curator

name	curator
description	Load when a dreamcontext brain has grown additively and needs a periodic refactor pass that re-orders content into the right shape — or the user invokes `/curator`. Triggers: "curate the brain", "re-organize my context", "the knowledge base has gotten messy", "clean up / refactor the brain", "conform everything to current conventions", "dedup the knowledge", "fix the structure, not just append to it", or any time the corpus has drifted from current architecture conventions (duplicate knowledge, topics living as both feature and knowledge, stale task statuses, off-vocabulary tags, a flat knowledge dump that should be foldered). This is the interactive, sub-agent-driven brain REFACTOR — the pass that sleep won't do. It is allowed to MOVE, MERGE, SPLIT, RENAME, RE-TYPE, and RETIRE content to reach the right knowledge / feature / task / version / objective shape.
user-invocable	true
alwaysApply	false
tags	["curator","refactor","reorganize","cleanup","dedup","single-source-of-truth","orchestration","sub-agents","dreamcontext"]

Curator — interactive, sub-agent-driven brain refactor

You are the orchestrator. Like goal-skill, initializer, multi-review, and council, you do not hand-author the bulk of the work yourself — you dispatch sub-agents, read their results, gate the transitions, and drive convergence loops until the brain conforms. Your value is judgment at the gates and the conversation with the user about the shape — not running every knowledge merge by hand.

Why this exists, vs sleep. Sleep/consolidation is conservative and additive — it polishes whatever shape already exists and keeps appending. The curator is the periodic brain refactor sleep won't do: it re-orders content into the right shape and is explicitly allowed to MOVE, MERGE, SPLIT, RENAME, RE-TYPE, and RETIRE. A brain is curated when the verifier passes: doctor clean, zero duplicate-topic knowledge, zero topics living as both a feature and a knowledge file, every task/feature/version status reflecting reality, tags normalized to the vocabulary, recall precision not regressed, and an immediate second run finding nothing material to change (convergence). Not when "some files got tidied".

Conventions are read AT RUN TIME — never hardcoded. The whole point is to conform the brain to today's architecture, not the shape that accreted. Every target shape comes from the live system: the installed dreamcontext skill + references/, dreamcontext taxonomy vocab, and the project's own core/0.soul.md / 1.user.md. When the conventions change, the curator's behavior changes with them — no edits to this skill required.

When to invoke

• /curator (primary entry).
• The brain has clearly drifted: duplicate/near-duplicate knowledge, a flat knowledge/ dump that should be foldered, topics living as both a feature and a knowledge file, stale in_progress tasks that actually shipped, off-vocabulary tags, bloated core files.
• "Re-organize / refactor / curate the brain", "dedup the knowledge", "conform to conventions".

Scale the machinery to the drift. A small, tidy brain does not need the full five-auditor fan-out. Say so and run a light path: one curator-auditor over the whole corpus + one curator-worker for the handful of fixes, then verify. Reserve the full orchestration for a brain with real accreted drift across domains.

Commitment ritual (do this FIRST — non-negotiable)

1. Announce: tell the user you're running the curator orchestration and what it's allowed to do (MOVE/MERGE/SPLIT/RENAME/RE-TYPE/RETIRE), and that it mutates the real corpus — so it runs plan-first and you'll confirm the shape before executing.
2. TodoWrite the phases (0–7) as items. A phase isn't done until its gate passes.
3. Track iteration counts in the todo text for each convergence loop, e.g. Phase 4: execute (batch 3/6), Phase 6: verify (iteration 2/3).

Skipping the ritual is the first step toward executing destructive moves the user never saw.

Orchestration flow

flowchart TD
    P0[Phase 0 — RECOGNIZE & SCOPE: confirm brain exists + drifted, announce, pick scope, READ current conventions] --> P1[Phase 1 — AUDIT: fan out curator-auditor, one per domain -> reorg findings]
    P1 --> P2[Phase 2 — REORG PLAN: merge findings into ONE source→action→target plan; de-conflict; batch]
    P2 --> P3{Phase 3 — CONFIRM THE SHAPE: show the dry-run plan, user adjusts -> approved?}
    P3 -->|user revises| P2
    P3 -->|approved| P4[Phase 4 — EXECUTE: fan out curator-worker per batch; track coverage]
    P4 --> P5[Phase 5 — RECONCILE: knowledge index, releases/versions, taxonomy.json]
    P5 --> P6{Phase 6 — VERIFY: curator-verifier — PASS? + idempotency re-run}
    P6 -->|FAIL and iter < 3| P4
    P6 -->|cap reached| ESC[ESCALATE to user with the unresolved gaps]
    P6 -->|PASS| P7[Phase 7 — REPORT: what moved/merged/retired + recall before/after + offer a sleep]

Phase 0 — RECOGNIZE & SCOPE (interactive — ask, then wait)

1. Confirm there IS a brain and it has drifted (dreamcontext doctor, knowledge index, features list, tasks list --all). If the brain is missing/sparse, this is the wrong skill — point the user at initializer instead.
2. Read the current conventions so the whole run targets today's shape: the installed dreamcontext skill + references, dreamcontext taxonomy vocab, core/0.soul.md, 1.user.md.
3. Announce (per the ritual) and ask only what you can't determine (keep it short):
   • Scope: the whole brain, or one domain (knowledge / features / tasks / versions / objectives)?
   • Anything off-limits — files/areas you should not touch this pass?
   • Confirm they want a real run (it mutates the corpus) — the plan is shown before execution. On a clean git tree, note it; if there are uncommitted changes, recommend committing first so the reorg diff is reviewable in isolation. Wait for the answers; capture them in TodoWrite.

Phase 1 — AUDIT (sub-agent fan-out → reorg findings)

Dispatch curator-auditor (read-only). For a full curate, fan out in parallel, one auditor per domain (single message, multiple Agent calls), each blind to the others — you merge their findings:

Domain	What it audits
knowledge	bloat (COMPRESS), tag drift (RETAG), flat files that should be foldered (MOVE), near-duplicates (MERGE), stale files (RETIRE)
ssot	the cross-cutting single-source-of-truth pass — topics as BOTH feature and knowledge, duplicate knowledge, overlapping features → fold/redirect to one home
features	reconcile status to reality, rename to current vocabulary, dedup vs knowledge, flag stale
tasks	finished tasks still open (STATUS-BUMP), duplicate/stale tasks (MERGE/RETIRE), orphans → attach to a planning version
versions	reconcile release/version statuses so they're tidy and consistent
objectives	PO-authored roadmap objectives (core/objectives/*.md): dangling depends_on/task links, stale status overrides, malformed dates/metrics, target dates long past with no progress — flag; never rewrite PO prose (STATUS-BUMP/RETAG only, PO owns the file)

Give each auditor its domain + the conventions you read in Phase 0. Each returns a source → action → target findings table. A finding that says "clean up knowledge" without naming each file and the exact action is rejected — send it back.

Phase 2 — REORG PLAN (you synthesize)

Merge the auditors' findings into ONE concrete reorg plan — source → action → target per item. This is your synthesis work (not a sub-agent's):

• De-conflict. Two auditors touching the same file → one action wins. Sequence dependent moves (RE-TYPE before the RETIRE of the original; MERGE survivors chosen before their MOVEs).
• Batch the plan into independent units a worker can own without racing another (group by folder / topic cluster; never split a MERGE pair across two workers).
• Keep the plan reviewable: a flat list the user can read top-to-bottom, each row carrying the why (the convention it satisfies).

Phase 3 — CONFIRM THE SHAPE (interactive gate — the user owns the shape)

Show the user the dry-run reorg plan: every source → action → target row, grouped by domain, with risk notes (anything that could move recall precision or a wikilink graph). This is where the user's intent wins — they veto a merge, keep a "duplicate" that's intentional, rename a target folder, downgrade a RETIRE to an archive. Iterate Phase 2 ↔ 3 until they approve. Do not execute until the plan is approved — a wrong MERGE/RETIRE is expensive to unwind.

Before executing, capture a recall BEFORE snapshot: pick ~5 seed queries spanning the domains touched and record dreamcontext memory recall "<q>" top-3 for each. The verifier diffs against this.

If running fully autonomously with no user, adopt the synthesized plan, record that you chose it, and surface it in the Phase 7 report for confirmation — but still skip any row flagged destructive + ambiguous, and list it as deferred.

Phase 4 — EXECUTE (sub-agent fan-out — the core)

Dispatch curator-worker over the approved plan, one batch per worker so each fits in context. Use parallel for independent batches; pipeline/sequential when batches depend on each other (a RE-TYPE that another batch's MERGE survivor points at). Each worker applies its batch via the CLI (knowledge move, knowledge merge, tasks status, features set), distills merged prose, and repoints wikilinks. Track coverage in TodoWrite (batch N/M). Loop until every plan row is applied or consciously deferred. Nothing is silently skipped — at the cap (3 passes) with rows unapplied, ESCALATE with the list. Re-dispatch failed batches; don't drop them.

Phase 5 — RECONCILE

Centralized cleanup after the workers (you or a final worker pass): rebuild/verify the knowledge index is coherent, reconcile core releases / version statuses, ensure any new canonical tags are in core/taxonomy.json (taxonomy add), and confirm no [[wikilink]] dangles.

Phase 6 — VERIFY (the real gate)

Dispatch curator-verifier (read-only + Bash) with the seed queries + the BEFORE recall snapshot. It returns PASS | FAIL with evidence: doctor clean, knowledge index coherent, zero duplicate-topic knowledge, zero topic-as-both-feature-and-knowledge, statuses reflect reality, taxonomy normalized, no dangling wikilinks, recall not regressed vs the snapshot.

• FAIL → route back to Phase 4, fix the specific gaps, re-verify. Cap = 3 → ESCALATE.
• PASS → run the idempotency check: an immediate second audit must find nothing material to change. Residual churn means the conventions weren't reached — treat it as a FAIL and loop. When the re-run is clean, the brain is curated.

Phase 7 — REPORT

Summarize what moved / merged / split / re-typed / retired (counts + the notable ones), the recall before/after for the seed queries (proving no regression), anything consciously deferred (and why), and then offer a sleep so the freshly-reorganized corpus is consolidated and the index/staleness warm.

Convergence rules (how the loops end)

• Every loop has a hard iteration cap of 3. Hitting it means ESCALATE to the user — never "good enough, the structure's better than it was".
• Update the TodoWrite count before each loop-back. Past the cap → stop and escalate with specifics.
• "Curated" is defined by Phase 6 PASS plus a clean idempotency re-run — not by the corpus looking tidier.

Red Flags — STOP, you're about to corrupt the brain

Thought	Reality
"I'll just start moving and merging files."	Plan first, confirm the shape (Phase 3), THEN execute. The curator mutates real content.
"I know the conventions, no need to read them."	Read them at run time (Phase 0). The brain conforms to today's shape, which you may be misremembering.
"These two files look similar — I'll delete one."	MERGE folds + repoints + preserves; RETIRE archives. Silent deletion loses signal and dangles wikilinks.
"This task is probably done, bump it to completed."	Reality-based only. Cite the changelog/release/code evidence, or leave it.
"Recall is fine, skip the before/after."	A reorg can drop a relevant doc from reach. Snapshot before, diff after — it's an acceptance criterion.
"Verifier passed, we're done."	Not until the idempotency re-run is clean. Residual churn = conventions not reached.
"It's a feature AND a knowledge file — leave both."	One home per topic. RE-TYPE / fold to the canonical one; the verifier fails this.
"I'll author the whole reorg myself."	The orchestrator dispatches auditors + workers. You synthesize the plan and gate; you don't run every merge by hand.

Rationalization table

If you think…	The truth is…	So…
"Auditing every domain is overhead; I'll eyeball it."	One pass over a drifted brain misses cross-cutting dupes and status drift.	Fan out an auditor per domain; merge their findings.
"The user will just approve the plan, skip the gate."	A wrong MERGE/RETIRE is expensive to unwind once files move.	Confirm the shape in Phase 3 before executing.
"Conventions don't change that often, hardcoding is fine."	The point of the curator is to track current conventions. Hardcoding makes it stale the day the skill changes.	Read taxonomy vocab + the live skill + soul at run time.
"Verifier will rubber-stamp."	A mis-prompted verifier rubber-stamps. Give it the checklist + the recall snapshot and demand evidence.	Treat FAIL as binding; loop or escalate.

Hard rules

• Orchestrator drives sub-agents. Auditor (intake) → worker (fan-out execute) → verifier (gate). You synthesize the plan and gate; you don't run the whole reorg by hand.
• Read conventions at run time. taxonomy vocab + the installed skill + soul define the target shape.
• Plan-first, confirm the shape (Phase 3) before executing. The curator mutates real content.
• Preserve signal. MOVE/MERGE/RETIRE keep content findable and repoint every inbound [[wikilink]]. Never silent-delete a topic.
• One home per topic. Feature or knowledge, never both — the verifier enforces it.
• CLI for structure, native edits for prose — knowledge move/merge, tasks status, features set; hand-edit only the wording the CLI doesn't own.
• Reality-based status. Bump only what is demonstrably done, with cited evidence.
• Recall must not regress. Snapshot seed queries before; the verifier diffs after.
• Caps are hard (3 per loop). At the cap, escalate — never declare curated.
• Done = Phase 6 PASS + a clean idempotency re-run. Use the dreamcontext skill throughout.

Relationship to other surfaces

Surface	Stage	Relationship
curator (this)	Periodic brain refactor	Re-orders an existing brain into the current shape — MOVE/MERGE/SPLIT/RENAME/RE-TYPE/RETIRE. The pass sleep won't do.
curator-auditor / -worker / -verifier	This skill's workers	Audit (findings) → fan-out execute → PASS/FAIL gate. Dispatched at Phases 1 / 4 / 6.
initializer	First-run / bootstrap	Builds the brain from raw material. Curator refactors an existing one. Use initializer to create, curator to re-shape.
Sleep / consolidation	Ongoing, additive	Sleep polishes + appends conservatively. Curator is the periodic structural refactor sleep deliberately avoids. Offer a sleep after a curate (Phase 7).
goal-skill	End-to-end build of a goal	The orchestration pattern this skill mirrors (plan→review→implement→validate ≈ audit→confirm→execute→verify).

Slash command wiring

/curator invokes this skill. The natural-language triggers in When to invoke also load it. (Named curator, distinct from sleep — sleep consolidates additively; the curator refactors.)