Claude-Mind

Produces an agent completion report showing what changed since the last status marker: completed goals, new tree encodings, emitted findings, resolved hypotheses, and in-flight work. Use whenever the user asks "what have you done", "what's the status", "give me a recap", or requests a dashboard; also use when the agent needs to summarize progress before a handoff, stop, or consolidation checkpoint. Writes {agent}/COMPLETION-REPORT.md (its git history is the permanent archive; the reports/ directory is abolished).

Handles the all-goals-blocked state inside the aspirations loop (phases B0-B7): scans the coordination board, generates constraint-aware aspirations, runs the idle playbook, triggers evolution, kicks off research, performs reflection, and applies exponential backoff. Use whenever the goal selector returns zero executable goals AND selection_reason starts with "all_blocked" — the orchestrator invokes this automatically. Internal-only sub-skill of /aspirations; not user-invocable.

Reviews aspirations approaching completion: sweeps remaining goals for outstanding work, checks motivation fulfillment, runs the maturity gate (Phase 7.4 intent satisfaction), decides archival or continuation, and creates replacement aspirations. Use whenever an aspiration reaches high completion_ratio, the zombie scan (aspirations-precheck Phase 0.5.0a) surfaces high-completion-stale-blocked aspirations, or an aspiration's last executable goal finishes.

Runs session-end consolidation — the hippocampal sleep-replay pass that compresses session observations into long-term memory. Handles micro-hypothesis sweep, encoding queue processing, knowledge debt sweep, tree rebalancing, experience-to-skill mining, skill health check, aspiration archive, user recap, handoff writeout, and restart loop cycle. Use whenever the aspirations loop stops (any stop condition), before agent-state transitions to IDLE, or when the orchestrator hits an explicit consolidation checkpoint.

Runs the autonomous evolution engine: assesses developmental stage, tunes config parameters, performs self-driven gap analysis, applies novelty filters, enforces caps, calibrates pattern signatures, archives strategies, runs the /forge-skill check, and curates skill health. Use whenever Phase 9 performance-based triggers fire, the user runs /aspirations evolve, or the orchestrator schedules a mandatory evolution pass. Internal sub-skill of /aspirations.

Phase 4 of the aspirations loop: executes a selected goal end-to-end with precondition checks, LLM-driven intelligent retrieval, memory deliberation, subagent delegation, primary execution, fail-fast cascade, experience archival, context-utilization feedback, domain post-execution steps (commit/push per world/conventions), knowledge reconciliation, and batch execution. Fires only when called from inside the /aspirations orchestrator — after /aspirations-select has chosen a goal and /decompose has broken it into primitives. Never invoke directly from reader or assistant mode.

Runs pre-selection checks at the start of every aspirations-loop iteration: completion runners, aspiration health, guardrail checks, blocker resolution re-probe, zombie-aspiration scan (Phase 0.5.0a), and recurring-goal surfacing. Use whenever the aspirations loop starts a new iteration and needs to tidy state before /aspirations-select runs. Internal sub-skill — invoked only from inside the orchestrator, never by the user.

Runs the autonomous aspiration loop — the perpetual heartbeat that selects, executes, verifies, reflects on, and evolves goals forever. This is the core orchestrator for autonomous mode. Use whenever /boot finishes in autonomous mode, when re-entering the loop after autocompact recovery, or when the user runs /aspirations {sub-command} (status, next, loop, evolve, complete, add). Must NEVER be invoked from reader or assistant mode — loop restrictions enforce this.

Runs the Spark Check (Phase 6) and Immediate Learning (Phase 6.5) of the aspirations loop: adaptive spark questions, all sq-XXX handlers (including sq-012 self-purpose update), aspiration-level spark, and immediate capture of reasoning-bank entries, guardrails, and forge awareness. Use whenever a goal completes — this is the recursive self-improvement mechanism that captures learning in-flight instead of deferring to /reflect. Internal sub-skill of /aspirations.

Entry point for autonomous mode — runs the status report (hypothesis readiness, pipeline state, accuracy stats, meta-memory counts), invokes /prime for full context load, then hands off to the /aspirations loop. Use only when /start activates autonomous mode or when recovering the loop after autocompact. NEVER invoke from assistant or reader mode; those modes use /prime alone without handing off to the loop.

Creates new aspirations from three source modes — from-user (parse user text), from-self (autonomous gap-driven, optionally --plan for research-backed deliberation), and from-followup (fast-path: one aspiration with a single 'Design implementation plan and file sub-goals here' seed goal). USE WHENEVER you catch yourself saying 'I'll note this for later', 'worth investigating', 'deserves its own aspiration', 'follow up on', 'file as an idea', 'circle back', or 'noting for later' DURING goal execution — invoke from-followup IMMEDIATELY with the observation, do not defer to insights.jsonl (those accumulate unprocessed). ALSO USE when the user says 'create an aspiration', 'add a project', 'start a new effort', 'capture this', or 'file for later'. The from-followup path defaults to sprint scope + MEDIUM priority, auto-derives title, and skips introspective-scan + interestingness-filter + priority-review. Writes to aspirations.jsonl via aspirations-add.sh.

Performs HTN (Hierarchical Task Network) decomposition: breaks a compound goal into a sequence of primitive, directly-executable sub-goals. Use whenever a selected goal is too abstract or multi-step to execute as-is (selector or Phase 4 flags it as compound), the user says "break down this goal", or /aspirations-execute encounters a goal whose primary action would span multiple atomic operations. Produces child goals linked back to the parent.

Fires whenever the aspirations-precheck cadence hits 75 completed goals — an autonomous structured 7-lane self-audit that converts the user's proven-high-yield diagnostic question into a routine. Sweeps memory hygiene (including insight curation from agents/{agent}/insights.jsonl — distills unprocessed entries into tree/reasoning-bank/guardrails/experience then bulk-marks processed), out-of-cycle completions, unblocks, forward backlog, /verify-learning gaps, meta tuning, and the felt-sense question (where is the pain, what would I change). Writes outputs directly — tree nodes, guardrails, reasoning-bank entries, new goals, verify-learning checks, meta edits. Material Self findings route through the Self-update protocol (guard-380 post-notification); cosmetic findings journal only. Use when the user wants to force the sweep on demand (/felt-sense-checkin) or the precheck cadence triggers automatically. Distinct from fresh-eyes-review (periodic local portfolio self-audit, no email push) and sq-012 (post-goal, n

Forges a new SKILL.md from a recurring capability gap recorded in meta/skill-gaps.yaml, registers it in world/forged-skills.yaml, creates companion scripts for restricted operations, announces on the message board, and adds a validation goal. Use whenever a gap reaches the forge threshold (times_encountered >= 2, estimated_value >= medium, no duplicate skill exists) and the curriculum permits forging, or the user runs /forge-skill list / skill {gap-id} / check / dismiss {gap-id}. Wraps Anthropic's generic skill-authoring pattern (see anthropics/skills/skill-creator) with this agent's gap-detection, registry, and validation loop.

Periodic local self-audit of world/program.md — fires when the every-100-goals precheck cadence trips, or on user demand (/fresh-eyes-program). Assembles a briefing (The Program body, both agents' Self summaries, cross-agent aspiration portfolio, recent completions, drift signals), writes it to agents/{agent}/temp/ (a staging file drained to the knowledge tree), and posts a one-line summary to the coordination board. No email push, no user-approval gate — the user reviews changes via git log and tracked signals at their own pace. Sibling to /fresh-eyes-review (per-agent Self, 25 goals). Closes the 'program.md has no systematic evolution path' gap.

Periodic local self-audit (cadence: every 25 goals). Assembles a portfolio-direction briefing (Self snapshot, aspiration portfolio, evolution signals, partner activity), writes it to agents/{agent}/temp/ (a staging file drained to the knowledge tree), and posts a one-line summary to the coordination board. No email push, no user-approval gate — the user reviews changes via git log and tracked signals at their own pace. Use whenever the user wants to force a portfolio review on demand (/fresh-eyes-review), or the precheck cadence triggers automatically (--cadence). Distinct from sq-012 (post-goal, narrow) and /priority-review (user-pull, ranking-only).

Primes the agent's active context by loading accumulated knowledge: self.md identity, world/program.md shared purpose, all active guardrails, universal + active reasoning-bank entries, category-specific tree nodes (top in-progress and HIGH-priority pending goal categories), recent coordination-board messages, and cross-agent musings. Use whenever a session starts in any mode, when /boot hands off to the aspirations loop, or when switching agents — without priming, the agent answers domain questions from amnesia. Internal sub-skill.

Shows the priority dashboard (all active aspirations ranked by aggregate goal score) and lets the user interactively reorder priorities to update the aspiration queue. Use whenever the user says "what are you working on next", "re-rank my priorities", "show me the priority dashboard", "show the queue", or invokes /priority-review directly. Closes the feedback loop between autonomous goal selection and user strategic direction. Valid in any mode including reader.

Reflects on a just-resolved hypothesis or goal outcome: builds the Antecedent-Behavior-Consequence (ABC) chain, captures execution pattern signatures, and processes batched micro-hypotheses. Use whenever a hypothesis resolves in the pipeline and reflection depth is "outcome" (not full self-model reflection), or /reflect dispatches with --on-hypothesis / --on-execution / --batch-micro. Produces reasoning-bank entries and new pattern signatures.

Orchestrates Reflexion-based learning: dispatches to /reflect-on-outcome (hypothesis ABC chains, execution patterns, batch micro-hypotheses), /reflect-on-self (pattern synthesis, Level 2 self-model, calibration), or /reflect-maintain (memory curation, active forgetting, aspiration grooming) based on --mode. Use whenever the aspirations loop hits a reflection cadence, a hypothesis resolves, the user asks to "reflect on recent work", or after major outcomes that warrant pattern extraction.

Resolves open hypotheses whose horizons have elapsed, extracts lessons from each outcome, calculates per-category accuracy stats, and generates a calibration report. Use whenever the aspirations loop hits the hypothesis-review cadence, the user says "how accurate are my predictions" or "review my hypotheses", or enough hypotheses have reached their horizon to warrant a batch resolve. Modes: --resolve, --learn, --accuracy-report, --full-cycle, --category-comparison.

Manages the framework SEED: build the seed manifest, PLANT (publish) the domain-stripped framework into a destination repo, verify, and diff. The seed is domain-free — planting it grows a NEW, empty environment (e.g. claude-mind) with no agents, no world, no learned state. To relocate a LIVING mind WITH its agents, world, meta and identity onto another machine, that is a TRANSPLANT — use the separate /transplant skill instead. Use when the user says 'seed', 'plant the seed', 'publish the framework', 'publish to claude-mind', 'copy framework to', 'create a seed', 'verify the seed', or 'diff against destination'. Sub-commands: create, plant, verify, diff.

Knowledge-tree operations entry point dispatching to sub-commands: read (node content), find (search), add (new node), edit (existing node), set (field update), decompose (split large node), distill (summarize), maintain (rebalance), stats (counts & health), validate (schema check). Use whenever the agent needs to read, modify, reorganize, or audit the world knowledge tree — the user says "add a node about X", "update the Y node", "reorganize this category", or reflection/encoding produces a tree write. Canonical entry point; never edit _tree.yaml or node .md files directly.

Runs post-test verification: checks the agent's state against a comprehensive checklist of learning artifacts (tree encodings, resolved hypotheses, reflections, skill return-protocols, guardrails, pattern signatures) and reports missing or drifted items. Use whenever the user says /verify-learning, after major framework changes to confirm the loop still produces learning, after a session with many commits and no encodings, or when framework-level health needs a diagnostic sweep. User-invocable AND agent-callable.

Daily curation flow for guardrails + reasoning bank. Each fire pulls 15 lowest-evidence guardrail candidates and 15 rb candidates from utilization-stats.py, walks them with a deterministic RETIRE/KEEP/REVISE/SKIP decision protocol (default RETIRE on zero-evidence + high exposure + age), writes exemption windows on KEEP, files Maintain goals on REVISE, and appends a batch entry to world/curation-log.jsonl. Use whenever the daily g-115-348 recurring goal fires, the user runs /aspirations-curate-memory directly, or the orchestrator hits a manual curation checkpoint. Internal sub-skill — slot in g-115-348's procedure block.

Handles the graceful-stop path for the aspirations loop: recovers in-flight iteration checkpoints, completes pending verify/state-update obligations, and runs the deferred stop sequence D1-D7. Use whenever {agent}/session/stop-requested is detected at Phase -1.4 of the aspirations loop, or the loop needs to exit cleanly without dropping in-flight work. Internal handler — only /aspirations invokes it; the user-facing /stop command writes stop-requested which this handler then reads.

Selects the next goal for execution: runs the mandatory goal-selector.sh scoring pass, metacognitive assessment, batch candidacy check, blocker gate, context pre-fetch, and full goal-detail loading. Use whenever the aspirations loop needs the highest-priority unclaimed unblocked goal for the next iteration. Always called immediately after /aspirations-precheck; never invoked directly by the user. Output determines whether execution, all-blocked handling, or evolution fires next.

Evaluates all graduation gates for the agent's current curriculum stage and promotes to the next stage if every gate passes. Gates include metric_threshold, count_check, log_scan, and command_check types. Use whenever /aspirations-consolidate hits session end, /aspirations-evolve runs a mandatory evolution pass, or the agent completes enough goals to plausibly graduate. Promotion unlocks new capabilities (self-edits, forge-skill, parallelism) per curriculum.yaml.

Drains the agent's temp/ working-doc store into the knowledge tree. Walks every undrained file under agents/{agent}/temp/ (analyses, briefings, audits, design docs, snapshots), classifies each against the learning-routing decision tree, encodes its reusable value into the right store (knowledge tree / reasoning bank / guardrails / experience), then moves the file to temp/drained/ as an audit trail. Also PURGES stale pure-ephemera files (.log/.txt/.py/.sh/.err test-suite output, tool dumps, one-shot scratch scripts) that carry no knowledge — deleting them rather than encoding (Phase 1.5, 120-min age guard). Use when the user says "drain temp", "encode everything in temp", "clear out temp", or when the aspirations-precheck temp-pressure check flags temp_drain_needed (>= drain threshold of undrained docs + ephemera). Pass --dry-run to list what WOULD drain or purge without encoding, moving, or deleting.

Runs a structured learning pass on the current chat session: encode reusable insights to the knowledge tree / reasoning bank / guardrails / patterns / experience archive; file Maintain goals for inline completions; re-probe blockers our work may have falsified; surface new aspirations / goals / forge gaps; propose /verify-learning checks for framework changes; check meta-strategy and Self for evolution signals. Use only when the user explicitly types /encode-session or says 'encode this chat session' — does NOT auto-fire on conversational close-out language. Hybrid: user-invocable AND agent-callable.

Periodic local self-audit of the knowledge tree's top-level taxonomy — fires when the every-200-goals precheck cadence trips, or on user demand (/fresh-eyes-tree). Assembles a briefing covering L1 distribution skew (S1), L1 pick-rate trends (S9), candidate L2 promotions, candidate L1 retirements, and SPROUT/REPARENT history, writes it to agents/{agent}/temp/ (a staging file drained to the knowledge tree), and posts a one-line summary to the coordination board. No email push, no user-approval gate. The user can invoke l1-domain-add.sh / l1-domain-rename.sh manually if taxonomy changes are desired. Closes the 'tree has no taxonomy-level review' gap.

Creates or resumes an agent in reader (read-only), assistant (user-directed), or autonomous mode (perpetual loop), handling full initialization for new agents (Self, program, paths, aspirations, curriculum) and state transitions for existing ones. USER-ONLY — Claude must NEVER invoke /start. Fires only when the user types /start {agent-name} [--mode {mode}]. Enforces the one-autonomous-session-per-agent invariant and supports observer sessions alongside running loops. Auto-recovers zombie sessions (state=RUNNING + stale heartbeat + no pending obligations) inline so /start {name} just works after a crash; --recover is reserved for the --force override path.

Stops the autonomous learning loop gracefully: writes stop-requested for Phase -1.4, waits for in-flight obligations (verify, state-update), consolidates session state via /aspirations-consolidate, drops the agent to assistant mode by default (or reader with --reader), and transitions state to IDLE. USER-ONLY — Claude must NEVER invoke /stop. Fires only when the user types /stop {agent-name} [--reader]. Agent name is REQUIRED — refuses with an error and a list of available agents otherwise. Preserves handoff.yaml for the next session to resume.

Relocates a LIVING mind — its agents, world, meta, and identity — onto another machine. Two modes. own-cloud: the repo (git) carries code + tracked agent identity and S3 carries world/meta, so the source side just prepares and prints a destination bring-up checklist (no archive). offline: packs a portable archive (git-archive of the repo PLUS the external world/ and meta/ data, minus the .history bloat and machine-local session state) that can be copied or emailed, plus a RESTORE guide. The destination resumes via /start (Phase A-0 auto-detects the cloned/unpacked agent). This is NOT the seed: a seed is domain-free and grows a NEW empty environment (use /seed). A transplant keeps the living mind intact and moves it. Use when the user says transplant, transplant the mind, move the mind to another computer, relocate the mind, move to a new machine, pack the mind, or email the mind. Sub-commands: own-cloud, offline, land, verify.

Runs the State Update Protocol (Phase 8 of the aspirations loop) after EVERY goal execution: 9 steps plus Step 3.5 Team State, Step 8.5 Actionable Findings Gate, Step 8.75 Execution Reflection, Step 8.76 Skill Quality, Step 8.77 User-Notable Event Push Classifier, and Step 8.11 Execution Feedback. Use whenever a goal finishes executing. Outcome_class controls depth — routine: Steps 1-4 + abbreviated journal; deep: full protocol with immediate tree encoding. MANDATORY — skipping or abbreviating kills the learning loop.

Performs maintenance reflection: curates memory (reasoning-bank entries, tree nodes, pattern signatures), applies active forgetting to low-utility items, grooms aspirations, and detects stuck goals that may need unblock conversion or archival. Use whenever the loop hits the maintenance cadence, the reasoning bank exceeds healthy size, the knowledge tree accumulates low-confidence nodes, or goals have stalled without progress. Invoked via /reflect --curate-memory or /reflect --curate-aspirations.

Handles every user message in assistant and autonomous modes: activates persona, runs mandatory 3-tier retrieval escalation (tree → codebase → web), detects and routes user directives (new aspirations, corrections, preferences), performs knowledge-freshness reconciliation, and captures interaction-level learning into reasoning bank and guardrails. Use whenever the user sends a message — every user turn MUST route through /respond, otherwise Claude may answer from amnesia instead of retrieving learned knowledge.

Enforces learning obligations inside the aspirations loop: the learning gate, retrieval gate, meta-learning signal, periodic reflection cadence, conclusion audit, and batch reflection. Use whenever a goal completes and the loop must verify that encoding, retrieval, and reflection actually happened before moving to the next goal. Catches sessions that ship commits without producing tree encodings or hypothesis resolutions. Internal sub-skill — never invoke directly.

Performs a strategic environmental scan: reads world signals, recurring-goal outputs (infra health, email, audit trails), knowledge-tree frontier, portfolio health, and intrinsic motivation — then generates new aspirations from external observation rather than introspection. Use whenever the aspirations loop hits the strategic-scan cadence (every N iterations), the goal pipeline looks thin, or the orchestrator needs fresh work driven by real-world signal instead of self-generated ideas.

Phase 5 of the aspirations loop: verifies a just-executed goal using hypothesis outcomes, unified outcome/check evaluation, Q1/Q2/Q3 verification escalation, streak tracking, and dependent-goal unblocking. Use whenever /aspirations-execute finishes and the loop must confirm the goal actually met its verification criteria before state-update fires. Internal sub-skill — never invoke outside the aspirations loop; assumes the just-executed goal is still in working context.