@zalom/plastic 2.0.0-alpha.27 → 2.0.0-alpha.29

package/skills/agent-advisor/SKILL.md

@@ -1,84 +0,0 @@
----
-name: plastic-agent-advisor
-description: >-
-  Consult the advisor for expensive reasoning: one-way doors, plans, adversarial
-  review of a plan or conclusion before an irreversible step, a deadlock after two
-  failed attempts, or ranking several plausible options. Use when the user asks for
-  a second opinion, a hard design decision, an architecture review, help breaking a
-  deadlock, or says "ask the advisor". Also sets which advisor is the default when
-  asked ("make Primary Advisor my default", "switch my advisor", "use Secondary Advisor").
-user-invocable: true
----
-
-# Agent Advisor
-
-Plastic ships two consultation agents, never dispatched by the auto pipeline, summoned
-only when you decide the reasoning is worth buying:
-
-- **Primary Advisor** (`plastic-primary-advisor`): Fable at medium effort. Use it for
-  normal consultation.
-- **Secondary Advisor** (`plastic-secondary-advisor`): Fable at high effort. Use it only
-  as an explicit escalation for harder or higher-risk reasoning.
-
-## When to consult (and when not to)
-
-Buy a consultation for: decisions with one-way doors (architecture, migration order,
-public contracts); turning a goal plus evidence into a step plan with checks;
-adversarial review of your plan or conclusion before an irreversible step; a deadlock
-after two failed attempts where you cannot say why; ranking several plausible options
-when the ordering decides where you spend the next day.
-
-Never buy a consultation for: anything a tool can answer (search, reading code, running
-tests, documentation), writing code at volume, confirming a decision you already made,
-style or naming a linter would settle, or anything reversible and cheap you have not
-  tried first. The full buy/never-buy list, answer-shape table, and entry test live in
-`references/advisor-protocol.md`; read it before writing a brief for the first time in
-a session.
-
-## Routing: which advisor answers
-
-1. Read the harness-scoped config: `advisor.claude.default`, the only advisor routing key
-   the installer writes. If unset, use `plastic-primary-advisor`, the shipped default.
-2. If the user explicitly asks for Primary Advisor or Secondary Advisor, honor that choice for
-   this consultation. Otherwise, dispatch the configured agent from step 1.
-3. If `advisor.enabled` reads `false`, neither advisor agent nor this skill is
-   installed; this step should not be reachable, but if it is, tell the user the
-   advisor is disabled and point at "Setting the default" below.
-4. Dispatch the resolved agent with a brief built per `references/advisor-protocol.md`
-   section 4 (natural prose, the block is a completeness check, not a form to fill).
-   State the answer shape explicitly. Primary uses medium effort and Secondary uses high;
-   only an explicit owner config override changes either value.
-5. Consume the answer per the protocol's section 5: run the Operating Manual's
-   five-question self-test on the advisor's plan before executing it. Advice is input,
-   not authority; the plan is the advisor's, the outcome is yours.
-
-Read the resolved config value with:
-
-```bash
-ruby ~/.plastic/scripts/read-config advisor.claude.default --project <repo>
-```
-
-(Omit `--project` outside a registered project; falls back to the global value.)
-
-## Setting the default advisor
-
-When asked to change the default, present the two options in plain language and write the
-choice:
-
-- **Primary Advisor** (`plastic-primary-advisor`, recommended): Fable at medium effort.
-- **Secondary Advisor** (`plastic-secondary-advisor`): Fable at high effort.
-
-These are the same two options the installer offers at install and update time. Write
-the choice to `advisor.claude.default` in the global `~/.plastic/config.yml` (or the
-project's `.plastic_store/config.yml` when the user scopes the change to one project):
-read the file as YAML, set `advisor.claude.default` to the agent name (`plastic-primary-advisor`
-or `plastic-secondary-advisor`, never a model name or nickname), and write it back. Confirm
-the new default back to the user in one line.
-
-## References
-
-- `references/advisor-protocol.md`: the full shipped Advisor Protocol (what to buy,
-  answer shape, the entry test, how to write a brief that earns its cost, the
-  answer contract, session economics, anti-patterns). Read it before the first
-  consultation in a session; the second consultation in the same advisor thread costs a
-  fraction of the first, so keep follow-ups on one thread rather than opening a new one.

package/skills/auto/SKILL.md

@@ -1,297 +0,0 @@
----
-name: plastic-auto
-description: >-
-  Autonomous intent delivery - a background team takes a registered intent from How to End.
-  Use when user says "auto", "take it from here", "deliver this", or when a thinking
-  conversation concludes and the user confirms autonomous execution. Requires an active intent
-  in INDEX.md.
-user-invocable: true
----
-
-# Auto - Autonomous Intent Delivery
-
-Announce: "Taking over intent [ID] - [name] for autonomous delivery."
-
-**Advisory (not a rule).** At auto-mode start, recommend once that the user run this
-orchestrating session on the best available thinking model (Fable, Opus, or whatever supersedes
-them); this is advice only, and dispatched agents keep their configured model, never resolving
-to Fable without an explicit `agents.models.<name>` config override. Primary Advisor and
-Secondary Advisor are consultation roles the user or this session summons deliberately;
-the auto pipeline never dispatches them.
-
-## Precondition
-
-An active intent MUST exist in INDEX.md. If none exists, refuse: "No active intent found.
-Create one first with /plastic-intent-creating."
-
-If several active intents exist, ask which to deliver (the one question auto asks at boarding).
-
-**Picking work when no intent is specified.** If the user says "auto" without naming an intent
-and none is active, consult the roadmap first (the primary planning surface), then fall back to
-the dashboard queue:
-
-```bash
-ruby ~/.plastic/scripts/roadmap-next --roadmaps-dir <tier>/roadmaps
-```
-
-Branch on `state`: `dispatchable` means work its `dispatchable_queue` in `rank` order (the
-current batch's `queued` intents, parallel-safe within the batch); `in_flight` means the
-frontier batch is still delivering, report it and wait, never dispatch a later batch; `none` or
-`exhausted` means fall back to `ruby ~/.plastic/scripts/dashboard.rb all --json` and work its
-`dispatchable_queue` in `rank` order, leaving `human_only` and `next_big_thing` for the user.
-
-QMD-first (when available): when the user describes the work instead of naming an intent, run
-`ruby ~/.plastic/scripts/qmd-sync search "<terms>"` first, then open the hit's authoritative intent file; a no-op when QMD is absent.
-
-## Take the intent (do this FIRST)
-
-Immediately after selecting the intent, take it for this session. One verb acquires the durable
-`delivery.lock` in the intent directory (stamped `run_mode: auto`) and provisions the code worktree
-at `<repo>/.claude/worktrees/{id}--{slug}` on branch `plastic/{id}--{slug}`; the delivery lock
-names this session as the one delivering the intent, so the record hook writes savepoint lines
-and heartbeats for it instead of the day ledger:
-
-```bash
-codex="${CODEX_THREAD_ID:-}"; claude="${CLAUDE_CODE_SESSION_ID:-}"
-ruby ~/.plastic/scripts/plastic-lock arm --intent-dir "<STORE>/<dir>" --mode auto \
-  --agent plastic-enforcer \
-  ${codex:+--harness codex --session "$codex" --thread "$codex"} \
-  ${claude:+--harness claude --session "$claude"}
-```
-
-Replace `<STORE>` (`~/.plastic/projects/<slug>/store` or `~/.plastic/store`) and `<dir>` (the
-`ID--slug` directory). The snippet trusts a nonblank `CODEX_THREAD_ID` as Codex, otherwise a
-nonblank `CLAUDE_CODE_SESSION_ID` as Claude, otherwise passes no identity and the verb keys the
-lock by a derived session key. Never guess identity from an absent runtime variable; an
-unknown harness or thread stays unknown. Exit 1 means the lock is held, stale, excluded, or
-corrupt - or `inline_refused`: a conversation session may not arm an intent at all (owner rule
-2026-08-31); dispatch the delivery team instead. `--allow-inline` exists only for an explicit
-owner override. Do not proceed as the owner after an exit 1.
-
-Read `../plastic-conventions/references/locks-and-worktrees.md` for what the lock and the
-worktree mean and the station table behind them. Code edits happen only inside the worktree.
-
-## The shape
-
-Work is a graph (`graph.md`: Goal, Decisions, Graph, Status; one `nodes/*.md` per node) or,
-for work small enough to skip speccing, delivered inline with no separate plan review. There
-is no intent tier and no stage agent; depth follows the work.
-
-`runner step` computes readiness and prints a spawn block per dispatched node - agent, model,
-node input path, the test command, the call cap - fenced for a session to paste into the Agent
-tool; the runner never spawns (327 D42). `runner status` renders the ledger; `runner answer`
-closes a `needs_decision` node.
-
-A lead is a choice, not a requirement (D8, 355). A lead earns its keep on a graph carrying a
-decision node, weighing its `needs_decision` stop; a graph with none runs end to end from
-`runner step` alone. When this session leads, it is the `plastic-enforcer` role, never a
-dispatched agent.
-
-## Team
-
-- **plastic-enforcer**: this session. Writes the Why and How record, dispatches, applies
-  review findings, verifies, closes.
-- **plastic-executor**: one dispatch per intent, implements the consolidated action tests first,
-  ticks the checklist, appends `## Insights`, drives the suite green.
-- **the plan reviewer**: an optional dispatch before code, from `plastic-intent-executing`'s
-  `plan-reviewer-prompt.md`; a fresh agent, never the lead.
-- **the post-execution reviewer**: dispatched only by the risk rule, from
-  `code-quality-reviewer-prompt.md`; a fresh agent, never the maker.
-
-Spawn preamble (live-state injection): before dispatching any agent, run
-`scripts/spawn-preamble <intent_dir> --role <role>` and PREPEND its output to the prompt. The
-preamble is a deterministic, filesystem-only snapshot of the intent (id, intent line, current
-stage, the worktree path when it exists) plus the honoring instruction and the report contract.
-
-Dispatch-time model contract: resolve each agent's model through the config chain
-(`read-config agents.models.<basename> --project <repo>`: project override, then global, then
-the shipped default) and pass it explicitly at dispatch; never rely on the role's frontmatter
-alone.
-
-Completion report (require, then synthesize): every dispatched agent MUST end with a structured
-completion report as its final message (`references/agent-report-contract.md`). When an agent
-returns no usable report, run `scripts/agent-report <intent_dir> --role <role>` to synthesize a
-deterministic filesystem-derived one, so the handoff account always exists.
-
-### Delegation (agents writing under the owner's lock)
-
-This session owns the delivery lock. A dispatched agent runs in its own session, so register
-each one as a delegate before (or when) it needs to write into the intent dir:
-
-1. Instruct each spawned agent to report its session id and runtime identity in its first
-   message: `CODEX_THREAD_ID` for Codex, or `CLAUDE_CODE_SESSION_ID` for Claude. Use the
-   agent's own identity when known; never infer a harness or model from missing context.
-2. As the lock owner, run:
-   `ruby ~/.plastic/scripts/plastic-lock delegate --intent-dir <intent-dir> --delegate <specialist-session-id> --harness <specialist-harness-when-known> --agent <role> --model <resolved-model-when-known> --thread <reported-CODEX_THREAD_ID-when-Codex>`
-   Omit `--harness`, `--model`, or `--thread` when that value is unknown; `--agent <role>` is
-   always known from the roster.
-3. Immediately after the specialist returns, and before validating or dispatching
-   the next handoff, classify the return and record its activity status as the owner:
-   - `finished` means the specialist returned a usable completion report, whether
-     agent-authored or synthesized through `scripts/agent-report`.
-   - `failed` means the specialist returned blocked, errored, or without a usable
-     completion report that can be synthesized.
-4. Record the classification with exactly one of:
-   ```bash
-   ruby ~/.plastic/scripts/plastic-lock delegate --intent-dir <intent-dir> \
-     --delegate <specialist-session-id> --status finished --harness <same-specialist-harness-when-known> \
-     --agent <same-role> --model <same-resolved-model-when-known> --thread <same-CODEX_THREAD_ID-when-Codex>
-   ruby ~/.plastic/scripts/plastic-lock delegate --intent-dir <intent-dir> \
-     --delegate <specialist-session-id> --status failed --harness <same-specialist-harness-when-known> \
-     --agent <same-role> --model <same-resolved-model-when-known> --thread <same-CODEX_THREAD_ID-when-Codex>
-   ```
-   Apply the same omission rule to unknown values on terminal status commands. A failed agent
-   stops that handoff under the error procedure; never dispatch the next agent first.
-
-Only the owner can delegate. Delegates cannot re-delegate or release.
-
-Headless note: in a headless or background run the session id may be unset; the arm verb then keys the lock by a derived key and the record hook still writes the ledger.
-Verify with `plastic-lock status` rather than assuming.
-
-Solo fallback: on a harness with no agent dispatch (Codex CLI today), this session walks the
-graph (or the plan) itself, still writing the matrix and the tests first and reviewing its own
-plan against the matrix before code, saying so in `## Insights`.
-
-## Stage-Aware Entry
-
-Read the active intent's `savepoint.md` FIRST: the last line classifies the stage, and you
-verify only that line's artifact before entering. Fall back to the filesystem probe when the
-ledger is missing (then rebuild it with `Savepoint.rebuild_savepoint`).
-
-| Ledger last line | Enter |
-|---|---|
-| `What  {id}--{slug}.md` (born) or no spec | Why (write spec.md) |
-| `Why  spec.md created` | How |
-| `How  plan.md created` / `How  checklist.md created` / `Exec  started` | Exec (verify plan, matrix, checklist) |
-| `Exec  outcome.md created` | Exec done; complete the intent |
-| A terminal savepoint line (`delivered` or `abandoned`) | Terminal; do not resume |
-| A node or `Intent` transition line (`n1  running ...`, `Intent  needs_decision ...`) | Exec; a graph delivery is in progress - drive it through `scripts/runner`'s three public verbs, `step` (one turn of the dispatch loop), `status` (renders ledger state, safe to poll constantly), and `answer` (closes a `needs_decision` node) - read node status through `NodeLedger.status` before dispatching anything, never re-derive it by eye. `scripts/graph-measure` is the read-only sibling over that same ledger, with its own three public verbs `intent`, `budget`, and `cohorts` - it never dispatches and never writes |
-
-Filesystem fallback, in order: `checklist.md` with items checked means resume Exec from the
-first unchecked item; `plan.md` plus `checklist.md` means enter Exec; `spec.md` alone means
-enter How; `## Context` with content means complete Why; only `## Intent` means start Why.
-
-Announce which stage you are entering and why.
-
-## Why (the lead)
-
-For a graph delivery, Why is already written into `graph.md`'s Goal and Decisions; nothing
-else to do here. For work with no graph: read `## Context` and `### Decisions`, assess the
-gaps, research them yourself (code, docs, related intents through `## Links`, the web if
-needed; no questions to the human), record each decision in `## Context > ### Decisions` with
-its rationale, log it in `## Insights` with the `(autonomous)` marker through
-`scripts/insight-append`, and write `spec.md` only when the intent needs one (speccing is
-optional). Then How.
-
-## How (the lead), then the plan review
-
-For a graph delivery, How is `graph.md` itself: no `plan.md`, no separate plan review (D1,
-341). For work with no graph: write `plan.md` (numbered steps) and at least one real
-`actions/ACTION_N.md` carrying the failure-mode matrix (one row per operation, the failure
-mode, the test that catches it; a `.gitkeep`-only `actions/` is not a finished How), then
-`checklist.md` covering every action. The plan reviewer is optional, not a required step:
-when the delivery warrants review before code, dispatch it (boot 1) with
-`plastic-intent-executing`'s `plan-reviewer-prompt.md`, the spawn preamble, and the intent
-directory, apply every finding to the spec, the matrix, and the tests, and record what was
-dropped and why in the action file's review notes. A REVISE verdict is applied and not
-re-reviewed unless a finding changes a decision.
-
-Print `ruby ~/.plastic/scripts/report-screen plan <intent_dir>` as the first characters of
-the reply, nothing before it, no fence, before dispatching the executor (see
-`references/human-report-contract.md` for the full binding table). It informs; it does not wait.
-
-Then Exec.
-
-## Exec (the executor)
-
-For a graph delivery, `runner step` prints the spawn block for the next ready node; paste it
-into the Agent tool, verbatim. For work with no graph, dispatch `plastic-executor` (boot 2)
-through `plastic-intent-executing` with the whole consolidated action pasted in.
-
-1. Read the executor's return by code: DONE or DONE_WITH_CONCERNS proceeds; NEEDS_CONTEXT
-   re-dispatches with the missing context; BLOCKED stops under the error procedure.
-2. Tick the checklist as items land (the executor does this); verify tick-versus-diff against
-   the diff. A mismatch is a review finding, not a lead cleanup.
-
-## Review by risk (boot 3, only when a rule fires)
-
-Dispatch the post-execution reviewer with `code-quality-reviewer-prompt.md` when any of these
-holds, each checkable from disk with no judgment; otherwise the green suite is the review:
-
-1. `git diff --name-only <red-commit>..HEAD` touches a path on the risk list in
-   `references/agent-architecture.md` (hooks, the lock, the arming module, the installer, a
-   release file).
-2. A row of any failure-mode matrix (an `actions/ACTION_N.md` or a `nodes/*.md` file) names a
-   test file that is not in that diff, or a test the green run did not execute.
-3. The executor's completion report carries a status other than `delivered`, or a non-empty
-   `deviations` or `blockers` field.
-
-The reviewer returns a pass or a list of fixes; the executor (re-dispatched) applies them, then
-the suite runs once more. On a graph, the risk rule maps onto the verify nodes named in
-`graph.md`'s decisions; at most one review-fix round, never more.
-## Project Creation
-
-If the plan calls for creating a new project, determine the path from `~/.plastic/config.yml`
-`project_roots` or the intent context, confirm the path with the user (the one human
-interaction added mid-delivery), invoke `plastic-project-creating`, and continue from the
-project directory on the tactical intent.
-
-## Permission Model - Safe-by-Default
-
-Prefer non-destructive routes: rename instead of drop, additive migrations plus backfill, move
-files instead of deleting them, feature flags off instead of removed code, a backup before a
-migration. When a destructive action on an existing project has no safe alternative, log it in
-`## Insights`, notify the user ("Blocked on destructive action: ..."), and STOP unless
-`--skip-permissions` was given, in which case log and proceed. During initial project creation
-every choice is non-destructive and the team has full autonomy.
-
-## Completion
-
-Read `../plastic-conventions/references/completion-and-done.md` for what "intent done" means.
-
-1. This is the merge gate: verify every checklist item is checked, verify tick-versus-diff against the diff, and confirm the suite is green once on the branch.
-2. Write `outcome.md` from `~/.plastic/templates/outcome.md` with `disposition: delivered`,
-   `## Delivered` as the labeled table whose row labels match the action-file headings (317a).
-3. Release, if configured: match the working directory against `~/.plastic/projects.yml`, read
-   `project.yml`'s `release` block, and act on `on_complete` (`commit`, `commit_and_push`,
-   `manual`), `verify` (green proceeds; red follows `on_red`: `fix_and_retry` up to twice,
-   `stop`, or `manual`), and `on_green` (delegate entirely to `plastic-releasing`).
-4. Review `## Insights` for observations that should become future intents; create them through
-   `plastic-intent-creating` and update `chain`.
-5. Close through `plastic-intent-ending`, which runs `scripts/end-intent`: outcome, INDEX,
-   savepoint, the store commit, and the disarm (the worktree released, `delivery.lock`
-   cleared), then the QMD reindex last and the single owner
-   report. Pass `--session` and `--index-note`:
-   ```bash
-   ruby ~/.plastic/scripts/end-intent --store <store_path> --id <ID> --disposition delivered \
-     --session "$CLAUDE_CODE_SESSION_ID" \
-     --index-note "<what shipped>; <suite result>"
-   ```
-   Exit 4: a live foreign session holds the lock. 5: the worktree is dirty (commit first, or
-   pass `--discard-worktree-changes` deliberately). 3: the lock survived the disarm
-   (`/plastic-doctor check the lock status`). 6: the structure check refused. Never leave an
-   orphaned worktree; run `git worktree prune` on a stale reference.
-6. Print `ruby ~/.plastic/scripts/report-screen delivered <intent_dir>` once (D15/331f), and
-   `report-screen state` at each of the five triggers in `references/human-report-contract.md`
-   (a review verdict, a blocker, a merge/release, or an owner status ask; a mid-batch ask
-   instead runs `report-screen session <tier_root> --session "$CLAUDE_CODE_SESSION_ID"`, intent
-   330). Print each as the first characters of the reply: nothing before it, no fence, or the
-   hook cannot paint it.
-
-## Error Handling
-
-If the team gets stuck (an unresolvable gap, a missing dependency, a suite that stays red):
-log the blocker in `## Insights`, make sure `savepoint.md` reflects the state, notify the user
-("Blocked on intent [ID] - [name]: ..."), and STOP. Never work around a blocker in a way that
-leaves the project broken.
-
-## References
-
-- Read `references/agent-architecture.md` for the team model, the risk list, the headless note,
-  and the solo fallback when dispatching or when a harness has no agent dispatch.
-- Read `references/human-report-contract.md` for the three report screens and the five
-  triggers before printing the How or Completion screen above.
-- Read `references/agent-report-contract.md` for the completion report format when reading a
-  dispatched agent's return or synthesizing one.
-- Read `references/end-tail.md` for what `Arm.disarm` does at the End tail and why the reindex
-  runs last, before closing an intent.

package/skills/auto/evals/evals.json

@@ -1,255 +0,0 @@
-{
-  "skill_name": "plastic-auto",
-  "notes": "Intent 27. Scopes: description triggering (1-8) and behavior/output quality (9). Assertions written after observing Step-3 runs (one clean subagent router per case). Intent 63 added cases 10-11 (auto-mode enforcer-led team spin-up and solo fallback).",
-  "results": {
-    "triggering": {
-      "cases": 8,
-      "passed": 8,
-      "pass_at_1": 1.0,
-      "run": "2026-06-10, one subagent per case"
-    },
-    "behavior": {
-      "cases": 1,
-      "passed": 1,
-      "evidence": "dogfood: intent 27 itself delivered via auto produced spec->plan->checklist before any code edit; code-gate unit test proves pre-How project-code edits are blocked"
-    }
-  },
-  "evals": [
-    {
-      "id": 1,
-      "scope": "triggering",
-      "set": "train",
-      "prompt": "auto",
-      "expected_output": "Activates plastic-auto (the bare 'auto' keyword is the documented trigger).",
-      "files": [],
-      "assertions": [
-        {
-          "type": "code",
-          "check": "router CHOICE == plastic-auto",
-          "observed": "plastic-auto",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 2,
-      "scope": "triggering",
-      "set": "train",
-      "prompt": "take it from here and deliver intent 27 end to end",
-      "expected_output": "Activates plastic-auto (autonomous delivery of an active intent).",
-      "files": [],
-      "assertions": [
-        {
-          "type": "code",
-          "check": "router CHOICE == plastic-auto",
-          "observed": "plastic-auto",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 3,
-      "scope": "triggering",
-      "set": "validation",
-      "prompt": "go fully autonomous on the active intent, don't ask me questions",
-      "expected_output": "Activates plastic-auto.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "code",
-          "check": "router CHOICE == plastic-auto",
-          "observed": "plastic-auto",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 4,
-      "scope": "triggering",
-      "set": "train",
-      "prompt": "deliver this intent for me",
-      "expected_output": "Activates plastic-auto.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "code",
-          "check": "router CHOICE == plastic-auto",
-          "observed": "plastic-auto",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 5,
-      "scope": "triggering",
-      "set": "train",
-      "prompt": "set up a hook to automatically format the file on every save",
-      "expected_output": "Does NOT activate plastic-auto. Near-miss: shares 'auto*' but is a settings/hooks task (update-config).",
-      "files": [],
-      "assertions": [
-        {
-          "type": "code",
-          "check": "router CHOICE != plastic-auto",
-          "observed": "update-config",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 6,
-      "scope": "triggering",
-      "set": "validation",
-      "prompt": "deliver the built package to the dist directory",
-      "expected_output": "Does NOT activate plastic-auto. Near-miss: shares 'deliver' but is a build/file task.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "code",
-          "check": "router CHOICE != plastic-auto",
-          "observed": "none",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 7,
-      "scope": "triggering",
-      "set": "train",
-      "prompt": "create a new intent for the dashboard idea",
-      "expected_output": "Does NOT activate plastic-auto; activates plastic-intent-creating.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "code",
-          "check": "router CHOICE != plastic-auto",
-          "observed": "plastic-intent-creating",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 8,
-      "scope": "triggering",
-      "set": "validation",
-      "prompt": "what's the status of my active intents?",
-      "expected_output": "Does NOT activate plastic-auto; this is a read/intent-continuing query.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "code",
-          "check": "router CHOICE != plastic-auto",
-          "observed": "plastic-intent-continuing",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 9,
-      "scope": "behavior",
-      "set": "train",
-      "prompt": "Active intent X exists with only a '## Intent' section. Deliver it in auto mode.",
-      "expected_output": "Arms the lifecycle gate first, then produces spec.md (Why), then plan.md + actions/ + checklist.md (How), and edits NO project code before plan.md + checklist.md exist. Disarms on completion.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "human",
-          "check": "spec.md written before plan.md before any project-code edit",
-          "observed": "dogfood run of intent 27 followed this order",
-          "result": "pass"
-        },
-        {
-          "type": "code",
-          "check": "code-gate blocks project-code Edit/Write while pre-How (test/code_gate_test.rb)",
-          "observed": "test green",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 10,
-      "scope": "behavior",
-      "set": "train",
-      "prompt": "Active intent X exists. Deliver it in auto mode on a harness that supports subagents.",
-      "expected_output": "Spins up one enforcer-led team per intent (plastic-enforcer, executor, an on-request reviewer). The enforcer IS the orchestrator: it writes spec.md, the action files, and checklist.md itself, dispatches one executor for the consolidated action on one branch, and dispatches an independent reviewer subagent at the final gate only.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "human",
-          "check": "enforcer writes Why and How itself; one executor dispatched; independent reviewer only at final gate",
-          "observed": "dogfood: intents 60-62 delivered by exactly this enforcer-led team on a shared branch",
-          "result": "pass"
-        },
-        {
-          "type": "code",
-          "check": "agents/plastic-*.md role files ship and install into the harness agent dir, manifest-tracked (test/install_packaging_test.rb)",
-          "observed": "test green",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 11,
-      "scope": "behavior",
-      "set": "validation",
-      "prompt": "Active intent X exists. Deliver it in auto mode on a harness with no subagent dispatch.",
-      "expected_output": "Falls back to a single agent walking the full What, Why, How, Exec cycle itself, preserving current behavior. The enforcer gate discipline still applies (arm the gate first, no project-code edits before plan.md + checklist.md exist).",
-      "files": [],
-      "assertions": [
-        {
-          "type": "human",
-          "check": "solo agent walks the full cycle when subagent dispatch is unavailable; gate discipline preserved",
-          "observed": "SKILL.md Team Spin-Up documents the solo fallback explicitly",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 12,
-      "scope": "behavior",
-      "set": "validation",
-      "prompt": "A power-tool is present (qmd on PATH, or a .serena marker / serena on PATH). A substantive prompt arrives in auto mode.",
-      "expected_output": "The agent prefers the present tool because PLASTIC.md (loaded at session start) recommends QMD for intents and Enola, or Serena when Enola is absent, for code navigation. No hook appends a per-prompt line: the power-tools hook was removed in 2.0 (intent 309).",
-      "files": [],
-      "assertions": [
-        {
-          "type": "code",
-          "check": "PLASTIC.md carries the recommendation (doctrine_305_test) and PowerTools presence probes still back doctor's readiness checks (power_tools_test.rb)",
-          "observed": "doctrine_305_test test_plastic_md_carries_the_power_tools_mandate_as_a_recommendation; power_tools_test.rb presence probes",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 13,
-      "scope": "behavior",
-      "set": "validation",
-      "prompt": "Neither qmd nor serena is present (no qmd on PATH, no .serena marker, no serena on PATH). A substantive prompt arrives.",
-      "expected_output": "Detect-then-degrade: PLASTIC.md's recommendation applies only when a tool is present, so nothing is required to install and no per-prompt line appears (there is no hook to emit one since intent 309).",
-      "files": [],
-      "assertions": [
-        {
-          "type": "code",
-          "check": "PowerTools.mandate returns nil when neither tool is present",
-          "observed": "power_tools_test.rb test_mandate_neither_is_nil",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 14,
-      "scope": "behavior",
-      "set": "validation",
-      "prompt": "QMD is present. In auto mode the user says: deliver the work on the uploader retry policy (no intent id given).",
-      "expected_output": "Before scanning the store with grep/Read to find the matching intent, runs `ruby ~/.plastic/scripts/qmd-sync search \"uploader retry policy\"` to surface the candidate intent, then opens the authoritative intent file for the hit it takes over. This discovery step is distinct from the completion-time reindex step. No-op fallback to INDEX.md / file scan when QMD is absent.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "human",
-          "check": "qmd-sync search is run before grep/Read during discovery; authoritative file opened for the hit; reindex step stays separate",
-          "observed": "SKILL.md (or agent file) carries the QMD-first step: run qmd-sync search before grep/Read, then open the authoritative file; no-op fallback when QMD is absent",
-          "result": "pass"
-        }
-      ]
-    }
-  ]
-}