Council

Council — Multi-Skill Orchestrator

Run the user's request through several skills in isolation (one subagent per skill, each seeing only its own skill's instructions), then aggregate: either one merged answer or the single best one. You (the main conversation) are the orchestrator and the aggregator — never delegate aggregation to a subagent.

Isolation & trust model (read before first run)

Isolation here is achieved by prompt construction, not sandboxing. Each subagent is a fresh general-purpose agent whose prompt contains only one skill's SKILL.md plus the user's request — but that agent still runs with the same tool access any subagent has (file reads, Bash, network, etc.). Putting a skill on a council therefore grants it exactly the capability it would have if the user invoked it directly. Council does not add a security boundary and does not vet the skills it dispatches. Only add skills you already trust to the discoverable set, and treat an imported skillset (see Import / export) as a list of names to run, never as a reason to install skills you haven't reviewed.

Helper scripts

All state and discovery logic lives in two scripts (both print JSON):

# Discover installed skills (name + description; project scope wins on
# name collision; council itself is excluded):
python3 ~/.claude/skills/council/scripts/discover_skills.py --project-dir "$PWD"
python3 ~/.claude/skills/council/scripts/discover_skills.py --format list        # numbered, for showing the user
python3 ~/.claude/skills/council/scripts/discover_skills.py --content <name>     # full SKILL.md, for subagent prompts

# Skillset store (~/.claude/skills/council/skillsets.json, created on first write):
python3 ~/.claude/skills/council/scripts/skillset_store.py list
python3 ~/.claude/skills/council/scripts/skillset_store.py last-run
python3 ~/.claude/skills/council/scripts/skillset_store.py create <name> --skills a,b,c
python3 ~/.claude/skills/council/scripts/skillset_store.py rename <old> <new>
python3 ~/.claude/skills/council/scripts/skillset_store.py set-skills <name> --skills a,b,c
python3 ~/.claude/skills/council/scripts/skillset_store.py add-skills <name> --skills d
python3 ~/.claude/skills/council/scripts/skillset_store.py remove-skills <name> --skills b
python3 ~/.claude/skills/council/scripts/skillset_store.py delete <name>
python3 ~/.claude/skills/council/scripts/skillset_store.py export <name> --out file.json
python3 ~/.claude/skills/council/scripts/skillset_store.py import file.json [--name X] [--overwrite]
python3 ~/.claude/skills/council/scripts/skillset_store.py record-run --type skillset --name X --mode combined
python3 ~/.claude/skills/council/scripts/skillset_store.py record-run --type manual --skills a,b --mode best

Never edit skillsets.json by hand — always go through the store script.

Entry points

• /council (no args, or with the request inline) → main flow below.
• /council manage → skip straight to Managing skillsets.
• Natural-language trigger → confirm first ("Want me to run this through Council — pick a few skills and compare?"), then main flow.

If the user hasn't yet stated the request they want run through the skills, ask for it before dispatching (selection can happen first — the request is only needed at dispatch time).

Main flow

Step 1 — Discover and load state

Run discover_skills.py (JSON) and skillset_store.py last-run (one Bash call is fine). If discovery returns no skills, tell the user and stop.

Step 2 — Selection question

Ask ONE AskUserQuestion with these options:

1. "Re-run last" — ONLY if last-run returned a non-null lastRun. The label stays short; put the specifics in the option description so the user knows exactly what re-runs, e.g. "Runs the 'Writing' skillset in merged mode (your last run)" or, for a manual last run, list the skills. Never show this option on first-ever use.
2. "Choose manually" — pick skills ad hoc (below).
3. "Skillset list" — browse saved skillsets (below).
4. "Create skillset" — build, save, and immediately run a new one (below).

If "Re-run last" is chosen: skip mode selection entirely (mode is part of the remembered config) and go straight to dispatch. If the last run pointed at a skillset, re-read its current skill list from the store (it may have been edited since).

Step 2a — Choose manually

• ≤4 discovered skills: one AskUserQuestion with multiSelect: true, one option per skill (description = the skill's description, truncated).
• >4 skills: show the numbered list from discover_skills.py --format list as plain text and ask the user to reply with comma-separated numbers (e.g. "1, 3, 5"). Prefer this over paginated picker rounds. Map numbers back to names; confirm the resolved names in one line before proceeding.

Step 2b — Skillset list

• Run skillset_store.py list. If empty, say so and offer to create one.
• Show a numbered plain-text list: name, skills, and lastModeUsed if set. User replies with a number.
• If the chosen skillset has a lastModeUsed, offer it as a quick-confirm ("Use combined mode again, like last time?") instead of the full mode question; otherwise proceed to Step 3.

Step 2c — Create skillset

1. Ask for a name (plain text question is fine).
2. Run the manual picker (Step 2a) to choose its skills.
3. skillset_store.py create <name> --skills ...
4. Proceed immediately to Step 3 and run it.

Step 3 — Mode selection

Ask via AskUserQuestion (skip if already decided by "Re-run last" or a quick-confirmed lastModeUsed):

1. "One merged answer" — synthesize all candidates (mode combined).
2. "Single best answer" — judge and present the strongest (mode best).

Step 4 — Cost warning

If more than 5 skills are selected, warn before dispatching: "You've selected N skills — this will run N parallel subagent calls before combining them. Continue?" (AskUserQuestion, Continue / Trim the list). Threshold is fixed at 5 for now.

Step 5 — Record, then dispatch in parallel

First record the run config:

• skillset run: record-run --type skillset --name <name> --mode <mode>
• manual run: record-run --type manual --skills a,b,c --mode <mode>

Then, for each selected skill, fetch its full instructions with discover_skills.py --content <name>. If that fails (skill missing — possible after an import or an uninstall), do NOT abort: mark that skill failed and dispatch the rest.

Dispatch ALL subagents in a SINGLE message (one Agent tool call per skill in the same block — that is what makes them run concurrently). Each uses subagent_type: general-purpose and this prompt shape, with NOTHING else — no conversation history, no other skills' content:

You are executing exactly one skill in isolation.

<skill_instructions>
{full SKILL.md content of the one assigned skill}
</skill_instructions>

<user_request>
{the user's original request, verbatim}
</user_request>

Rules:
- Follow ONLY the skill instructions above. Do not invoke, load, or borrow
  from any other skill, even if one seems relevant.
- Do not ask the user questions; make reasonable assumptions and state them.
- Your final message is your complete answer to the request, produced the way
  this skill would produce it.

Step 6 — Failure-tolerant aggregation (done by YOU, not a subagent)

Collect all results. A subagent that errored, timed out, returned nothing usable, or whose skill file was missing is a failed candidate; the rest proceed. If ALL failed, report that plainly and stop.

• best: read every successful candidate, silently judge which is strongest for the user's request, and present that answer directly and completely. Do not narrate the judging or reveal scores.
• combined: merge the distinct, non-redundant strengths of the candidates into ONE coherent answer. This is a real synthesis — not a stitched list of "skill X said… skill Y said…".

Step 7 — Output

• Show ONLY the final aggregated answer.
• If any skill failed, append one short note, e.g. "Note: the xlsx skill didn't respond and wasn't included above."
• Do NOT show individual raw outputs by default.

Reveal on request

If the user later asks "show me each one" / "what did each skill say", present the individual outputs from that run, each labeled with its skill name, pulled from what is already in context. Never re-run the subagents for this.

Managing skillsets (/council manage)

Show the numbered skillset list (skillset_store.py list), then ask what to do (rename / edit skills / delete / export / import) and apply it with the matching store command. For edit, show the current skill list plus the discovery list, and use add-skills / remove-skills / set-skills. For delete, confirm first.

Import / export

• Export: export <name> --out <file>.json — a standalone shareable file, shape {"name": "...", "skills": [...]}.
• Import: import <file> — then immediately cross-check the imported skill names against discover_skills.py output and tell the user which (if any) are NOT installed. Always surface this caveat: a skillset is just a list of skill names — it does not bundle the skill files themselves, so missing skills stay missing until installed, and are flagged again at run time by the Step 5 failure handling. Never silently drop them.