GEO Monthly Delta Report
zubair-trabzada/geo-seo-claude
Compares a baseline and a current GEO audit for a client, calculates score changes and action item progress, and writes a monthly progress report.
When the user wants to figure out which marketing actually drives conversions and revenue, choose or interpret an attribution model, or reconcile conflicting numbers across tools.
$ npx skills add Nexus-JPF/note-companion --skill attribution -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install Nexus-JPF/note-companion attribution --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/Nexus-JPF/note-companion.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/attribution .claude/skills/attribution && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "attribution" agent skill from https://github.com/Nexus-JPF/note-companion/tree/master/.agents/skills/attribution into .claude/skills/attribution/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "attribution", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/Nexus-JPF/note-companion/tree/master/.agents/skills/attributionType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add Nexus-JPF/note-companion --skill attribution -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install Nexus-JPF/note-companion attribution --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Nexus-JPF/note-companion.git skills-src && mkdir -p .agents/skills && cp -r skills-src/.agents/skills/attribution .agents/skills/attribution && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "attribution" agent skill from https://github.com/Nexus-JPF/note-companion/tree/master/.agents/skills/attribution into .agents/skills/attribution/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "attribution", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add Nexus-JPF/note-companion --skill attribution -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install Nexus-JPF/note-companion attribution --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Nexus-JPF/note-companion.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/.agents/skills/attribution .cursor/skills/attribution && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "attribution" agent skill from https://github.com/Nexus-JPF/note-companion/tree/master/.agents/skills/attribution into .cursor/skills/attribution/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "attribution", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/Nexus-JPF/note-companion.git --path .agents/skills/attribution--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add Nexus-JPF/note-companion --skill attribution -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install Nexus-JPF/note-companion attribution --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Nexus-JPF/note-companion.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/.agents/skills/attribution .gemini/skills/attribution && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "attribution" agent skill from https://github.com/Nexus-JPF/note-companion/tree/master/.agents/skills/attribution into .gemini/skills/attribution/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "attribution", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install Nexus-JPF/note-companion attributionInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add Nexus-JPF/note-companion --skill attribution -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/Nexus-JPF/note-companion.git skills-src && mkdir -p .github/skills && cp -r skills-src/.agents/skills/attribution .github/skills/attribution && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "attribution" agent skill from https://github.com/Nexus-JPF/note-companion/tree/master/.agents/skills/attribution into .github/skills/attribution/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "attribution", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add Nexus-JPF/note-companion --skill attribution -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install Nexus-JPF/note-companion attribution --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Nexus-JPF/note-companion.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/.agents/skills/attribution .opencode/skills/attribution && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "attribution" agent skill from https://github.com/Nexus-JPF/note-companion/tree/master/.agents/skills/attribution into .opencode/skills/attribution/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "attribution", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
attributionWhen the user wants to figure out which marketing actually drives conversions and revenue, choose or interpret an attribution model, or reconcile conflicting numbers across tools.
Attribution is an agent skill from Nexus-JPF/note-companion. When the user wants to figure out which marketing actually drives conversions and revenue, choose or interpret an attribution model, or reconcile conflicting numbers across tools. Also use when the user mentions "attribution," "attribution model," "first-touch vs last-touch," "multi-touch," "which channel drives revenue," "what's my real CAC," "my dashboards disagree," "Google/Meta says X but GA says Y," "media mix model," "MMM," "incrementality," "geo lift," "holdout test," "how did you hear about us,"…
Its SKILL.md is about 5.2k tokens, which your agent loads only when the skill is triggered. The skill folder holds 7 other files, including reference files (for example `evals/evals.json`, `references/attribution-models.md` and `references/by-business-type.md`).
It sits in Marketing & SEO, covering Marketing analytics, AI search optimization and Product analytics. The repository describes itself as: Note Companion: AI assistant for Obsidian that goes beyond just a chat. (prev File Organizer 2000). The licence is MIT.
7 steps, taken from the step headings in SKILL.md.
Read from SKILL.md and the folder at commit 9cad635. It shows what the files ask for, not the result of running them.
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown).
From the folder's file list and the shell code blocks in SKILL.md.
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Attribution loads about 5.2k tokens when it runs, and up to ~15k if it reads all its reference files. Until then it costs about 247 tokens; SKILL.md has 2,565 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
The full file from Nexus-JPF/note-companion at commit 9cad635, republished under its MIT licence (© Nexus-JPF). 2,565 words, ~5,197 tokens.
.claude/skills/attribution/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.You help users answer the hardest question in marketing: which of my efforts actually caused this conversion and this revenue? Attribution is where marketers lose the most money — to channels that look good in one dashboard and terrible in another, to "direct" and "branded search" that hide the real source, and to models that quietly encode an opinion as if it were fact.
This skill has two pillars. Know which one the user needs before you dive in:
Most requests start with (A). Reach for (B) only when they control the surface and want to build.
Product context: check for .agents/product-marketing.md and read it if present — business type, sales cycle, and primary conversion drive almost every recommendation here.
State these up front so you don't rebuild neighboring skills:
references/conversion-tracking.md). Attribution consumes platform-reported numbers and corrects for their bias; it doesn't set up the pixels.Set expectations before touching a number:
When a user demands one true number, reframe: "We can get you a defensible, consistent number and a read on which channels are trending up. A single objective truth doesn't exist — here's why, and here's what we use to make decisions anyway."
The six standard models and when each one lies:
| Model | Credit rule | Best for | How it lies |
|---|---|---|---|
| First-touch | 100% to the first known touch | Top-of-funnel / demand-gen valuation; short cycles | Ignores everything that closed the deal; over-credits awareness channels |
| Last-touch | 100% to the last touch before conversion | Direct-response, quick e-comm | Over-credits bottom-funnel + branded search/direct; ignores what created demand |
| Last non-direct | 100% to last touch, skipping "direct" | A cheap fix for direct pollution | Still single-touch; just moves the blind spot |
| Linear | Equal credit to every touch | Long, multi-touch journeys where every step matters | Treats a throwaway visit like a demo; flatters high-frequency channels |
| Time-decay | More credit to touches nearer conversion | Longer cycles where recency matters | Under-credits the top of funnel; still an assumption, not a measurement |
| Position-based (U-shaped) | 40% first, 40% last, 20% middle | B2B with clear "created" + "closed" moments | The 40/40/20 split is arbitrary; middle touches get shortchanged |
| Data-driven (algorithmic/Shapley) | Credit from modeled marginal contribution | High-volume accounts with enough conversions | A black box; needs volume; can't see offline/dark touches it was never fed |
Rules of thumb:
For the model math, worked examples of one journey scored six ways, and Shapley explained plainly, see references/attribution-models.md.
Models split credit within your tracked data. Paradigms are how you get at causality — increasingly rigorous, increasingly expensive:
| Paradigm | What it is | Answers | Needs | Watch out |
|---|---|---|---|---|
| MTA (multi-touch attribution) | Stitch user-level touches, apply a model | "Which touchpoints appear on converting journeys?" | Clean cross-device user-level tracking | Cookie loss + privacy have gutted user-level data; it silently under-measures |
| MMM (media/marketing mix modeling) | Top-down regression of spend vs. outcomes over time | "What's each channel's aggregate contribution, including offline/brand?" | 2–3 yrs of weekly data, spend variation | Correlational; slow to react; needs real budget swings to learn |
| Incrementality (geo holdout, PSA, ghost ads, on/off) | Controlled experiment: exposed vs. withheld | "Did this channel cause lift I wouldn't have gotten anyway?" | Ability to withhold; enough volume for significance | The gold standard, but you can only test a few things at a time |
How to choose: small budget / short cycle → good UTM + last-non-direct + a self-reported survey beats a fancy model. Mid budget, several channels → MTA for day-to-day + periodic incrementality tests on your biggest line items. Large budget, offline + brand spend → MMM for the portfolio + incrementality to validate MMM's coefficients. Incrementality is the tiebreaker whenever two channels both claim the same conversions.
Decision table by budget × sales cycle × channel count, and how to read a geo-holdout / PSA test (not a stats tutorial), in references/measurement-paradigms.md.
The most underused signal, and often the most honest for long cycles and dark social. A post-conversion "How did you hear about us?" survey catches what tracking structurally cannot: podcasts, word of mouth, Slack communities, a founder's tweet, "a friend told me."
references/first-party-tracking.md.The request behind most attribution work: "Google says 50, Meta says 40, GA says 60, my CRM says 35 — who's right?" Nobody is. Here's the framework.
Why each source systematically lies:
| Source | Biased toward | Because |
|---|---|---|
| Ad platforms (Google/Meta/LinkedIn) | Over-counts itself | Claims view-through + click conversions in its own window; every platform counts the same sale; motivated to look good |
| GA / web analytics | Last non-direct click | Loses cross-device, loses cookie-blocked users, dumps the unknown into direct |
| CRM | Whatever the rep typed / the form captured | Human entry, lead-source overwrites, offline deals with no digital trail |
| Self-reported survey | The memorable touch | Recall bias; under-counts boring-but-real touches like retargeting |
How to triangulate:
The output is an honest allocation with confidence levels, not a false reconciliation to the decimal.
Where conversions hide, making real channels look weak:
The through-line: when "direct" and "branded search" dominate, your top of funnel is working and your attribution is hiding it. Say that explicitly — it's the single most common misread in marketing.
Defaults differ sharply. Summary here; full playbooks in references/by-business-type.md.
Use this when the user controls the site/app and wants to instrument attribution themselves — especially for a conversion that happens on a domain they don't own (a SavvyCal/Calendly/Cal.com booking, a Stripe Checkout page). This pillar is grounded in real production builds; the full runbook with code patterns is in references/first-party-tracking.md. The essentials:
First-party attribution is one idea: join anonymous browsing to the eventual conversion.
distinct_id and stamps first-touch properties ($initial_referrer, $initial_utm_*) on their events.identify() with a stable id (email or user UUID). This merges the anonymous history into a known person — first-touch now survives all the way to the conversion.identify() gapThe most common first-party failure: nothing ever calls identify(), so conversions never join to browsing history and every customer looks like they appeared from nowhere. (Framing adapted from Tessa Kriesel's PostHog approach.) The fix is to call identify at each real conversion. Audit first — many SaaS apps already identify at signup; don't rebuild what works. Find the specific un-instrumented conversions and close only those.
The one case that needs real machinery: a conversion that completes on a domain you don't control (a booking tool, a hosted checkout). You can't run your analytics there, so:
distinct_id to the outbound URL via the tool's metadata passthrough (e.g. ?metadata[ph_distinct_id]=<id>). One document-level listener covers every CTA — no per-link edits.$identify with the booking email as distinct_id and the smuggled anonymous id as $anon_distinct_id) plus a conversion event — joining the booking back onto the marketing journey.identify(), the current id becomes the user's email/UUID; leaking that into a third-party URL or merging on it corrupts profiles (person A's email folds into whoever books). Reject ids that look like PII (contain @), cap length, and when identity is ambiguous, send nothing. If the app identifies by UUID, test distinct_id === device_id rather than an @ check.accounts.google.com, checkout.stripe.com, login.*), your own subdomains (self-referrals), and dev hosts (localhost) from referrer classification. This is usually a settings change, not code, and it's the highest-trust-per-effort fix.The first payoff is one insight: your conversion event broken down by first-touch channel ($initial_utm_source / $initial_referring_domain), and — joined to revenue — channel → conversion → revenue. Confirm first-touch vs. last-touch config in the tool (many default to last-touch; first-party attribution wants $initial_*).
But first-touch alone can't run the multi-touch models from §2. Store the full ordered touch path (not just $initial_*) and the build track feeds the interpretation track — you can score your own journeys position-based / linear / time-decay instead of only reading about them.
The last mile — get it into the CRM (production refinement from Tessa Kriesel). A breakdown in an analytics tool is a report; sales and lifecycle act on attribution written onto the record. Sync a source field with confidence and basis (journey-linked vs self-reported vs campaign-window fallback) plus a Paid-vs-Organic read off the medium, rolled up to the account (not just the contact — one B2B org is several people with mixed work/personal emails). How pipeline/lifecycle then use it is revops' job.
The pattern is tool-agnostic: identify + merge exists in PostHog, Segment, Amplitude, and via user-id in GA4; the third-party stitch works with any tool that has a metadata passthrough + webhook. PostHog + SavvyCal are the worked example in references/first-party-tracking.md.
Deliver an attribution readout, not a data dump:
# Attribution Readout — [date]
## The question
[What decision this informs — e.g. "where should next quarter's budget go?"]
## Source of truth
[Which system defines the conversion count, and why]
## What each source says
| Channel | Platform-reported | GA | CRM | Self-reported | Our read |
|---------|------------------|----|----|--------------|----------|
[De-duped against source of truth; not summed]
## Model comparison (for long cycles)
[First-touch vs last-touch side by side; the gap is the insight]
## Confidence & gaps
[The attribution gap, the blind spots, what we can't see]
## Recommendation
[Allocation call with confidence levels; the tiebreaker test worth running]For implementation, see the tools registry. Key tools:
| Tool | Best For | MCP | Guide |
|---|---|---|---|
| PostHog | First-party attribution, identify/merge, funnels | - | posthog.md |
| GA4 | Web analytics, model comparison, user-id stitching | ✓ | ga4.md |
| Dub | Short-link + click attribution | ✓ | dub-co.md |
| Segment | CDP — route identify/track to every destination | - | segment.md |
| HubSpot | CRM lead-source + self-reported fields | ✓ | hubspot.md |
| Salesforce | CRM as revenue source of truth | - | salesforce.md |
| Supermetrics | Pull platform numbers into one place to reconcile | ✓ | supermetrics.md |
| RB2B | De-anonymize B2B website visitors | - | rb2b.md |
references/conversion-tracking.md).© Nexus-JPF, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
SKILL.md and 5 other files (references) in .agents/skills/attribution of Nexus-JPF/note-companion.
Open the folder on GitHubat commit 9cad635
We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in Nexus-JPF/note-companion, which our catalogue first saw on October 7, 2026.
Attribution next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Attribution this skillNexus-JPF/note-companion | 870 | 1 repos | ~5.2k | Automated safety check: Pass | MIT | |
| GEO Monthly Delta Reportzubair-trabzada/geo-seo-claude | 11k | — | ~2.4k | Automated safety check: Notes | MIT | |
| LLM Mention Trackingunifapi-agent/agents | 587 | — | ~1.8k | Automated safety check: Pass | MIT | |
| SEO SerankingAgriciDaniel/claude-seo | 18k | — | ~567 | Automated safety check: Pass | MIT | |
| Share Of Voiceindranilbanerjee/digital-marketing-pro | 855 | 1 repos | ~3.7k | Automated safety check: Pass | MIT | |
| SEO AI Search Share Of Voiceseranking/seo-skills | 160 | — | ~1.1k | Automated safety check: Pass | MIT |
zubair-trabzada/geo-seo-claude
Compares a baseline and a current GEO audit for a client, calculates score changes and action item progress, and writes a monthly progress report.
unifapi-agent/agents
When the user wants to track how often their brand or domain gets mentioned across ChatGPT and AI search engines over a set of prompts, and how that share of voice compares to named competitors over…
AgriciDaniel/claude-seo
SE Ranking AI visibility analyst (extension). An agent skill from AgriciDaniel/claude-seo.
indranilbanerjee/digital-marketing-pro
Calculate share of voice against named competitors across four dimensions — organic (volume-weighted keyword visibility), paid (Google Ads auction insights), social (mention volume with sentiment…
seranking/seo-skills
Measure AI Search share of voice for a target domain versus competitors across ChatGPT, Perplexity, Gemini, Google AI Overview, and AI Mode.
seranking/seo-skills
Build a phased SEO roadmap for a domain — quarter-by-quarter, tied to the site's competitive position, content gaps, technical debt, and AI Search readiness.
Nexus-JPF/note-companion
When the user wants to set up, improve, or audit analytics tracking and measurement.
Nexus-JPF/note-companion
When the user wants to conduct, analyze, or synthesize customer research.
Nexus-JPF/note-companion
When the user needs a comprehensive marketing plan for a client, a company they advise, or their own product.
Nexus-JPF/note-companion
When the user wants to research, profile, or analyze competitors from their URLs.
Nexus-JPF/note-companion
When the user wants to optimize post-signup onboarding, user activation, first-run experience, or time-to-value.
Nexus-JPF/note-companion
When the user wants to create, generate, edit, or optimize images for marketing — blog heroes, social graphics, product mockups, profile banners, listing visuals, or brand assets.
Categories
When the user wants to figure out which marketing actually drives conversions and revenue, choose or interpret an attribution model, or reconcile conflicting numbers across tools. Attribution is an agent skill from Nexus-JPF/note-companion. When the user wants to figure out which marketing actually drives conversions and revenue, choose or interpret an attribution model, or reconcile conflicting numbers across tools.
Attribution fits situations like: wants to figure out which marketing actually drives conversions and revenue; interpret an attribution model; reconcile conflicting numbers across tools; the user mentions attribution.
Run `npx skills add Nexus-JPF/note-companion --skill attribution -a claude-code`. Or copy the skill folder (.agents/skills/attribution in Nexus-JPF/note-companion) into .claude/skills/attribution in your project. Claude Code loads it when a task matches its description.
Run `npx skills add Nexus-JPF/note-companion --skill attribution -a codex`. Or copy the skill folder (.agents/skills/attribution in Nexus-JPF/note-companion) into .agents/skills/attribution in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Nexus-JPF/note-companion --skill attribution -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/attribution, .gemini/skills/attribution, .github/skills/attribution and .opencode/skills/attribution in your project.
SKILL.md names no scripts, command-line tools or credentials: Attribution is instructions for the agent only.
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
Attribution is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
About 5.2k tokens (SKILL.md is roughly 21k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 10k tokens, read only when the agent opens those files.
Skills that share tags, products or a category with Attribution: GEO Monthly Delta Report (zubair-trabzada/geo-seo-claude, 11k stars), LLM Mention Tracking (unifapi-agent/agents, 587 stars), SEO Seranking (AgriciDaniel/claude-seo, 18k stars) and Share Of Voice (indranilbanerjee/digital-marketing-pro, 855 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Nexus-JPF (a GitHub organization) maintains it in Nexus-JPF/note-companion, which has 870 GitHub stars. The repository holds 18 skills in this directory. The repository was last updated on October 7, 2026.
Source: Nexus-JPF/note-companion on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.