CLAUDE.md git:20260927.f6ba906A

Immutable. This exact content never changes and is served at /api/v1/blob/db3d0371e807e5d9.

# Mycelium: Theory-Guided Agentic Product Development

*Version 0.277.0 -- **A test past its score date is scored by Mycelium** (MINOR). In the E2E rung L4-open on 0.276.0, 4 of 5 testers came back against a frozen bar of 3; the builder offered to write the result ("say the word") and did not, the verdict item fired only on a file already marked scored, and 0.276.0's ladder line "It waits on its learning delivery ending" was read as the whole L3 waiting and snoozed. An L3 test still live past its `score_by` is now the agent's to score from the notes, or to re-date with the reason; the ladder says only the move waits, not the verdict; and the line beside the request, which told the builder to put every escalated item to the user, now says to do an agent's item, from the first session (rung L5-open on 0.276.0 asked the founder to rule on the launch record). Prior: 0.276.0 a move that can happen now is proposed first.**A move that can happen now is proposed first, and an item says what to do** (MINOR). E2E rungs on 0.275.x: an L3 whose pilot was still running led the ladder every session because its notes kept arriving, and the L4 whose next move was desk work waited below it (L4-develop reached develop 1 of 3); the L4 was opened with no bar and two sessions went on asking the founder to write one she had decided; and the launch-data item borrowed the verdict's instruction, so the builder held the launch figures two sessions asking "say the word". A move that waits on the world (an L3 whose learning delivery has not ended) now follows one that can happen now; a bare L3-L5 gets its definition of done drafted from the founder's decisions, for her to confirm; and an agent-owned item carries its own instruction. A learning delivery past its last day now asks how it ended whatever was snoozed before (service world run 5 ran a month past it, clients still paying, no L4), and a hand-typed `ended.on` is read: `on` is a YAML 1.1 boolean and loaded as the key True. Founder: propose a move once what it needs is on record. Prior: 0.275.1 recording the launch is Mycelium's work.**Recording the launch is Mycelium's work, and the item names the fields** (PATCH). In the E2E rung L5-open on 0.275.0 the shipped-L4 item was put to the founder for four sessions, and the builder wrote the launch figures into a log entry the L5 lock never reads. Until the release and its launch data are recorded, the item is the agent's and names `released_on` and `launch_data: {..., as_of}` on the L4; the L5 door stays the founder's decision. Prior: 0.275.0 launch data comes after the release.**Launch data comes after the release** (MINOR). In the E2E rung L5-refused, with the launch withheld, the builder wrote the L3 pilot's five-tester results into the L4's launch_data ("forum page opens: 0") and the L5 lock, which read only that usage was filled, opened the L5. The L4 now records `released_on`, and the L5 lock needs `launch_data.as_of` after it. Prior: 0.274.0 a learning delivery's start is on the record.**A learning delivery's start is on the record** (MINOR). The E2E service world's L3 reached Deliver and grew its client pack from 4,100 to 7,100 words over seven sessions while nobody was served; 0.273.0 caught a growing build only in develop. `learning_delivery.started` records the day the first person took part; until it is set, the next item offers the start, and once overdue tells the agent to cut the build to what the start needs. Prior: 0.273.1 a duplicate key is named as it is written.**A duplicate key is named as it is written** (PATCH). YAML keeps a duplicate key's second value and drops the first without a word; the full canvas validator reported it, the check that runs as a file is written did not. The E2E service world wrote three into threat-model.yml and nothing told the builder. Prior: 0.273.0 an L3 builds only what its test needs.**An L3 builds only what its test needs** (MINOR). The E2E service world grew 8,500 words of client documents for a two-month, hand-run pilot with three existing clients, each edge case a new question for the founder, and the pilot never started. The L3's learning-delivery item now says to build only what the test needs, and once overdue tells the agent to stop extending the build and send every other open question to the tree as the next assumption, or to L4. Founder: "that's the ost working its way." Prior: 0.272.0 Mycelium records its own verdicts.**Mycelium records its own verdicts** (MINOR). In the E2E service world the pilot met the bar its test was frozen with, and the verdict item was put to the founder for three sessions as "Decide one: run | rule | snooze | drop"; the builder left it for her, nobody wrote it, and the L4 stayed locked. A next item now says whose it is: recording a verdict is the agent's to do now, told to the founder as being recorded; a door, a release or a pivot stays the founder's decision. Prior: 0.271.1 the security scope has its own key.**The security scope has its own key** (PATCH). 0.271.0 recorded the scope under `scope`, the name threat models already use for their sentence on what is modelled, so the E2E service world's threat model failed the canvas check on its next write. It is `security_scope` now; a written `scope` is valid again. Prior: 0.271.0 security and privacy checks fit what the product holds.**Security and privacy checks fit what the product holds** (MINOR). Founder: "2fa and so on might not be applicable for all products." `/mycelium:security-review` now records the product's scope first (runs code, accounts, personal data, money, reach) and applies only the checks it calls for, the rest recorded n/a with a reason; a service handled by people has its own section; privacy controls are proportional; and theory-gates no longer calls an offline service's Security gate N/A, which the lock could never honour. Prior: 0.270.0 the delivery gate sees a product that is not code.**The delivery gate sees a product that is not code** (MINOR). The E2E second world, a bookkeeping service with no software, wrote its client agreement, intake checklist and price sheet with only an L0 in discover; the gate knew code by its extension and skipped every document. A project now records `product_paths` (where its own files live), new files there are gated whatever their kind, and the next item asks once an L0 exists. Prior: 0.269.0 evidence and test sizing fit the product type.**Evidence and test sizing fit the product type** (MINOR). The rest of the overfit audit: the L4's per-transition evidence is keyed by product type (a course, an AI tool or a service is no longer asked for code tests); the L3's Develop->Deliver asks for one trial outside the team in the form the product takes, not a software prototype; and test sizing records reversibility, reach and harm, derives the class from them, and reports a test too light for its decision as well as too heavy, with the decision owner able to accept either with a reason. Prior: 0.268.0 the learning-delivery rules fit builders beyond the test world.**The learning-delivery rules fit builders beyond the test world** (MINOR). An audit of 0.258.0-0.267.0 against eight builders (a course pilot, a concierge service, a hardware loan, an internal team, a staged app beta, an open-source pre-release, a non-English founder, a project without git) found the 0.267.0 rules shaped to one simulated web page. How a delivery ended is recorded as fields, never matched as words; an audience change is recorded with its kind (narrowed, reworded, widened with its gates re-run, or everyone, the L4's); a repair reads the fresher record before the commit; an inconclusive test and a delivery past its end date each get a way on. Prior: 0.267.0 an L3's learning delivery keeps its audience.**An L3's learning delivery keeps its audience, and ends when the L3 does** (MINOR). The E2E rung L4-open made its page public under the L3, on Security and Privacy passed for five testers, and completed the L3 with the page still up. Widening the audience of an L3 that delivers now needs an L4 on it; an L3 completes by recording how its learning delivery ended (taken down, or handed to its L4); a completion written straight into completed_diamonds is judged like any move; and the L4 door names the audience it is the way past. Prior: 0.266.0 a broken diamonds file can be repaired.**A broken diamonds file can be repaired** (MINOR). The E2E rung L4-ship broke diamonds/active.yml with a shell write; the shell check said to fix it with Edit, and the scale lock refused the Edit as opening every diamond in it, since a file that does not parse read as no diamonds. A repair is now judged against the last good state (the committed file, else the scale and phase Mycelium recorded); anything the repair changes is still judged. Prior: 0.265.0 a verdict the lock cannot read is asked for again.**A verdict the lock cannot read is asked for again** (MINOR). An E2E rung recorded a correct pass as prose ("met on 2026-11-18 ... 4 of 5"); the L4 lock reads only its own words and stayed shut, and the verdict item stood down because the field was not empty. It now fires on an unreadable verdict and asks for `validated` or `invalidated`, reasoning in `verdict_note`. Prior: 0.264.1 the lock verdicts are pinned against reordering.**The lock verdicts are pinned against reordering** (PATCH). Metamorphic tests: reordering diamonds, opportunities or solutions, or adding a parked diamond elsewhere, never changes which diamonds hold or whether the L4 and L5 may open. Tests only. Prior: 0.264.0 a test is sized to the decision it informs.**A test is sized to the decision it informs** (MINOR). E2E runs 53-55 pre-registered a re-test for a five-tester recipe page that needed twelve blind recipe lines and a government dataset, and stalled on inputs nobody could supply. `/mycelium:assumption-test` now classes the decision (light, standard, heavy) and picks a test no heavier; the instrument check reports OVERSIZED tests; the founder can override with a written reason. Prior: 0.263.0 a failed assumption offers the way on.**A failed assumption offers the way on** (MINOR). E2E run 53 recorded `invalidated` on its L3's riskiest assumption; the L4 lock refused correctly and the next session offered nothing. A new next item offers the three exits: revise and re-test (back to define), the next solution from the L2, or stop the L3 with a reason. Prior: 0.262.0 the L3's JTBD and Privacy gates are phased too.**The L3's JTBD and Privacy gates are phased too** (MINOR). E2E run 50 held its L3 in discover on JTBD `fail` ("the emotional and social sides are unknown") and Privacy `pending` ("can't pass until the page is built"), two design-time gates read as needing evidence from use. Their L3 rows now say what each transition asks: JTBD, the three dimensions stated to define and served by the design to develop; Privacy, privacy by design on the design to develop and the build checked against it to deliver. Prior: 0.261.0 the L4's threshold is its exit bar too.**The L4's threshold is its exit bar too** (MINOR). E2E run 47 held the first L4 any run has opened in discover at confidence 0.15 against 0.7: the L4's field started at the default and its threshold was read at its first transition, duplicating the lock that had just admitted it on a test-validated verdict. The L4's threshold now applies at deliver -> complete, and each transition names its own evidence. Prior: 0.260.0 a scored test asks for its verdict.**A scored test asks for its verdict** (MINOR). E2E run 46 delivered its L3 to five testers, 4 of 5 came back against a bar of 3, and the builder scored the test file; it never wrote the verdict on the riskiest assumption, which is all the L4 lock reads, and nothing asked for it. A new next item names the scored file and asks for the verdict, and the verdict is defined on the bet the solution needs, whichever way the statement is worded. Prior: 0.259.0 the L3's bars rise with its phases.**The L3's bars rise with its phases** (MINOR). E2E runs 42-43 held an L3 in discover for three in-world months: its 0.75 confidence threshold and "prototype tested with users" were read at every transition, so it could not define before it had the prototype it exists to produce, a higher entry bar than the L4's. The L3's threshold is now its exit bar, and each transition names its own evidence: a real problem to define, a named test to develop, a prototype met by users to deliver, the learning delivery's verdict to complete. Prior: 0.258.0 the L4 opens only on the verdict of a learning delivery.**The L4 opens only on the verdict of a learning delivery** (MINOR). E2E run 41 scored a hand-run trial at a real site with its L3 still in develop and the backup approver timed without being told; one recorded verdict would have opened the L4, and only the builder held it back. The L4 lock now also needs the L3 in Deliver with `learning_delivery` recorded; any means counts, a concierge or hand-run test included, and after an early pass the next item keeps proposing the L3's Deliver. Prior: 0.257.1 commands Mycelium shows run this plugin's own script.**Commands Mycelium shows run this plugin's own script** (PATCH). The next item named `advisory_ledger.py` with no path; in E2E run 32 the agent searched for it, ran a copy 37 versions old from the plugin cache, and the founder's answer was stamped with a date before the question, so the item kept escalating after it was answered. Every shown command now carries the plugin's absolute path, and the answer prompts say which ruling fits which answer ("not now, ask me after X" is a snooze until asked with X as the note). Prior: 0.257.0 the L3 delivers to learn, the L4 to earn.*

*Full version history: [`docs/changelog.md`](docs/changelog.md).*

Mycelium is a harnessing system for AI-assisted product development. It connects theories, shares learning, adapts to conditions, and makes the whole ecosystem stronger.

**You are an agent operating within Mycelium. Every action you take must be guided by the frameworks below, harnessed by the guardrails, and logged in the decision system.**

## Agent Operating Contract (always-on rules)

The always-on behavioral rules — the **Communication Rules** (plain-language-first; suggest-skills-at-transitions; route-through-skills with the freeform escape valve; cite-the-trigger; offer-to-capture-learnings; name-the-verification-surface incl. `Ran: <cmd> → <result>` for runnable artifacts, `G-V13`; name-the-gate; read-canvas-before-narrating; verify-after-write; BLUF-layering, `G-C1`) and the **Mandatory Pre-Task / Pre-Ship (G-P-pre) / Post-Task (G-P7) Protocols** — are defined once, canonically, in **[`plugins/mycelium/engine/agent-operating-contract.md`](plugins/mycelium/engine/agent-operating-contract.md)**.

That file is the single source of truth, and the SessionStart hook (`plugins/mycelium/hooks/session-start.sh`) injects it into every session — so the contract binds in **plugin form** too, where no operating-manual `CLAUDE.md` is templated into the consuming project. It is the plugin-form replacement for the removed legacy `degit`-templating path (the migration kept the computational half of the harness — hooks — but until v0.58.0 silently dropped this always-on inferential half for plugin-form consumers; the framework repo never noticed because its own sessions load this very file as the repo's `CLAUDE.md`). Read the contract; those active rules win over any restatement. **CI Check 47** keeps the wiring intact: contract present + packaged in `manifest.yml` + injected by the hook + referenced here + free of legacy `.claude/` framework paths.

Canonical detail behind individual rules still lives in the harness: `plugins/mycelium/harness/communication-rules.md` (rationale + graduation history + X/Twitter extraction sequence), `guardrails-core.md` (`G-C1` BLUF-layering, `G-V13` runtime-proof, `G-P7` Post-Task, `G-P-pre` Pre-Ship), `engine/canvas-guidance.yml#action_flags` (gate flags). Pre-Ship graduated 2026-05-04; write-narration-verification 2026-06-05 (#18/#19).

## The Diamond Engine

### Diamond Scales (L0-L5)

| Scale | Focus | Primary Theories | Canvas Files |
|-------|-------|-----------------|--------------|
| L0: Purpose | Why we exist | Sinek (Golden Circle), JTBD (Christensen) | `canvas/purpose.yml`, `canvas/jobs-to-be-done.yml` |
| L1: Strategy | Where to play | Wardley Mapping, North Star, Team Topologies (Skelton) | `canvas/landscape.yml`, `canvas/north-star.yml`, `canvas/team-shape.yml` |
| L2: Opportunity | What to solve | Torres (CDH/OST), Allen (User Needs Mapping), Hoskins (Scenarios), Cynefin | `canvas/opportunities.yml`, `canvas/user-needs.yml`, `canvas/scenarios.yml` |
| L3: Solution | How to solve it | Gilad (GIST), Ellis (ICE, adopted by Gilad within GIST), Cagan (Inspired), Downe (Good Services) | `canvas/gist.yml`, `canvas/services.yml` |
| L4: Delivery | Build and ship | Forsgren (DORA), OWASP, Goldratt (ToC), DRY/KISS/YAGNI/SOLID/SoC | `canvas/dora-metrics.yml`, `canvas/threat-model.yml`, `canvas/value-stream.yml` |
| L5: Market | Reach users | Lauchengco (Loved), Shotton (behavioral science) | `canvas/go-to-market.yml`, `canvas/trust-signals.yml` |

L0-L3 are product-agnostic. L4-L5 adapt to `product_type` (software, content_course, content_publication, content_media, ai_tool, service_offering). See `canvas-guidance.yml#product_types`.

### Diamond Phases

Four phases per diamond, gated by theory checks: **Discover** (diverge — explore, gather evidence), **Define** (converge — synthesize, frame the problem), **Develop** (diverge — ideate, prototype), **Deliver** (converge — validate, build, ship, measure). Diamonds spawn children (L0→L1→L2→L3→L4, L5→L2 on market feedback); a bad assumption found in delivery **regresses** the diamond back with new evidence — the system working correctly. Full transition rules, WIP limits, lifecycle: `plugins/mycelium/engine/diamond-rules.md`.

### OST Leaf Lifecycle

Every solution leaf runs a 10-phase pipeline, each phase with input artifacts, gates, outputs, and discard criteria: **OST Leaf → Four Risks → ICE Score → Assumption Test → GIST Entry → Bounded Context → Threat Model → Preflight → Delivery Diamond → Launch + Feedback**. Definitions and discard rules: `plugins/mycelium/engine/leaf-lifecycle.md`; archived leaves → `canvas/archived-solutions.yml`.

### Perspective Resolution & Leaf Bakeoff

Conflicting product/design/engineering perspectives → structured resolution in `plugins/mycelium/engine/perspective-resolution.md`. Multiple leaves competing for one opportunity → structured A/B comparison in `plugins/mycelium/orchestration/leaf-bakeoff.md`.

## Theory Gates (Decision Checkpoints)

Every diamond transition must pass applicable gates from: Evidence, Four Risks, JTBD, Cynefin, Bias, Security, Privacy, BVSSH, Service Quality, Delivery Metrics, Corrections, Regulatory, Explainability, Landscape, Capacity. See `plugins/mycelium/engine/theory-gates.md` for complete definitions, pass/fail criteria, and suggested skills.

**You cannot progress a diamond by saying "I'm confident enough." You must demonstrate evidence that satisfies each gate.**

## The Canvas (Source of Truth)

All product knowledge lives in `.claude/canvas/*.yml`. These files are:
- The **single source of truth** for the product's state
- Committed to git (they are documentation-as-code)
- Updated through evidence, not assumption
- Readable by any team member starting a new session

**Never make a significant decision without first checking and updating the relevant canvas file.**

Canvas files should include `_meta` blocks for versioning and staleness detection (see `canvas-guidance.yml`). Run `/canvas-health` periodically to lint for missing fields, stale confidence, inconsistent evidence types, and orphaned references.

**Canvas writes — Read before Write (HARD RULE).** Canvas files ship pre-populated, so every `.claude/canvas/*.yml` exists on a fresh project. `Write`/`Edit` require a prior **`Read` tool** call (same session); **`cat`/`head`/`grep` via Bash do NOT satisfy it** (different tool surfaces). **`Edit`**: `Read limit:1` suffices (~50 tokens; state is per-file — reuse across edits; use for large files like `purpose.yml`). **`Write`**: full Read first (it obliterates the file). **ID-bearing entries**: run `grep "^  - id: <prefix>-" .claude/canvas/<file>.yml | sort -u` before assigning and pick the next free integer (`validate_canvas.py` catches dupes on CI but a working-tree dupe can persist for days; kin to anti-pattern #8 Stale State Read). Validator Check 31 enforces the Preflight block; cost-discipline + ID-scan graduation history in `docs/changelog.md`.

## Harnessing System

- **Behavioral Contract** (`plugins/mycelium/harness/behavioral-contract.md`): Consolidated must / must-never index for the agent itself. Pointer-only (copies nothing; the cited source always wins) so the agent's own behavioral contract is grep-able in one place — the self-governance analogue of the `ai_tool` product contract in `canvas/ai-tool-metrics.yml`.
- **Guardrails** (`plugins/mycelium/harness/guardrails.md`): Three-tier enforcement -- BLOCK (mechanically prevented), REVIEW (gates progression), NUDGE (advised, not blocking).
- **Anti-Patterns** (`plugins/mycelium/harness/anti-patterns.md`) & **Cognitive Biases** (`plugins/mycelium/harness/cognitive-biases.md`): Known failure modes with detection rules (stop and self-correct if you catch yourself in one); per-stage bias checklist.
- **Security & Trust** (`plugins/mycelium/harness/security-trust.md`): Per-stage security requirements.
- **Engineering Principles** (`plugins/mycelium/harness/engineering-principles.md`): DRY, KISS, YAGNI, SoC, SOLID, LoD. Human-facing complement: **Design Principles** (`plugins/mycelium/harness/design-principles.md`) — how the framework treats its user (SDT autonomy/competence/relatedness; Theory Y; never gamify discipline).
- **Delegation Authority** (`plugins/mycelium/harness/delegation-authority.md`): who decides — agent vs human — for each *execution* decision, keyed to consequence (effective-reversibility × aggregate-blast-radius). Binds the BLOCK/REVIEW/NUDGE tiers to execution (not just epistemic discipline); names the no-standing decisions (which bet, security/privacy/ethics tradeoffs, editing the map itself) that are absolutely human; round-up-under-uncertainty; escape-hatch override. Repo anchor for behavioral-contract N9/N10.

## Self-Learning System

### Two Memory Systems -- Important Distinction

| System | Location | Scope | Committed to git? |
|---|---|---|---|
| **Project memory** | `.claude/memory/` (in the project repo) | Team-level learnings about *this product* | Yes |
| **Auto-memory** | `~/.claude/projects/<id>/memory/` (in user home) | Per-session continuity between you and the agent | No (user-local) |

**Routing rule**: Project-team learnings -> project memory. Agent-user learnings -> auto-memory. Hardware/environment failures -> neither.

The reflexion hook (PostToolUseFailure) is scoped to **project-relevant failures only** -- do not log entries to project memory for agent self-inflicted tool errors or environment issues outside the project directory.

### Key Artifacts
- **Corrections** (`.claude/memory/corrections.md`): learning from mistakes. **Read before every task.** *Recourse SLA*: one-offs inform next session; ≥3 same-root-cause instances graduate to mechanism on the next L4 cleanup cycle.
- **Patterns** (`.claude/memory/patterns.md`): successful patterns to reuse.
- **Warnings Log** (`.claude/memory/warnings-log.md`): CI WARN+FAIL capture, auto-updated; per-class fixes in `plugins/mycelium/engine/warning-handbook.md`; consumed by `/corrections-audit`.
- **Decision Log** (`plugins/mycelium/harness/decision-log.md`): every significant decision. **Required** `why_not_alternatives` field — per-alternative rejection rationale; contrastive explanations land harder (Liao et al. 2020) and feed `/xai-check` Stage 2.
- **Feedback Loops** (`plugins/mycelium/engine/feedback-loops.md`, `/feedback-review`), **Reflexion Loop** (`plugins/mycelium/skills/reflexion/SKILL.md`, max-3 retry), **Eval Benchmarks** (`.claude/evals/`), **Cycle History** (`.claude/canvas/cycle-history.yml` → `engine/cycle-learning.md`), **Adaptive Thresholds** (`.claude/canvas/thresholds.yml` → `engine/adaptive-thresholds.md`).

### Learning Metabolism (Self-Improving System)

Five mechanisms make Mycelium smarter over time (details + cadence in each sub-file): **Cycle Learning** (`plugins/mycelium/engine/cycle-learning.md` — predicted vs actual ICE), **Pattern Emergence** (`plugins/mycelium/engine/pattern-detector.md` — into `/retrospective`, `/diamond-assess`), **Adaptive Thresholds** (`plugins/mycelium/engine/adaptive-thresholds.md` — defaults until N=10), **Framework Reflexion** (`plugins/mycelium/engine/framework-reflexion.md`, `/framework-health`), **Evidence Decay** (`plugins/mycelium/engine/evidence-decay.md` — `/canvas-health` flags stale evidence).

## Domain Contexts

Load the appropriate context based on current diamond phase:

- **Discovery**: `${CLAUDE_PLUGIN_ROOT}/domains/discovery/CLAUDE.md` -- Torres-style interviewing, OST construction, bias-aware research
- **Delivery**: `${CLAUDE_PLUGIN_ROOT}/domains/delivery/CLAUDE.md` -- Agile/DevOps practices, clean code, security, accessibility, DORA metrics
- **Quality**: `${CLAUDE_PLUGIN_ROOT}/domains/quality/CLAUDE.md` -- Always-active overlay: validation, accessibility, security, service principles

## JiT Tooling

Mycelium is **language-agnostic** and **product-type-agnostic**. When a delivery diamond begins, auto-detect the tech stack (or product type), generate appropriate validation, and confirm with the user. See `plugins/mycelium/jit-tooling/detector.md`.

## Usage & Orchestration

Solo developers use canvas as shared memory with the agent. Teams commit canvas to git as shared product documentation. For parallel exploration, use `/fan-out` with worktree-isolated worker agents.

See `plugins/mycelium/orchestration/modes.md` for usage patterns and `plugins/mycelium/orchestration/agent-teams.md` for parallel orchestration.

## Operations & Maintenance

- **Day-to-day**: `plugins/mycelium/orchestration/operations.md` -- Session resumption, canvas maintenance, diamond lifecycle, memory pruning
- **Escape hatch**: `plugins/mycelium/orchestration/escape-hatch.md` -- Legitimate process bypass for emergencies. Must be documented and paid back.

## Skills

All 63 skills are auto-discovered from SKILL.md frontmatter — in plugin form (`plugins/mycelium/skills/*/SKILL.md`, recommended) or legacy form (`.claude/skills/*/SKILL.md`, supported during transition). Suggested skills are surfaced at diamond transitions by `/diamond-progress` and `/diamond-assess`, and contextually by hooks. Type `/` to see the current list.

## Getting Started

New project (empty canvas): run `/interview`. Continuing work (populated canvas): run `/diamond-assess`. The system guides you from there.