About

Each skill is a self-installing additive unit: its folder under .claude/skills/<name>/ carries its own apply steps (SKILL.md), and channel/provider skills fetch their code files from a long-lived upstream branch (channels, providers) with git fetch origin <branch> + git show origin/<branch>:path > path. Every apply is idempotent and safe to re-run.

Updating a skill means re-running its own apply. The apply re-fetches the latest files from upstream and overwrites the copied-in code, so newer versions land additively.

Run /update-skills in Claude Code.

How it works

Preflight: checks for a clean working tree and the upstream remote.

Detection: reads the channel and provider barrels to list which skills have copied code into your tree, and lists the operational/utility skills present under .claude/skills/.

Selection: presents the installed skills and lets you pick which to re-apply.

Re-apply: invokes each selected skill's own apply (e.g. /add-slack), which fetches its latest files. Then validates with build + test.

---

Goal

Help users pull the latest skill code from upstream by re-applying their installed skills, without losing local customizations and without merging any branch.

Operating principles

• Never proceed with a dirty working tree.
• Re-apply each skill through its own idempotent apply step — re-applying overwrites only that skill's code files; credentials, wiring, and DB state are untouched.
• Keep token usage low: detect installed skills with git and barrel reads; let each skill's apply do its own fetching.

Step 0: Preflight

Run:

• git status --porcelain

If output is non-empty:

• Tell the user to commit or stash first, then stop.

Check remotes:

• git remote -v

If origin does not point at a NanoClaw upstream (or you want to verify it has the skill branches), confirm with the user before continuing. The default upstream is https://github.com/nanocoai/nanoclaw.git.

Fetch the branches that carry skill code:

• git fetch origin channels providers --prune

Step 1: Detect installed skills

Channels — read src/channels/index.ts and collect each import './<name>.js'; line, excluding cli. Each <name> maps to the /add-<name> skill.

Providers — read src/providers/index.ts the same way; each imported provider maps to its /add-<name> skill.

Operational and utility skills — list the folders under .claude/skills/. These copy no code into the tree, so "re-applying" them just re-reads their instructions; only include them if the user specifically wants to re-run a workflow.

Build the candidate list from the channels and providers actually wired into the barrels — those are the skills whose copied code can be refreshed from upstream.

Step 2: Present results

If no channel or provider skills are installed:

• Tell the user there are no code-carrying skills to update. List any operational skills present for reference.
• Stop here.

If installed channel/provider skills are found:

• Show the list (e.g. slack, discord, opencode).
• Use AskUserQuestion with multiSelect: true to let the user pick which skills to re-apply.
  • One option per installed channel/provider (e.g. "Re-apply Slack (/add-slack)").
  • Add an option: "Skip — don't update any skills now".
• If the user selects Skip, stop here.

Step 3: Re-apply each selected skill

For each selected skill (process one at a time):

1. Tell the user which skill is being re-applied.
2. Invoke the corresponding /add-<name> skill using the Skill tool.
   • Its apply runs its own pre-flight, fetches the latest files from upstream (git fetch origin <branch> + git show origin/<branch>:path > path), overwrites the copied-in code, and installs any pinned dependency.
   • Re-applying is additive: it refreshes only that skill's own files. The barrel import line is left in place if already present, and .env credentials and DB wiring are untouched.
3. If a skill's apply reports a problem (a missing upstream file, a failing dependency install), record it and continue with the remaining skills.

Step 4: Validation

After all selected skills are re-applied:

• pnpm run build
• pnpm test (do not fail the flow if tests are not configured)
• If the re-apply changed any files under container/ (git diff --name-only -- container/ is non-empty), rebuild the agent image so new sessions pick up the new code: ./container/build.sh. Skill code that lives in the container (e.g. a provider's runtime) keeps running the old image until this is done — the rebuild is what makes the fix live, not the file copy. If nothing under container/ changed (e.g. only a channel adapter was re-applied), skip it.

Each channel/provider skill copies in its own registration test; those run as part of pnpm test and assert the barrel still registers the adapter against the freshly fetched code.

If build fails:

• Show the error.
• Only fix issues clearly caused by the refreshed code (missing imports, type mismatches).
• Do not refactor unrelated code.
• If unclear, ask the user.

Step 5: Summary

Show:

• Skills re-applied (list)
• Skills skipped or that reported problems (if any)
• New HEAD: git rev-parse --short HEAD

If the service is running, remind the user to restart it to pick up the refreshed code.