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

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

@@ -1,72 +0,0 @@
-{
-  "skill_name": "plastic-intent-creating",
-  "notes": "Intent 68. Scope: output-quality for the sources-vs-chain construction rules (D1/D2). Asserts the related-but-not-spawned case produces NO sources plus a predecessor chain link and a ## Links mirror, contrasted with the created-from case (true ascendant -> --sources set, reciprocal chain). The machine-checkable half lives in test/new_intent_test.rb (test_sources_path_gets_child_in_chain_frontmatter); this file documents the agent-facing scenario for skill evaluation and is NOT run by bin/test.",
-  "evals": [
-    {
-      "id": 1,
-      "scope": "behavior",
-      "set": "train",
-      "prompt": "Create an intent for adding a retry policy to the uploader. It's related to intent 41 (the upload pipeline work) but it's independent: it did not come out of intent 41's lifecycle.",
-      "expected_output": "A new root intent is created with EMPTY sources (it was not created from 41). The relation is recorded on the PREDECESSOR: intent 41 gains the new intent's id in its frontmatter chain, and a [[<new-id>]] wikilink is added to intent 41's ## Links. The new intent is NOT given 41 in --sources (the related-but-not-spawned rule). No false symmetry: 41 keeps the new id on chain with no reciprocal sources.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "code",
-          "check": "new intent sources is empty",
-          "observed": "sources: []",
-          "result": "pass"
-        },
-        {
-          "type": "code",
-          "check": "predecessor 41 chain includes new id",
-          "observed": "41.chain includes <new-id>",
-          "result": "pass"
-        },
-        {
-          "type": "code",
-          "check": "predecessor 41 ## Links has [[<new-id>]] mirror",
-          "observed": "[[<new-id>]] present in 41 ## Links",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 2,
-      "scope": "behavior",
-      "set": "validation",
-      "prompt": "Create an intent that is the direct continuation of intent 41: it emerged from intent 41's lifecycle and could not exist without it.",
-      "expected_output": "Because the new intent was genuinely CREATED FROM 41 (D1), it carries 41 in --sources (or branches from 41, which merges 41 into sources via the redundant-explicit rule). The reciprocal I1 backlink lands: intent 41's frontmatter chain gains the new intent's id. This is the created-from case, contrasted with the related-but-not-spawned case in eval 1.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "code",
-          "check": "new intent sources includes 41",
-          "observed": "sources includes 41",
-          "result": "pass"
-        },
-        {
-          "type": "code",
-          "check": "predecessor 41 chain includes new id (I1 reciprocity)",
-          "observed": "41.chain includes <new-id>",
-          "result": "pass"
-        }
-      ]
-    },
-    {
-      "id": 3,
-      "scope": "behavior",
-      "set": "validation",
-      "prompt": "QMD is present. The user says: create an intent to add retry to the uploader.",
-      "expected_output": "Before allocating the id / scaffolding, runs `ruby ~/.plastic/scripts/qmd-sync search \"add retry to the uploader\"` to surface a near-duplicate or true predecessor, then opens the authoritative intent file for any hit (reusing a near-duplicate or setting a real predecessor in --sources). No-op fallback to INDEX.md / file scan when QMD is absent.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "human",
-          "check": "qmd-sync search is run before id allocation; authoritative file opened for any hit; informs reuse / --sources",
-          "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"
-        }
-      ]
-    }
-  ]
-}

package/skills/intent-creating/references/lifecycle.md

@@ -1,81 +0,0 @@
-# Building an Intent — Full Lifecycle Detail
-
-## What → `## Intent` section
-
-The desire. One paragraph. What the human or agent wants.
-This exists from the moment the intent is created.
-
-**Deliverable:** `{ID}--{slug}.md`
-
-## Why → `## Context` + `### Decisions` sections
-
-Why this intent exists. Grows over time through brainstorming and exploration.
-
-- **Context** — what we knew going in + what we decided along the way
-- **Decisions** — main premises derived from Context plus decisions from brainstorming/grilling
-- Decisions are Why-level: "status belongs on actions because multiple workstreams", not How-level: "use ACTION_N.md files"
-
-**Deliverable:** `spec.md` (consolidated specification from Context + Decisions + brainstorming)
-
-## How → Planning and preparation
-
-Research decisions, create the implementation plan, define actions.
-
-**Deliverable:** `plan.md` + `actions/` + `checklist.md` (execution registry with checkboxes covering all actions)
-
-## Exec → Execute actions
-
-Execute actions from the plan, track progress via checklist.
-
-**Deliverable:** `outcome.md` (detailed result). `## Outcome` in intent.md = short summary written as last step.
-
-## `## Insights` — Append-only work log
-
-Captured throughout ALL stages. One-liner bullet points.
-Never modified, only appended.
-
-Tracks: stage transitions, decisions, shifts, blocks, cancellations, material for future intents.
-This is how execution is tracked. When this intent completes, Insights
-is where to look for what comes next. New intents spawned from this one,
-plus related-but-not-spawned successors it leads to, appear in the `chain`
-field.
-
-## `## Links`
-
-The human-readable projection of the local knowledge graph, mirroring the
-frontmatter exactly. Each entry is `- [[id--slug|<target's full intent: text>]]`,
-a clickable `id--slug` wikilink target with the target intent's full `intent:`
-text as the label (cross-store targets render
-`- [[store:id--slug|<target's full intent: text>]]`). Ordering is mandatory: all
-`sources` first (top), then all `chain`, frontmatter order preserved within each
-group. Sources never appear at the end. No source/chain tags, no sub-grouping. An
-intent with empty `sources` and `chain` carries the empty-state comment. Counterpart
-to the frontmatter `sources` / `chain` edges, for Obsidian graph navigation.
-
-## Conventions — Filesystem as Schema
-
-State is derived from what exists, not from what's declared.
-
-| Convention | Signal |
-|---|---|
-| No `## Context` | Intent is fleeting (quick capture, non-actionable) |
-| `## Context` has content | Intent is permanent (developed, actionable) |
-| `## Outcome` has content | Intent is done |
-| `## Insights` has `(autonomous)` entries | Intent is/was being delivered autonomously |
-
-### Transitions
-
-- Fleeting → permanent: add `## Context` (one-way, also makes it actionable)
-- There is no separate "non-actionable → actionable" transition — permanence implies actionability
-- Even research intents are actionable: the research itself is the action, the conclusion is the outcome
-
-## Creating an Intent — Full Steps
-
-1. Determine the target store: `~/.plastic/store/` for global intents (default), `~/.plastic/projects/{slug}/store/` for project intents
-2. Decide branch vs root (this sets whether you pass `--parent`)
-3. Scaffold with one call: `ruby ~/.plastic/scripts/new-intent --store <store> --intent "<one-line>" --slug <slug> [--parent <id>] [--sources id,id] [--tags ...]`. This allocates the id, creates the directory plus `actions/` and `resources/`, renders the born-complete intent file (frontmatter plus `## Intent`, `## Context`, `## Outcome`, `## Insights`, `## Links`), writes the sentinel placeholder lifecycle files, wires the reciprocal links, and self-validates.
-4. Update the appropriate `INDEX.md` — add to Active section and appropriate cluster
-
-The intent file is born complete with all five sanctioned `##` sections; the lifecycle files (`spec.md`/`plan.md`/`checklist.md`/`outcome.md`) are sentinel placeholders that read as "stage not reached" until an agent fills them and deletes the `<!-- plastic:placeholder -->` first line.
-
-Always scaffold through `new-intent` (or this skill). Never hand-author intent files: `new-intent` validates the file it writes (`scripts/validate-intent`) and `end-intent` checks it again at close, and hand-authoring is the bypass this contract is designed to remove.

package/skills/intent-creating/references/wikilinks.md

@@ -1,8 +0,0 @@
-# Wikilink Conventions
-
-| Syntax | Meaning |
-|--------|---------|
-| `[[ID]]` | Link to intent in same store (e.g., `[[1a1]]`) |
-| `[[ID\|display text]]` | Link with human-readable label |
-| `[[global:ID]]` | Link to intent in `~/.plastic/store/` |
-| `[[project-slug:ID]]` | Link to intent in `~/.plastic/projects/{slug}/store/` |

package/skills/intent-ending/SKILL.md

@@ -1,182 +0,0 @@
----
-name: plastic-intent-ending
-description: >
-  Wrap, finish, or close an intent as delivered or abandoned. Use
-  when completing or abandoning an intent, when a graph's last node
-  reaches a terminal status (or, for a legacy intent, a checklist
-  reaches 100 percent) and Exec is finished, or when asked to "wrap
-  this up".
-user-invocable: true
----
-
-# Intent Ending
-
-The one procedure every terminal transition routes through. Auto mode, the
-curator path, and releasing all call this skill (or its backing script,
-`scripts/end-intent`) for the mechanical close instead of restating the same
-prose three times. `abandoned` is the SAME procedure as `delivered`, not a
-failure branch: only outcome.md content and the INDEX section differ.
-
-Read `../plastic-conventions/references/completion-and-done.md` for what "intent done" means and
-the End-stage tail behind the steps below. This path resolves relative to this skill's own
-installed directory.
-
-## The 8 steps (0-7)
-
-| # | Step | Who does it |
-|---|---|---|
-| 0 | Precondition check | You, before touching outcome.md |
-| 1 | backfill spec/plan/action/outcome from the record, self-check, intent-file `## Outcome` summary | `scripts/end-intent` |
-| 2 | INDEX.md terminal move (Active -> Completed/Abandoned) | `scripts/end-intent` |
-| 3 | the terminal savepoint line | `scripts/end-intent` |
-| 4 | store auto-commit | `scripts/end-intent` |
-| 5 | disarm (worktree + lock) | `scripts/end-intent` (intent 188) |
-| 6 | QMD reindex, async, LAST | You |
-| 7 | EM-to-CTO report | You |
-
-Steps 1-5 are ONE callable script call, not several separate one-liners: this
-is exactly what the failure mode this intent fixes looked like (releasing hand
-authored the close in prose and dropped the savepoint bookend for two real
-deliveries; separately, one session delivered four intents back to back and
-never ran the old step-5 one-liner at all, intent 188). Never restate
-outcome/INDEX/savepoint/disarm prose inline again; call `scripts/end-intent`.
-
-### Step 0. Precondition (the record is what gets backfilled)
-
-Nothing refuses the close any more (the 1.x write-time gate and `end-intent`'s
-exit-6 structure gate were retired in 2.0, intents 302 and 308). What you leave
-on disk is what the record becomes, so before the call:
-
-1. For an intent with a `graph.md`: confirm every node's Status in `graph.md` is
-   terminal (`done` or `failed_verification`, nothing left `running`, `blocked`, or
-   waiting `needs_decision`), and that the last verify node's gates were
-   accepted. A node still open is not a refusal, it is a reported gap that lands
-   verbatim in the backfilled `## Follow-ups`.
-   For an intent with no `graph.md` (legacy): read checklist.md, tick every item as
-   it is actually performed, including an item that describes the close itself:
-   running this very procedure IS what that item describes; an unchecked box is not
-   a refusal, it is a reported gap. Also confirm every acceptance criterion in
-   spec.md is verifiable (tests pass, or the manual check described in its HOW line
-   was actually run).
-2. Decide what you have to say. For an intent with a `graph.md`, never hand-write
-   `outcome.md`: `scripts/end-intent` GENERATES it, through
-   `scripts/lib/outcome_report.rb` (`scripts/outcome-report` is its standalone
-   CLI, useful for checking the generated text before the close). `## Delivered`,
-   `## Verification`, `## Graph diff`, and `## Findings` are read straight from
-   `graph.md`, `nodes/`, and the ledger every time, in plain wording a reader
-   recognizes, never hand-typed; when the generated wording is wrong, fix
-   `graph.md` or `nodes/`, the source it reads from, not the report. `## Summary`,
-   `## Needs you`, and `## Follow-ups`, and every frontmatter key but
-   `disposition`, are preserved byte for byte when you author them and
-   generated as plain facts otherwise. For an intent with no `graph.md`, a
-   spec.md, plan.md, action file, or outcome.md left as the scaffold placeholder
-   is written from the record by `scripts/end-intent` (the intent file's
-   `## Intent`, `### Decisions`, and `## Insights`, the checklist, the worktree
-   diff). A file you wrote, even under a still-present sentinel, is never touched.
-
-### Step 1-5. Run `scripts/end-intent`
-
-For an intent with a `graph.md`, do not author `outcome.md` by hand: run
-`ruby ~/.plastic/scripts/outcome-report <intent_dir> --write --disposition delivered|abandoned`
-if you want to see the generated text before the close, or let the single call below write it.
-`## Summary`, `## Needs you`, and `## Follow-ups` are the sections worth your own words; edit
-those into the file before the call when the generator's plain facts say too little (they are
-preserved byte for byte). `## Needs you` is the literal None or a `| N | What | Why |` table.
-On abandon, `## Summary` states the abandonment reason and the trail (see Pivot below). An
-intent with no `graph.md` gets a placeholder outcome.md backfilled from the record instead,
-with the close's disposition and the `--outcome-summary` line as its summary. Also author the
-rich INDEX entry note now (a short line in the store's existing Completed/Abandoned
-convention: mode, what shipped or why it was abandoned, suite result, merge/spawn notes);
-content authoring stays with you, `--index-note` only appends what you write.
-
-Then call the script once:
-
-```bash
-ruby ~/.plastic/scripts/end-intent \
-  --store <store_path> --id <intent_id> --disposition delivered|abandoned \
-  --session "$CLAUDE_CODE_SESSION_ID" \
-  --outcome-summary "<one-line ## Outcome summary for the intent file>" \
-  --index-note "<rich Completed/Abandoned entry description>"
-```
-
-This does all of steps 1-5 in order: backfills every missing or placeholder
-spec.md, plan.md, action file, and outcome.md from the record (never a file
-you wrote), runs doctor's per-intent structure check and the outcome guard as
-a self-check that reports on stderr and proceeds (an unchecked box, a
-malformed intent file, a wrong-disposition outcome.md you wrote), stamps the
-intent file's `## Outcome` section, moves the INDEX.md
-line from `## Active` to `## Completed` or `## Abandoned` (dated today,
-idempotent, accepting either a real em dash or a plain hyphen as the id/
-title separator on read while always emitting the real em dash on write)
-with the `--index-note` text appended after the date so the entry stays
-rich, appends the terminal savepoint line, commits the store repo, and
-disarms (releases the code worktree and clears `delivery.lock`, verified
-against the durable lock file on disk, never merely trusted). Omit
-`--index-note` for a thin id+date entry, add `--no-commit` when a separate
-commit step already covers the store (this never skips disarm), and
-`--dry-run` to preview steps 1-5 with no writes.
-
-Read `../plastic-conventions/references/completion-and-done.md` for the pre-flight lock guard
-and the dirty-worktree refusal this call runs before writing anything (exit 4 and exit 5
-below); this procedure only calls `end-intent`, it never re-implements them.
-
-On the auto mode / curator path (no release), this single call performs the
-FULL disarm (plain worktree remove, since the branch survives for later
-reclaim). On a release-shipped path, `skills/releasing/SKILL.md` merges and
-removes the worktree FIRST (its own step 8, merge-then-remove) before ever
-calling this script, so by the time this call's step 5 runs, the worktree is
-already gone (a harmless no-op) and only the lock is left to clear,
-correctly, for the first time on that path (D7).
-
-Exit codes: 0 success (the intent is closed AND its delivery lock is gone);
-1 a usage or resolution failure, OR an INDEX id that resolves to neither
-`## Active` nor the terminal section; 3 steps 1-4 already committed
-but disarm could not verify the lock is gone afterward (run `/plastic-doctor
-check the lock status`); 4 a live foreign session holds the lock (back off);
-5 the code worktree is dirty (commit/stash first, or pass
-`--discard-worktree-changes` deliberately).
-
-### Step 6. QMD reindex, LAST
-
-Only after step 5 has released the worktrees and cleared the lock, so the
-index never references state about to disappear:
-
-```bash
-ruby ~/.plastic/scripts/qmd-sync reindex --store <store-root> --async
-```
-
-No-op when QMD is absent. Runs in the background so it never blocks the
-turn.
-
-### Step 7. Print `delivered`
-
-Print `ruby ~/.plastic/scripts/report-screen delivered <intent_dir>` as the first characters
-of the reply: nothing before it, no fence, or the hook cannot paint it. Asked, Delivered (with
-its Proven-by column), Evidence, and Needs you come straight from the record - the EM-to-CTO
-report, impact and risk first, in plain language, with the decision left to the human (merge,
-release, or accept). See `outcome.md` for the details; do not restate it verbatim.
-
-## Abandoned is the same procedure
-
-`disposition: abandoned` runs the identical steps 0-7. The only differences
-are outcome.md content (Summary states why this was abandoned, not what was
-delivered) and the INDEX target section (`## Abandoned` instead of
-`## Completed`). Never branch the mechanical steps by disposition; the
-script already does that internally.
-
-## Mid-flight pivot
-
-When the work that shipped differs from what spec.md or plan.md originally
-called for, do not retcon those documents. Record the decision once in
-`## Insights`, then let outcome.md carry the truth of what actually
-happened, including the abandoned trail when part of the work was dropped
-mid-flight. outcome.md is truth of delivery; spec and plan stay the
-historical record of what was planned.
-
-## Routing
-
-`plastic-releasing`, `plastic-auto`, and `plastic-intent-executing` all delegate their mechanical
-close to this skill (or call `scripts/end-intent` directly for steps 1-5).
-None of them restate the outcome/INDEX/savepoint/disarm prose inline any
-more; if you find one that does, that surface has drifted and should route
-here instead.

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

@@ -1,74 +0,0 @@
-{
-  "skill_name": "plastic-intent-ending",
-  "notes": "Intent 161. Scopes: description triggering (3-6) and behavior (1-2: the two mandatory D6 cases). Case B graduates into test/end_intent_test.rb (test_done_bookend_lands_once_and_is_idempotent) per evaluating-skills conventions.",
-  "evals": [
-    {
-      "id": 1,
-      "scope": "behavior",
-      "set": "train",
-      "prompt": "checklist.md has one unchecked non-completion item. Try to complete the intent.",
-      "expected_output": "Ticks or finishes the item before calling scripts/end-intent, because an unchecked box is reported by the structure self-check and lands verbatim in the backfilled Follow-ups; never a refusal (the write-time gate was removed in 2.0, intents 302 and 308).",
-      "files": [],
-      "assertions": [
-        { "type": "human", "check": "SKILL.md Step 0 states that nothing refuses the close, that an unchecked box is a reported gap landing in Follow-ups, and instructs finishing the checklist before the call", "result": "expect-pass" },
-        { "type": "code", "check": "scripts/end-intent exits 0 on an unchecked '- [ ]' item and prints 'structure check: intent_checklist_complete' (test/end_intent_test.rb)", "result": "pass" }
-      ]
-    },
-    {
-      "id": 2,
-      "scope": "behavior",
-      "set": "train",
-      "prompt": "Run the mechanical close (scripts/end-intent) for a delivered intent with a real outcome.md.",
-      "expected_output": "The terminal savepoint line lands exactly once in savepoint.md, and a second run of the same command does not duplicate it (this is the regression the intent fixes: releasing used to skip this line entirely).",
-      "files": [],
-      "assertions": [
-        { "type": "human", "check": "SKILL.md Step 1-4 calls scripts/end-intent as one script instead of restating the outcome/INDEX/savepoint one-liners in prose", "result": "expect-pass" },
-        { "type": "code", "check": "test/end_intent_test.rb#test_done_bookend_lands_once_and_is_idempotent is green", "result": "pass" }
-      ]
-    },
-    {
-      "id": 3,
-      "scope": "triggering",
-      "set": "train",
-      "prompt": "Mark intent 87 done, it shipped.",
-      "expected_output": "Activates plastic-intent-ending to run the mechanical close (outcome.md, INDEX move, savepoint bookend, commit, disarm, reindex, report).",
-      "files": [],
-      "assertions": [
-        { "type": "code", "check": "router CHOICE == plastic-intent-ending", "result": "expect-pass" }
-      ]
-    },
-    {
-      "id": 4,
-      "scope": "triggering",
-      "set": "train",
-      "prompt": "This one's not worth finishing, abandon it and wrap this up.",
-      "expected_output": "Activates plastic-intent-ending (indirect trigger: 'wrap this up' names no lifecycle vocabulary directly). Abandoned runs the identical procedure, only outcome.md content and the INDEX section differ.",
-      "files": [],
-      "assertions": [
-        { "type": "code", "check": "router CHOICE == plastic-intent-ending", "result": "expect-pass" }
-      ]
-    },
-    {
-      "id": 5,
-      "scope": "triggering",
-      "set": "validation",
-      "prompt": "Start work on intent 87.",
-      "expected_output": "Does NOT activate plastic-intent-ending; this is a resume request (plastic-intent-continuing), the opposite end of the lifecycle from a close.",
-      "files": [],
-      "assertions": [
-        { "type": "code", "check": "router CHOICE != plastic-intent-ending", "result": "expect-pass" }
-      ]
-    },
-    {
-      "id": 6,
-      "scope": "triggering",
-      "set": "validation",
-      "prompt": "Cut a release and tag it v1.2.0.",
-      "expected_output": "Does NOT activate plastic-intent-ending directly; activates plastic-releasing, which internally calls scripts/end-intent for the mechanical close as one of its own steps.",
-      "files": [],
-      "assertions": [
-        { "type": "code", "check": "router CHOICE == plastic-releasing", "result": "expect-pass" }
-      ]
-    }
-  ]
-}

package/skills/intent-executing/SKILL.md

@@ -1,87 +0,0 @@
----
-name: plastic-intent-executing
-description: Use when you have a graph or a plan to execute. A graph delivery runs on
-  `scripts/runner`'s three verbs, `step`, `status`, and `answer`; older, non-graph work
-  dispatches the `plastic-executor` agent for one consolidated action.
-user-invocable: true
----
-
-# Executing a Plan
-
-## Step 0: Sync Worktree First
-
-Before touching any file the graph or the plan names, sync the code worktree with main so no
-edit lands on a path a merged rename or delete already removed:
-
-```
-git -C <worktree> fetch origin && git -C <worktree> merge --ff-only origin/main
-```
-
-If a named file or directory is missing (renamed or removed upstream), stop and report it
-rather than editing a stale path. Read
-`../plastic-conventions/references/locks-and-worktrees.md` for delivery isolation before
-touching the worktree above.
-
-## step
-
-`ruby scripts/runner step <intent_dir>` computes which nodes in `graph.md`/`nodes/*.md` are
-ready, applies dispatch policy (model, call cap), and prints a spawn block per dispatched node
-- agent, model, node input path, the one test command, the call cap - fenced in its own stdout.
-The runner itself never spawns an agent (327 D42). Call `step` again after each dispatched
-node returns.
-
-### Graph dispatch: the paste
-
-The dispatch step is the paste, not a lead's hand-typed brief: copy each spawn block into the
-Agent tool as its own dispatch, verbatim.
-
-On Claude Code, the session spawns each dispatched node as a background subagent of its
-per-kind agent (`plastic-node-work`, `plastic-node-verify`, `plastic-node-research`) named in
-the spawn block. On Codex, one node runs over `codex exec` in a sandbox scoped to its kind and
-writes only a return file, which the next `step` absorbs the same way it absorbs a Claude Code
-return.
-
-## status
-
-`ruby scripts/runner status <intent_dir>` renders the graph's ledger state: which nodes are
-running, done, blocked, or waiting on a decision. Safe to poll constantly; read node status
-through `NodeLedger.status` before dispatching anything, never re-derive it by eye.
-
-## answer
-
-`ruby scripts/runner answer <intent_dir> --node <id> --decision "<text>"` closes a
-`needs_decision` node with the owner's ruling, recorded to the ledger, so `step` can resume
-the graph past it.
-
-## Non-graph work
-
-When the intent has no `graph.md`, dispatch ONE `plastic-executor` subagent with the whole
-consolidated action pasted in (never a file reference): every task's full text, every action
-file with its failure-mode matrix, the checklist items it must tick, the project context, and
-the worktree path. It writes the matrix's tests and commits them red, implements the
-consolidated action in order, ticks each item as it lands (see `## Tick-as-you-land`), and
-drives the test suite green. Read its response by code: DONE or DONE_WITH_CONCERNS proceeds;
-NEEDS_CONTEXT provides the missing context and re-dispatches; BLOCKED stops and reports.
-
-## Tick-as-you-land
-
-A tick is two edits, made together: mark the item's box `[x]`, and move its
-checklist item from `## In Progress` to `## Completed` in `checklist.md`;
-then add one `## Session Log` row (Date, Items Completed, Notes). The box is
-the half the state screen's Progress bar reads: `IntentScreen::ITEM_RE` and
-`progress_fields` count `[x]`, not which section the line sits in, so a line
-moved to `## Completed` with its box left unmarked still reads as zero
-progress. Do not batch several tasks' worth of checklist updates into one
-later edit; tick the moment the task is verified, before moving to the next
-task.
-
-## Position in the cycle
-
-- **Before:** the graph (`graph.md`, `nodes/*.md`), or `plan.md`/`checklist.md`, exists; the
-  worktree is armed.
-- **Produces:** code changes and a ticked checklist.
-- **Next:** `plastic-intent-ending` owns `outcome.md`, generated through
-  `scripts/outcome-report`, and the rest of the mechanical close.
-
-Read `../plastic-conventions/references/lifecycle-and-savepoints.md` for the subagent
-report-home contract this handoff relies on.

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

@@ -1,66 +0,0 @@
-{
-  "skill_name": "plastic-intent-executing",
-  "notes": "Intent 164. New evals.json for the executing-plan skill: refuse-to-present-unverified, sync-worktree-first, and the reroute-vs-dispatch distinction. All assertions are pending a real observed run per the plastic-evaluating-skills convention.",
-  "evals": [
-    {
-      "id": 1,
-      "scope": "behavior",
-      "set": "train",
-      "prompt": "A task just landed: a new method was added and its test file was written. The agent is about to tell the owner the task is done and move to the next one.",
-      "expected_output": "Before presenting the completed task to the owner, the agent independently verifies it: greps the changed file or runs the specific test, rather than restating what it intended to do. It does not present the claim until the grep or test run has actually been observed.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "human",
-          "check": "a grep or test run against the actual artifact is shown before the owner-facing claim; no claim is presented as done without that observed check",
-          "result": "expect-pass"
-        }
-      ]
-    },
-    {
-      "id": 2,
-      "scope": "behavior",
-      "set": "validation",
-      "prompt": "The agent finished implementing a task and, without running anything, tells the owner \"Task 3 is complete and the tests pass.\"",
-      "expected_output": "This is a refusal case: the skill does not allow presenting a pass claim without first grepping or running the artifact. The correct behavior is to run the verification first and only then report the observed result.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "human",
-          "check": "the skill's stated hard rule blocks an unverified claim like this; expected behavior is verify-then-report, not report-then-hope",
-          "result": "expect-pass"
-        }
-      ]
-    },
-    {
-      "id": 3,
-      "scope": "behavior",
-      "set": "train",
-      "prompt": "Execution is starting for an intent whose plan.md was written two days ago; the code worktree has not been touched since.",
-      "expected_output": "Before Step 1 (Load Plan), the agent syncs the code worktree with main: `git -C <worktree> fetch origin && git -C <worktree> merge --ff-only origin/main`, then verifies the plan's target files exist at the paths plan.md names before editing any of them.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "code",
-          "check": "the fetch-and-merge --ff-only sync command runs before Load Plan; target file existence is checked before the first edit",
-          "result": "expect-pass"
-        }
-      ]
-    },
-    {
-      "id": 4,
-      "scope": "behavior",
-      "set": "validation",
-      "prompt": "The plan's next step reads \"run /plastic-intent-speccing\" as a human-facing instruction to consolidate the spec once Exec finishes an audit task.",
-      "expected_output": "The agent tells the user to type the /plastic-intent-speccing command themselves; it does not dispatch a subagent with that slash-command text as a prompt, and it does not paste an agent-facing dispatch prompt at the user instead.",
-      "files": [],
-      "assertions": [
-        {
-          "type": "human",
-          "check": "the slash-command instruction is directed at the user, not handed to the Agent tool as a subagent prompt; no dispatch-prompt text leaks into the user-facing message",
-          "result": "expect-pass"
-        }
-      ]
-    }
-  ]
-}

package/skills/intent-executing/implementer-prompt.md

@@ -1,47 +0,0 @@
-# Implementer Subagent Prompt
-
-You are implementing a specific task from a plan. You have been given the full task text below.
-
-## Your Task
-
-{{TASK_TEXT}}
-
-## Project Context
-
-{{PROJECT_CONTEXT}}
-
-## Active Intent
-
-{{INTENT_CONTEXT}}
-
-## Instructions
-
-1. Read the task carefully. If anything is unclear, report NEEDS_CONTEXT with what you need.
-2. Implement exactly what the task specifies — nothing more, nothing less.
-3. Write tests first when the task includes test steps (TDD).
-4. Follow the file paths specified in the task exactly.
-5. Commit after each logical unit of work, and in the same step tick the checklist item that
-   unit lands: mark its box `[x]` and move the line to `## Completed`, then append the
-   savepoint `Commit` line
-   (`scripts/savepoint-note <intent_dir> --kind Commit --text "<sha> <what it proves>"`). A
-   commit without its tick is incomplete.
-6. When done, self-review against this checklist:
-   - [ ] All steps in the task are completed
-   - [ ] Tests pass
-   - [ ] Code is clean and follows project conventions
-   - [ ] No unrelated changes
-   - [ ] Every landed unit's checklist item is ticked
-
-## Report Format
-
-End your work with one of these status lines:
-
-**DONE** — All steps completed, tests pass, code committed.
-
-**DONE_WITH_CONCERNS** — Completed but I noticed: [describe concerns].
-
-**NEEDS_CONTEXT** — I need clarification on: [specific questions].
-
-**BLOCKED** — Cannot proceed because: [describe blocker].
-
-It is always OK to report BLOCKED or NEEDS_CONTEXT. Do not guess or improvise when uncertain.

package/skills/intent-executing/spec-reviewer-prompt.md

@@ -1,27 +0,0 @@
-# Spec Compliance Reviewer Prompt
-
-The implementer says they finished this task. Verify independently — their report may be incomplete or optimistic.
-
-## Task Requirements
-
-{{TASK_TEXT}}
-
-## Instructions
-
-1. Read the actual code that was written (not the implementer's report)
-2. Compare line by line against the task requirements
-3. Check for:
-   - Missing requirements — anything in the task that wasn't implemented
-   - Extra work — anything added that the task didn't ask for
-   - Misunderstandings — code that doesn't match what the task intended
-   - Test coverage — are all specified behaviors tested?
-
-## Report Format
-
-**PASS** — All task requirements are correctly implemented. No gaps, no extras.
-
-**FAIL** — Issues found:
-- [file:line] Description of what's wrong and what was expected
-- [file:line] Description of what's missing
-
-Be specific. Reference exact file paths and line numbers.