@zalom/plastic 1.0.0-beta.9 → 1.0.0

package/skills/install/SKILL.md

@@ -1,24 +1,31 @@
 ---
 name: plastic-install
-description: Use when initializing Plastic globally (~/.plastic/) or locally in a project, or to re-install/repair a broken installation. Accepts channel flags (--alpha, --beta, --latest) to select release channel. Default is --latest (stable). Global install is recommended — creates the global intent store as a git-backed repository. Local install creates .plastic/ in the current project for testing.
+description: Use when initializing Plastic globally (~/.plastic/) or locally in a project, or to re-install/repair a broken installation. Accepts channel flags (--alpha, --beta, --latest) to select release channel. First install defaults to --beta; reinstalls match the already-installed channel. Global install is recommended: it creates the global intent store as a git-backed repository. Local install creates .plastic/ in the current project for testing.
 ---
 
 # Install Plastic
 
-> **Recommended path:** for a first install, run `npx @zalom/plastic@latest install --claude`
-> in your shell (or `bunx @zalom/plastic@latest --claude` if you use Bun). This skill
+> **Recommended path:** for a first install, run `npx -y @zalom/plastic@beta install --claude`
+> in your shell (or `bunx -y @zalom/plastic@beta install --claude` if you use Bun). This skill
 > exists to **re-install or repair** an existing setup from inside the agent, and to
 > drive interactive global configuration. Whenever this skill performs an install or
 > re-install, it **runs `/plastic-doctor` afterward** and reports the result.
 
+## Channel rule
+
+If Plastic is installed, derive `<channel>` from `~/.plastic/VERSION`: a version containing
+`-alpha` means `@alpha`, `-beta` means `@beta`, otherwise `@latest`. If not installed
+(first install), default to `@beta`. The user can always override with
+`--alpha` / `--beta` / `--latest`.
+
 ## Re-install / repair
 
 If Plastic is already installed but something is broken (skills missing, hooks not
-firing, leftover legacy plugin), re-run the installer — it is idempotent, prunes
+firing, leftover legacy plugin), re-run the installer, it is idempotent, prunes
 files that no longer ship, and removes any legacy plugin/marketplace layout:
 
 ```bash
-npx @zalom/plastic@latest install --reinstall --claude   # or @beta / @alpha to match your channel
+npx -y @zalom/plastic@<channel> install --reinstall --claude
 ```
 
 Then **run `/plastic-doctor`** and report what it found.
@@ -27,22 +34,22 @@ Then **run `/plastic-doctor`** and report what it found.
 
 | Flag | Behavior |
 |------|----------|
-| `--latest` | Install from stable channel (default) |
-| `--beta` | Install from beta channel |
-| `--alpha` | Install from alpha channel |
+| `--latest` | Install from the stable channel |
+| `--beta` | Install from the beta channel (default on a first install) |
+| `--alpha` | Install from the alpha channel |
 
 When invoked from within Claude Code (re-install or channel switch), the skill
 runs the appropriate npx command:
 
 ```bash
-# Stable (default)
-npx @zalom/plastic install --claude
+# Stable
+npx -y @zalom/plastic@latest install --claude
 
-# Beta
-npx @zalom/plastic@beta install --claude
+# Beta (default on a first install)
+npx -y @zalom/plastic@beta install --claude
 
 # Alpha
-npx @zalom/plastic@alpha install --claude
+npx -y @zalom/plastic@alpha install --claude
 ```
 
 The installed version and channel are recorded in `~/.plastic/VERSION`.
@@ -55,105 +62,80 @@ Run `/plastic-install` with no arguments.
 
 #### Procedure
 
-**Step 1: Check for existing installation**
-
-Check if `~/.plastic/INDEX.md` exists.
-- If yes: announce "Plastic is already installed at ~/.plastic/. Run `/plastic-update` to sync core files."
-- If no: proceed with fresh install.
+**Step 1: Run the installer**
 
-**Step 2: Create ~/.plastic/ as a git repo**
+Check if `~/.plastic/VERSION` exists.
+- If yes: announce "Plastic is already installed at ~/.plastic/. Run `/plastic-update` to
+  sync core files, or use the re-install command above to repair in place."
+- If no: run the fresh install command (default `@beta`, or the channel the user named):
 
 ```bash
-mkdir -p ~/.plastic/store ~/.plastic/projects
+npx -y @zalom/plastic@beta install --claude
 ```
 
-Copy templates from the plugin:
-- `config.yml` from `${CLAUDE_PLUGIN_ROOT}/templates/config.yml`
-- `projects.yml` from `${CLAUDE_PLUGIN_ROOT}/templates/projects.yml`
-- `INDEX.md` from `${CLAUDE_PLUGIN_ROOT}/templates/index.md`
-- `PLASTIC.md` from `${CLAUDE_PLUGIN_ROOT}/PLASTIC.md`
+This single command, via `install.rb` (`bootstrap` + `distribute`), creates `store/`,
+`projects/`, `config.yml`, `projects.yml`, `INDEX.md`, and `AGENTS.md` under `~/.plastic/`,
+and copies the utility scripts (`folgezettel-id`, `read-config`, and the rest of
+`scripts/`). This skill does none of that itself; it wraps the command with the
+interactive steps the CLI does not yet own, plus reporting and a doctor pass.
 
-Create `AGENTS.md` (user-editable, not overwritten on updates):
-```markdown
-# Plastic — Agent Instructions
+**Statusline**
 
-Read `PLASTIC.md` in this directory. It contains all Plastic conventions.
-Follow it exactly. Never modify it — it is overwritten on plugin updates.
+On install, if an existing statusline is already configured, Plastic asks whether to
+keep it or switch to Plastic's (interactive sessions only). The choice is honored via
+`--statusline keep` or `--statusline plastic`, which skips the prompt. Non-interactive
+sessions (no tty) default to keeping the user's line: nothing is silently overwritten.
+A fresh system with no statusline configured gets Plastic's line with no prompt.
 
-This file (`AGENTS.md`) is where project-specific rules live. Users and agents
-may add content below.
-
----
-```
+**Step 2: Initialize git (retained)**
 
-Add `.gitkeep` to `store/` and `projects/`.
+Only if `~/.plastic/.git` is absent (a fresh bootstrap does not init git):
 
-Initialize git:
 ```bash
 cd ~/.plastic && git init && git add . && git commit -m "chore: initialize Plastic global intent store"
 ```
 
-**Step 2b: Copy utility scripts**
+Retained here because the CLI does not git-init the store yet (follow-up).
 
-```bash
-mkdir -p ~/.plastic/scripts
-cp "${CLAUDE_PLUGIN_ROOT}/scripts/folgezettel-id" ~/.plastic/scripts/folgezettel-id
-cp "${CLAUDE_PLUGIN_ROOT}/scripts/read-config" ~/.plastic/scripts/read-config
-chmod +x ~/.plastic/scripts/folgezettel-id ~/.plastic/scripts/read-config
-```
-
-This ensures project agents can generate hashes via `~/.plastic/scripts/folgezettel-id` without depending on a specific agent's plugin cache path.
-
-**Step 2c: Detect agent type and set preferences**
+**Step 3: Personalize config (retained)**
 
 Detect which agent is running:
-- If `CLAUDE_CODE` env var is set or we're running inside Claude Code → `agent.type: claude-code`
-- If `HERMES_HOME` env var is set → `agent.type: hermes`
-- Otherwise → ask the user: "Which AI agent are you using? (claude-code / hermes / other)"
+- If `CLAUDE_CODE` env var is set or we're running inside Claude Code -> `agent.type: claude-code`
+- If `HERMES_HOME` env var is set -> `agent.type: hermes`
+- Otherwise -> ask the user: "Which AI agent are you using? (claude-code / hermes / other)"
 
 Ask the user:
-> "Enable Agent Teams? (experimental — parallel project work with teammates)"
-> - Yes → set `parallel_mode: agent-teams`
-> - No → set `parallel_mode: linear` (subagents only)
-
-Update `~/.plastic/config.yml` with detected/chosen values using `read-config --migrate` first to ensure v3 schema, then write the agent-specific values.
-
-Auto-commit the config change.
-
-**Step 2d: Configure GitHub and push preferences**
+> "Enable Agent Teams? (experimental: parallel project work with teammates)"
+> - Yes -> set `parallel_mode: agent-teams`
+> - No -> set `parallel_mode: linear` (subagents only)
 
 Inform the user:
-> "Plastic agents can create GitHub repositories for new projects.
-> By default, all agent-created repos are **private**. Your global
-> intent store (~/.plastic/) is never pushed — it stays local-only."
+> "Plastic agents can create GitHub repositories for new projects. By default, all
+> agent-created repos are **private**. Your global intent store (~/.plastic/) is never
+> pushed, it stays local-only."
 
 Ask the user:
 > "Default visibility for agent-created repos?"
-> - Private (recommended) → set `github.default_visibility: private`
-> - Public → set `github.default_visibility: public`
-
+> - Private (recommended) -> set `github.default_visibility: private`
+> - Public -> set `github.default_visibility: public`
+>
 > "Allow agents to push to GitHub without asking?"
-> - No (recommended) → set `github.auto_push: false`
-> - Yes → set `github.auto_push: true`
-
-Update `config.yml` with chosen values. Auto-commit.
-
-**Step 3: Configure project roots**
-
-Ask the user:
+> - No (recommended) -> set `github.auto_push: false`
+> - Yes -> set `github.auto_push: true`
+>
 > "Where do you keep your projects? Default: ~/.plastic/projects/"
 > "Add additional roots? (e.g., ~/apps/personal/, ~/apps/companies/)"
 
-Update `config.yml` with any additional roots.
-
-Auto-commit the config change.
+Write each answer via `read-config --migrate` first (ensures the v3 schema), then the
+chosen values; auto-commit each change. Retained here because the CLI writes only
+hardcoded defaults, so these interactive choices stay in the skill.
 
 **Step 4: Verify with doctor**
 
 Run `/plastic-doctor` and report the result. Resolve any fixable findings before
 announcing success.
 
-**Step 5: Register stores with QMD (optional)**
+**Step 5: Register stores with QMD (retained)**
 
 QMD is an optional search layer. If it is installed, register the Plastic stores so
 they are searchable:
@@ -165,19 +147,27 @@ ruby ~/.plastic/scripts/qmd-sync detect && ruby ~/.plastic/scripts/qmd-sync regi
 `qmd-sync` no-ops cleanly when QMD is absent, so this is safe to run unconditionally.
 It registers `plastic-global` and every project store from `projects.yml`, then indexes
 them. Report what was registered, or that QMD was not detected and the step was skipped.
+Retained here because the CLI does not register at install time (follow-up).
+
+**Step 6: Report + announce**
 
-**Step 6: Announce**
+```
+Plastic install (<channel>)
+Command:  npx -y @zalom/plastic@<channel> install --claude <flags>
+Version:  none -> <installed>
+Doctor:   <summary or "all clear">
+```
 
-> "Plastic installed globally at ~/.plastic/. Health check: [doctor summary].
-> Create your first intent with `/plastic-creating-intent`."
+Then: "Read `docs/guides/your-first-intent-in-10-minutes.md` for your first intent, start to finish."
 
 ### Local Install (testing/legacy)
 
-Run `/plastic-install --local`.
+Run `/plastic-install --local`. `install.rb` has no `--local` verb, so this mode is
+genuinely skill-owned.
 
 #### Procedure
 
-**Step 1:** Check if `.plastic/` exists in CWD — if so, warn and exit.
+**Step 1:** Check if `.plastic/` exists in CWD, if so, warn and exit.
 
 **Step 2:** Create `.plastic/` in CWD:
 - `config.yml` from templates
@@ -192,4 +182,5 @@ Run `/plastic-install --local`.
 
 **Step 4:** Commit in project: `git add .plastic/ && git commit -m "chore: initialize Plastic local store"`
 
-**Step 5:** Announce: "Plastic initialized locally. This is a testing/legacy mode. Consider `/plastic-install` for global mode."
+**Step 5:** Announce: "Plastic initialized locally. This is a testing/legacy mode. Consider
+`/plastic-install` for global mode."

package/skills/intent-curator/SKILL.md

@@ -38,6 +38,10 @@ The agent handles:
 - Cluster management (create, merge, rename)
 - Orphan detection
 
-When an intent reaches a terminal state — moved to Completed OR Abandoned — refresh the QMD index for the affected store (no-op when QMD absent), running in the background so it never blocks: `ruby ~/.plastic/scripts/qmd-sync reindex --store <store-root> --async`.
+When an intent reaches a terminal state — moved to Completed OR Abandoned — do these things as the closing act of the transfer, in the canonical End-tail order (see PLASTIC.md `## Delivery Isolation and the Single-Owner Lock`):
+
+1. Author a real `outcome.md` in the intent directory from `~/.plastic/templates/outcome.md`, with the frontmatter `disposition: delivered` for a completed intent or `disposition: abandoned` for an abandoned one. `outcome.md` is MANDATORY at every terminal, delivered and abandoned alike: on abandon it records the abandonment reason and replaces the scaffolded placeholder sentinel (never leave `outcome.md` a placeholder at a terminal).
+2. Stamp the terminal savepoint bookend (intent 81), so the ledger's last line records the disposition: `ruby -r ~/.plastic/scripts/lib/bridge -e 'Bridge.append_terminal_savepoint("<intent_dir>", "delivered")'` (use `"abandoned"` for an abandoned intent). Idempotent.
+3. Refresh the QMD index for the affected store LAST, after the terminal move and savepoint (no-op when QMD absent), running in the background so it never blocks: `ruby ~/.plastic/scripts/qmd-sync reindex --store <store-root> --async`.
 
 After the agent completes, report what changed.

package/skills/intent-discovery/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: plastic-intent-discovery
+description: >-
+  What-stage context deposit at intent activation: run QMD discovery over the
+  intent's chain/sources and related parked intents, and write findings to
+  resources/discovery--<slug>.md for the Why stage to consume. Use when an intent
+  is activated (moved from Future to Active), after the lock is armed, under it,
+  and before Why begins. Never writes the intent file itself.
+---
+
+# Intent Discovery — What-stage context deposit
+
+Announce: "Discovering context for intent [ID] — [name]."
+
+Runs once, at intent activation, after the lock is armed and before Why. It gathers what is
+already known so Why does not start cold, and deposits it as a resource the
+Why-stage brainstorming agent reads.
+
+## When it fires
+Inside `plastic-intent-starting`, right after the bridge is armed, under the
+lock. Dispatched as the `plastic-intent-discovery` background agent.
+
+## What it does
+1. **Read the intent's links.** Load the activating intent file's `chain` and
+   `sources` frontmatter fields.
+2. **QMD-first discovery.** Search the Plastic stores with
+   `scripts/qmd-sync search "<terms>"` (or the `qmd` skill), scoped to the
+   relevant `plastic-*` collections, across completed predecessor work named in
+   `chain`/`sources` and any related parked/future intents in INDEX.md. Fall back
+   to ripgrep over the stores only when QMD is absent.
+3. **Deposit, never author.** Write findings to
+   `resources/discovery--<slug>.md` in the intent directory ONLY. Do not write
+   the intent file, spec.md, or any lifecycle deliverable. The lock-owner-only
+   write rule stays intact; the Why-stage `plastic-brainstorming` agent reads the
+   deposit and enriches `## Context`.
+
+## Stage coverage
+This is the What-stage agent in the one-agent-per-stage table (What:
+intent-discovery, Why: brainstorming + spec-specialist, How: planner, Exec:
+executor, Done: intent-curator).
+
+## Boundaries
+- Single output: `resources/discovery--<slug>.md`.
+- Does not ACQUIRE the delivery lock itself; it runs under the lock the
+  orchestrator armed, as the owner session (inherited session id), and is not
+  blocked by it.
+- Advisory input to Why, not a gate.

package/skills/intent-starting/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: plastic-intent-starting
+description: >-
+  Board a session onto an intent: take the lock FIRST, confirm savepoint state, ask auto or
+  guided ONCE, then resume at the latest delivered station and run the cycle to Done. Use on
+  `continuing --intent {id}`, when a new intent is registered and the user asks to work it,
+  or when the user picks an intent to work. Requires the intent in INDEX `## Active`.
+---
+
+# Intent Starting — board a session onto an intent
+
+Announce: "Boarding intent [ID] — [name]."
+
+`plastic-intent-starting` is the Start procedure. It boards a session onto one intent: take
+the lock FIRST, confirm the delivery state, ask **auto or guided ONCE**, board at the latest
+delivered station, then run the cycle to Done. The What → Why → How → Exec stations are the
+train track; Start boards the train, the ending procedure (~93) exits it.
+
+## Precondition + trigger
+
+Fires when the user picks an intent to work, when an agent is told to continue a SPECIFIC
+intent, or on `continuing --intent {id}` (the `continuing` → `starting` router is 106's job;
+this skill is invokable standalone now).
+
+If the intent is **terminal** (Done / Abandoned in INDEX): report only. Take NO lock, run NO
+resume, do NOT reopen it. Summarize the outcome and ask what is next. Stop here.
+
+## Lock FIRST (the spine)
+
+The lock is non-negotiable and comes before any mutating work. The ACTION-3 lock-gate
+enforces it: without a held lock, mutating writes to this active intent's dir are denied with
+"run /plastic-intent-starting to lock and begin".
+
+1. **Ensure the intent is in INDEX `## Active`.** If it sits in `## Future`, activate it
+   (move it to `## Active`, auto-commit) before arming. Creation precedes activation, so a
+   brand-new What intent is activated here, then locked.
+2. **Self-heal the lock state first.** Run:
+   `ruby ~/.plastic/scripts/plastic-lock fix --intent-dir <STORE>/<dir>`
+   This is the one repair function (same one /plastic-lock exposes): it removes
+   corrupt or legacy lock state and rebuilds the lock and bridge from disk for
+   this session. If it reports `held`, another session owns the intent: STOP
+   and tell the user who holds it. If it reports `stale`, ask the user before
+   running `plastic-lock reclaim` (takeover is audited).
+3. **Arm the bridge.** Which arm is chosen by the mode answer (below), but the lock itself is
+   taken first. Reuse the arm one-liner shape from `plastic-auto`:
+   ```bash
+   # guided (lock only):
+   ruby -r ~/.plastic/scripts/lib/bridge -e \
+     'Bridge.arm_guided(ENV["CLAUDE_CODE_SESSION_ID"], intent_id: "<ID>", intent_dir: "<STORE>/<dir>", store: "<STORE>", name: "<name>")'
+   # auto (lock + auto), then hand to plastic-auto:
+   ruby -r ~/.plastic/scripts/lib/bridge -e \
+     'Bridge.arm_auto(ENV["CLAUDE_CODE_SESSION_ID"], intent_id: "<ID>", intent_dir: "<STORE>/<dir>", store: "<STORE>", name: "<name>")'
+   ```
+   Replace `<ID>`, `<STORE>` (`~/.plastic/projects/<slug>/store` or `~/.plastic/store`),
+   `<dir>` (the `ID--slug` directory), and `<name>`.
+4. **Dispatch What-stage discovery (under the lock).** Right after arming, when the intent
+   was just activated in step 1 (on a resume that already has
+   `resources/discovery--<slug>.md`, skip: discovery runs once per intent, at activation
+   only), dispatch the `plastic-intent-discovery` agent (see the `plastic-intent-discovery`
+   skill), now that this session owns the lock, deposit authorized as the owner session. Resolve its
+   model explicitly and pass it at dispatch time (belt-and-braces): `read-config
+   agents.models.plastic-intent-discovery --project <repo>`. The agent runs QMD discovery
+   over the intent's `chain`/`sources` and deposits findings to
+   `resources/discovery--<slug>.md` only; it never writes the intent file, so the
+   lock-owner-only rule is untouched. This is advisory context for Why, not a gate: if
+   discovery yields nothing, proceed to Why normally.
+
+**Session id resolution (verbatim from `plastic-auto`).** The first argument is the session
+id the bridge is keyed by: pass the hook stdin `session_id` when you have it, otherwise
+`ENV["CLAUDE_CODE_SESSION_ID"]`, otherwise `nil`. Both arms call `resolve_session`, which
+picks the first non-empty of: the explicit id you pass → `CLAUDE_CODE_SESSION_ID` → a
+deterministic derived key (a hash of the store and intent id). It never returns nil, so the
+lock is taken even when every session env var is empty; arming prints a one-line stderr
+notice when it falls through to the derived key.
+
+**What the lock IS.** Ownership is session-keyed and lease-based: arming writes a durable
+`delivery.lock` file in the intent dir naming this session as owner, and the owner's hooks
+refresh the file mtime on tool activity (the lease heartbeat). The /tmp bridge is only a
+cache of that file; on any disagreement the lock file wins, so a wiped /tmp never strands
+the owner. Idempotent re-arm: arming again with the same owner just refreshes the lock; it
+is not an error to re-board an intent this session already owns. A failed arm raises with
+a message naming the resolving `plastic-lock` verb (`status`, `reclaim`, or `fix`): follow
+that message, never delete a lock file by hand.
+
+## Confirm delivery state
+
+Read `savepoint.md` and classify from the **last line** alone, then verify ONLY that line's
+artifact is real (sentinel-aware via `Bridge.stage_file_present?`). On drift (the last line
+disagrees with files on disk), rebuild the ledger from disk and note the correction. Do not
+inline the rebuild; the `plastic-savepoint` skill owns it:
+```bash
+ruby -r ~/.plastic/scripts/lib/bridge -e 'Bridge.rebuild_savepoint("<intent_dir>")'
+```
+
+## Report + ask "auto or guided?" ONCE
+
+Report: the intent, the station it lands at (the matrix below), what is delivered, the next
+step. Then ask the user **"auto or guided?"** — exactly ONCE, whatever station it lands at.
+Never re-ask at a later station.
+
+- **guided** → `arm_guided` (lock only); continue step by step with the user through the
+  station's work below.
+- **auto** → `arm_auto` (lock + auto), then hand off to `plastic-auto`. The auto branch's
+  only remaining job is the handoff; `plastic-auto` runs the cycle from here.
+
+## Board at the latest delivered station
+
+The station is derived from `savepoint.md` last line + real artifacts on disk. See
+`references/boarding-matrix.md` for the full table (last line → latest delivered → boards at →
+continue with) and the per-station notes. Summary of what "continue" means per station:
+
+- **What** → do what What requires (106-expanded), then brainstorm → `spec.md`.
+- **Why** → continue brainstorming → `spec.md`.
+- **How** → continue `plan.md` + `actions/` + `checklist.md`.
+- **Exec** → verify what has been delivered, then continue (or restart) the delivery /
+  research; tick the checklist.
+- **ready to complete** (`Exec outcome.md created`) → exit at Done.
+- **Done** → report only, ask what is next, never reopen.
+
+## Disarm / release on done
+
+When delivery finishes, disarm and release per the `plastic-auto` disarm/release prose (do
+not duplicate it here). The guided branch releases the lock via `disarm_auto`, which is
+mode-agnostic (it sets `auto = false` and calls `Worktree.release`), so it releases a guided
+lock too. When the work ships through a release, the release path merges the branch before the
+worktree is removed; the plain disarm remove is only for the no-release case.
+
+## References
+
+- `references/boarding-matrix.md` — the full boarding table and per-station behaviour.

package/skills/intent-starting/evals/evals.json

@@ -0,0 +1,117 @@
+{
+  "skill_name": "plastic-intent-starting",
+  "notes": "Intent 96. Scopes: description triggering (1-5) and behavior (6-10: lock-first spine, ask-mode-once, terminal report-only, mode->arm mapping, boarding matrix). The lock-first and gate behaviors are also proven by Ruby tests (test/bridge_guided_test.rb, test/lock_gate_test.rb, test/lock_gate_hook_test.rb).",
+  "evals": [
+    {
+      "id": 1,
+      "scope": "triggering",
+      "set": "train",
+      "prompt": "start work on intent 96",
+      "expected_output": "Activates plastic-intent-starting (board a session onto the named intent).",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-intent-starting", "result": "expect-pass" }
+      ]
+    },
+    {
+      "id": 2,
+      "scope": "triggering",
+      "set": "train",
+      "prompt": "continuing --intent 96",
+      "expected_output": "Activates plastic-intent-starting (the --intent form boards a specific intent).",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-intent-starting", "result": "expect-pass" }
+      ]
+    },
+    {
+      "id": 3,
+      "scope": "triggering",
+      "set": "validation",
+      "prompt": "work this intent",
+      "expected_output": "Activates plastic-intent-starting when an intent is in context to be worked.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-intent-starting", "result": "expect-pass" }
+      ]
+    },
+    {
+      "id": 4,
+      "scope": "triggering",
+      "set": "validation",
+      "prompt": "continue",
+      "expected_output": "Does NOT activate plastic-intent-starting; bare 'continue' is plastic-continuing (no specific intent named).",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE != plastic-intent-starting", "result": "expect-pass" }
+      ]
+    },
+    {
+      "id": 5,
+      "scope": "triggering",
+      "set": "validation",
+      "prompt": "create a new intent for the uploader retry policy",
+      "expected_output": "Does NOT activate plastic-intent-starting; activates plastic-creating-intent.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE != plastic-intent-starting", "result": "expect-pass" }
+      ]
+    },
+    {
+      "id": 6,
+      "scope": "behavior",
+      "set": "train",
+      "prompt": "Active intent X exists at the Why station. Start work on it (guided).",
+      "expected_output": "Takes the lock FIRST via Bridge.arm_guided (auto stays false) before any mutating work, confirms savepoint, then boards at Why and continues brainstorming toward spec.md.",
+      "files": [],
+      "assertions": [
+        { "type": "human", "check": "lock acquired before any mutating write; SKILL.md 'Lock FIRST' section precedes station work", "result": "expect-pass" },
+        { "type": "code", "check": "Bridge.arm_guided stamps the lock with auto=false (test/bridge_guided_test.rb green); lock-gate denies a no-lock write to the active intent dir (test/lock_gate_hook_test.rb green)", "result": "pass" }
+      ]
+    },
+    {
+      "id": 7,
+      "scope": "behavior",
+      "set": "train",
+      "prompt": "Start work on an active intent without saying auto or guided.",
+      "expected_output": "Asks 'auto or guided?' exactly once after reporting the station; never re-asks at later stations.",
+      "files": [],
+      "assertions": [
+        { "type": "human", "check": "SKILL.md asks the mode exactly once and states 'never re-asked at a later station'", "result": "expect-pass" }
+      ]
+    },
+    {
+      "id": 8,
+      "scope": "behavior",
+      "set": "train",
+      "prompt": "Start work on an intent that is Done in INDEX.",
+      "expected_output": "Reports only: no lock, no resume, no reopen. Summarizes the outcome and asks what is next.",
+      "files": [],
+      "assertions": [
+        { "type": "human", "check": "terminal intent -> report only, no arm call", "result": "expect-pass" }
+      ]
+    },
+    {
+      "id": 9,
+      "scope": "behavior",
+      "set": "validation",
+      "prompt": "Start work and choose auto.",
+      "expected_output": "guided -> Bridge.arm_guided; auto -> Bridge.arm_auto then hand off to plastic-auto (auto branch's only remaining job is the handoff).",
+      "files": [],
+      "assertions": [
+        { "type": "human", "check": "SKILL.md maps guided->arm_guided and auto->arm_auto+handoff to plastic-auto", "result": "expect-pass" }
+      ]
+    },
+    {
+      "id": 10,
+      "scope": "behavior",
+      "set": "validation",
+      "prompt": "Start an intent whose savepoint last line is 'How  checklist.md created'.",
+      "expected_output": "Boards at Exec (verify plan + checklist real), per references/boarding-matrix.md, and continues delivery/ticks the checklist.",
+      "files": [],
+      "assertions": [
+        { "type": "human", "check": "boarding matrix lands 'How checklist.md created' / 'Exec started' at Exec", "result": "expect-pass" }
+      ]
+    }
+  ]
+}

package/skills/intent-starting/references/boarding-matrix.md

@@ -0,0 +1,35 @@
+# Boarding matrix — which station Start drops you at
+
+The station is derived from `savepoint.md`'s last line plus the real artifacts on disk.
+Classify from the last line alone, then verify ONLY that line's artifact is real
+(sentinel-aware). On drift, rebuild the ledger from disk and note it.
+
+| savepoint last line | latest delivered | boards at | continue with |
+|---|---|---|---|
+| `What  {id}--{slug}.md` (born) | What | **What / Why** | What work (106-expanded), then brainstorm → `spec.md` |
+| `Why  started` (spec still sentinel) | What | **Why** | continue brainstorming → `spec.md` |
+| `Why  spec.md created` | Why | **How** | `plan.md` + `actions/` + `checklist.md` |
+| `How  started` / `How  plan.md created` | (How in progress) | **How** | finish `plan.md` → `checklist.md` |
+| `How  checklist.md created` / `Exec  started` | How | **Exec** | implement, tick the checklist |
+| `Exec  outcome.md created` | Exec | **ready to complete** | exit at Done |
+| `Done  delivered` / `Done  abandoned` | terminal | **report only** | immutable; ask what is next |
+
+## Per-station behaviour (what "continue" means)
+
+- **What** → do what What requires (to be expanded in 106), then brainstorm → `spec.md`.
+- **Why** → continue brainstorming; deliver `spec.md`.
+- **How** → continue `plan.md` + `actions/` + `checklist.md`.
+- **Exec** → verify what has been delivered, then continue (or restart) the delivery /
+  research. The first unchecked `checklist.md` item is the next step; the newest `## Insights`
+  entry supplies human-readable context.
+- **ready to complete** → `outcome.md` is real; run the ending procedure (~93).
+- **Done** → terminal. Report the outcome, ask what is next. Never reopen; INDEX is
+  authoritative.
+
+## Notes
+
+- The mode (auto / guided) is asked exactly ONCE, whatever station Start lands at. It is never
+  re-asked at a later station. The lock is taken FIRST regardless of station (terminal intents
+  excepted: they get no lock and no resume).
+- An `## Insights` entry marked `(autonomous)` means the intent was being delivered
+  autonomously; in guided mode, surface that and offer to hand back to `plastic-auto`.