@zalom/plastic 2.0.0-alpha.21 → 2.0.0-alpha.23

package/skills/auto/references/agent-architecture.md

@@ -29,12 +29,13 @@ in 2.0, intent 304; the lead writes the Why and How record itself):
 - **plastic-executor** (Exec): commits the matrix's tests red, writes the code, checks off
   `checklist.md`, appends `## Insights`, and drives the suite green.
 - **the plan reviewer**: a fresh agent on `plastic-intent-executing`'s
-  `plan-reviewer-prompt.md`, dispatched once before any code exists.
+  `plan-reviewer-prompt.md`, an optional dispatch before any code exists.
 - **the post-execution reviewer**: a fresh agent on `code-quality-reviewer-prompt.md`,
   dispatched only when the auto skill's risk rule fires; never the maker.
 
-Two agent boots is the normal delivery (the plan reviewer, the executor); the post-execution
-reviewer is the third only when risk calls for it.
+One agent boot (the executor) is the minimum delivery; the plan reviewer is a second,
+optional boot when the lead calls for review before code, and the post-execution reviewer is
+a third only when risk calls for it.
 
 ### Handoff Contracts
 
@@ -44,8 +45,8 @@ the code, the red and green commits, a checked-off checklist, `## Insights`, and
 report. Dispatch is sequential on a single branch, because the deliverables share files.
 
 The chain: intent `## Intent` / `## Context`, then enriched `## Context` plus `### Decisions`,
-then `spec.md`, then `plan.md` plus `actions/` plus `checklist.md`, then the plan review, then
-the code changes plus a checked-off checklist plus `## Insights`.
+then `spec.md`, then `plan.md` plus `actions/` plus `checklist.md`, then an optional plan
+review, then the code changes plus a checked-off checklist plus `## Insights`.
 
 ### Spawn Preamble (L2 live-state injection)
 
@@ -88,9 +89,10 @@ not revoke the registered delegate's authorization.
 
 ### Review Ownership
 
-The lead owns every review decision: it dispatches the plan reviewer before code, folds the
-findings itself, and decides from the risk rule whether the post-execution reviewer runs. It
-never delegates that decision, and neither reviewer is ever the maker of what it reviews.
+The lead owns every review decision: it dispatches the plan reviewer before code when one
+runs, takes the review into its own record, and decides from the risk rule whether the
+post-execution reviewer runs. It never delegates that decision, and neither reviewer is ever
+the maker of what it reviews.
 Nothing blocks a write in 2.0 (the gate hooks were removed, intent 302); the lock, the
 worktree, and the record are how the team keeps one delivery in one place.
 

package/skills/auto/references/human-report-contract.md

@@ -78,7 +78,7 @@ an executor's intermediate commit, or an agent going idle is NOT one of them:
 
 | Trigger | Scope |
 |---|---|
-| A savepoint line lands (a stage boundary: Why, How, Exec started, outcome written, Done) | that intent |
+| A savepoint line lands (a stage boundary: Why, How, Exec started, outcome written, End) | that intent |
 | A review verdict returns (plan review or post-execution review), naming what it changed | that intent |
 | A blocker or needs-input is logged | that intent |
 | A merge or a release lands | that intent |

package/skills/conventions/references/completion-and-done.md

@@ -1,16 +1,16 @@
-# Completion and Done
+# Completion and the End Tail
 
 This chapter holds what "intent done" means and the End-stage tail.
 
 #### What "intent done" means (intent 93)
 
-Done is one law with three signals, and they must agree. INDEX `## Completed` /
+Completion is one law with three signals, and they must agree. INDEX `## Completed` /
 `## Abandoned` is the single canonical terminal marker: it is the store-wide ledger a fresh
 session reads first, so it wins on any conflict. `outcome.md` is the "deliverable exists"
-signal, and the savepoint `Done delivered|abandoned` line is the audit echo. All three must
-agree; when they disagree, INDEX is authoritative and `doctor` flags the mismatch (the
+signal, and the savepoint's terminal `delivered|abandoned` line is the audit echo. All three
+must agree; when they disagree, INDEX is authoritative and `doctor` flags the mismatch (the
 `done_signals` check: `outcome.md` real but still under `## Active`, or terminal without a
-real `outcome.md`, or a terminal intent whose savepoint carries no `Done` line).
+real `outcome.md`, or a terminal intent whose savepoint carries no terminal disposition line).
 
 `outcome.md` is mandatory at every terminal transition, delivered and abandoned alike. It
 self-declares its disposition through a `disposition: delivered|abandoned` frontmatter
@@ -18,8 +18,8 @@ header. The delivered path authors it with the result; the abandoned path author
 the abandonment reason and no longer leaves the scaffolded placeholder sentinel in place.
 
 The canonical End tail runs in this order, and the QMD reindex is always LAST, after the
-purge: `outcome.md -> INDEX terminal -> savepoint Done -> commit -> disarm (Worktree.release
--> Lock.release -> purge) -> QMD reindex`. Running the reindex last keeps the index from
+purge: `outcome.md -> INDEX terminal -> the terminal savepoint line -> commit -> disarm
+(Worktree.release -> Lock.release -> purge) -> QMD reindex`. Running the reindex last keeps the index from
 ever referencing a bridge or lock that disarm is about to remove.
 
 `scripts/end-intent` performs this order's disarm step (verify the code worktree is clean,

package/skills/conventions/references/knowledge-graph.md

@@ -45,3 +45,12 @@ This chapter holds the linking doctrine from Frontmatter and the branch-vs-root
   the relation on the PREDECESSOR's `chain` (and mirror it as a
   `[[id--slug|<target's full intent: text>]]` wikilink in `## Links`).
 - **Rule of thumb:** if the intent could exist without its parent, it's a root.
+
+## Naming
+
+A thing is named after the concept family it lives under. A node is a graph-engineering
+concept, so its name comes from graph engineering (node, edge, ready set, critical path),
+from the Plastic concepts coined on top of it (intent, ledger, packet, lease, gate, runner),
+and from the software and AI engineering concepts those rest on (review, fix, test, verify,
+dispatch, executor, reviewer). A name from outside that stack is refused. Where no existing
+concept fits, that is a design finding to raise, not a word to coin.

package/skills/conventions/references/locks-and-worktrees.md

@@ -84,13 +84,13 @@ Provisioning fails open for intents that touch no project code (pure research or
 intents in the global store, or a non-git repo): those get the lock only, and the worktree
 block stays unprovisioned. The fail-open path is always logged, never silent.
 
-Cleanup is part of Done: the End tail merges the branch, then removes the worktree. Never leave
+Cleanup is part of the End tail: it merges the branch, then removes the worktree. Never leave
 an orphaned worktree behind, and clear a stale worktree reference with `git worktree prune`.
 
 
 #### Intent delivery, station by station
 
-How one auto-team intent travels from boarding to Done, and what the lock, the pointer, and
+How one auto-team intent travels from boarding to the End tail, and what the lock, the pointer, and
 the record hook do at each station. Nothing in the third column blocks; the fourth column is
 what gets written down.
 
@@ -101,7 +101,7 @@ what gets written down.
 | Why | `spec.md` | owner writes refresh the lease (lock file mtime heartbeat) | savepoint `Why started`, `Why spec.md created` |
 | How | `plan.md`, `actions/ACTION_N.md` (at least one), `checklist.md` | heartbeat on writes | savepoint `How started`, `How plan.md created`, `How checklist.md created`, `Exec started` |
 | Exec | code on the intent branch, checklist checked off | heartbeat; code edits confined to the provisioned worktree; delegates write under the owner's lock | checklist boxes; savepoint milestones; the day-ledger line promotes when a project file lands |
-| End (done) | mandatory `outcome.md` (`disposition: delivered\|abandoned`), INDEX moves to Completed or Abandoned | ordered End tail: verify, merge and remove worktrees, disarm clears `delivery.lock`, then the pointer is purge-eligible, and the QMD reindex runs LAST (after purge); `end-intent` backfills a placeholder `outcome.md` from the record and its structure check reports (never refuses) | savepoint `Done delivered` (or `abandoned`); takeover audits, if any, remain in savepoint.md |
+| End (done) | mandatory `outcome.md` (`disposition: delivered\|abandoned`), INDEX moves to Completed or Abandoned | ordered End tail: verify, merge and remove worktrees, disarm clears `delivery.lock`, then the pointer is purge-eligible, and the QMD reindex runs LAST (after purge); `end-intent` backfills a placeholder `outcome.md` from the record and its structure check reports (never refuses) | the savepoint's terminal `delivered` (or `abandoned`) line; takeover audits, if any, remain in savepoint.md |
 | Maintenance (Future, Terminal, or Active-with-a-stale-or-no-lock) | `revisions.md` move-and-record entries | detects (never acquires) `delivery.lock`; defers and reports while the target's lock is FRESH (`Lock.fresh?`); a stale or absent lock is not-active, maintenance proceeds | append-only, rule-tagged `revisions.md` entry written in the same operation as the change, or the change is refused; lands via a fresh branch off store main merged back as one closed op, never `git add -A` |
 
 ## The write guard is not residue

package/skills/conventions/references/maintenance-and-revisions.md

@@ -8,7 +8,7 @@ Plastic separates two different things an earlier doctrine blurred under one wor
 "immutable." WORK is the delivered CONTENT an intent produced: the code and project files a
 delivery changed, the research it recorded, the outcome it wrote. Once the intent is terminal
 (Completed or Abandoned), that content is immutable - the only way to change it is another
-intent that continues or reverts it. Editing a Done intent's own artifacts so it looks like it
+intent that continues or reverts it. Editing a terminal intent's own artifacts so it looks like it
 delivered something different, or that parts are missing, is forbidden (the book analogy:
 never rewrite the text on the pages of an old, valuable book).
 

package/skills/doctor/SKILL.md

@@ -223,7 +223,7 @@ knowingly-exempt `(intent_id, rule)` pairs. Format: one `rule_name id id id` lin
 blank lines and `#` comments ignored. v1 honors exactly one rule, `savepoint_operational`.
 
 **Reading the count.** When any exclusion applies, the `savepoint_operational` check's message
-folds in the count and the file's path, e.g. `"... (3 excluded via ~/.plastic/doctor-exclusions)"`.
+includes the count and the file's path, e.g. `"... (3 excluded via ~/.plastic/doctor-exclusions)"`.
 A malformed line in the file forces the check to `warn` with the parse error in `details`, even
 when zero real gaps remain, so a broken file is never silently permissive.
 
@@ -262,7 +262,7 @@ Locks exist for auto teams: a `delivery.lock` file in the intent directory names
 session, and the `record` hook refreshes its mtime on every edit (the lease heartbeat; stale
 means older than the TTL). Direct work takes no lock. When a lock reads held by a session
 that is gone, when work resumes after a crash, reboot, or `/tmp` wipe, or when the user says
-"fix the lock", "who holds the lock", or "reclaim the lock", use the CLI (intent 304 folded
+"fix the lock", "who holds the lock", or "reclaim the lock", use the CLI (intent 304 merged
 the former locking skill here):
 
 | Verb | What it does | When |
@@ -290,7 +290,7 @@ these verbs (claims, worktrees, the station ledger).
 ## Provisioning a project store
 
 When a project is registered in `~/.plastic/projects.yml` but has no store on disk (doctor
-reports `project_store_dir`), provision it (intent 304 folded the former provisioning skill
+reports `project_store_dir`), provision it (intent 304 merged the former provisioning skill
 here). The slug is the project's key under `projects`; an unregistered slug exits non-zero and
 creates nothing, and this procedure never edits `projects.yml`.
 

package/skills/doctor/report.md

@@ -18,7 +18,7 @@
        core_files         -> "Core Files"
        project_stores     -> "Project Stores"
        deprecations       -> "Deprecations"
-       done_signals       -> "Done Signals"
+       done_signals       -> "Completion Signals"
        session_ledger     -> "Session Ledger" (global store only)
   4. For each check within a category, emit one line with the status icon
      and the check message. If the check has non-empty details, list them

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

@@ -12,7 +12,7 @@ Classify from the last line alone, then verify only that line's artifact is real
 | `How  started` / `How  plan.md created` | (How in progress) | **How** | finish `plan.md` and `checklist.md` |
 | `How  checklist.md created` / `Exec  started` | How | **Exec** | do the work, check off the checklist |
 | `Exec  outcome.md created` | Exec | **ready to complete** | the ending procedure (`plastic-intent-ending`) |
-| `Done  delivered` / `Done  abandoned` | terminal | **report only** | immutable; ask what is next |
+| A terminal savepoint line (`delivered` or `abandoned`) | terminal | **report only** | immutable; ask what is next |
 | A node or `Intent` transition line (`n1  running ...`, `Intent  needs_decision ...`) | Exec | **Exec** | a graph delivery is in progress; read node status through `NodeLedger.status`, never re-derive it by eye |
 
 ## Per-stage behaviour (what "continue" means)
@@ -24,7 +24,7 @@ Classify from the last line alone, then verify only that line's artifact is real
   The first unchecked `checklist.md` item is the next step; the newest `## Insights` entry
   supplies the context.
 - **ready to complete**: `outcome.md` is real; run the ending procedure.
-- **Done**: terminal. Report the outcome, ask what is next. Never reopen; `INDEX.md` is
+- **End**: terminal. Report the outcome, ask what is next. Never reopen; `INDEX.md` is
   authoritative.
 
 ## Notes

package/skills/intent-creating/SKILL.md

@@ -6,110 +6,51 @@ user-invocable: true
 
 # Creating an Intent
 
-## When to Use
+Creating writes the thought to disk: an id, a directory, a born-complete intent file.
+Nothing else runs here; specifying, planning, and execution are separate, later skills.
+
+## When to use
 - User starts new work ("build X", "fix Y", "research Z")
 - No active intent matches the current task
 - User explicitly says "new intent" or "create intent"
 - An agent discovers work needed during implementation
 
-## Determine the store
-
-**Global intent** (strategic): created when working outside a registered project, or when the user expresses a high-level goal. Stored in `~/.plastic/store/`.
-
-**Project intent** (tactical): created when working inside a registered project directory. Stored in `~/.plastic/projects/{slug}/store/`. Automatically linked to the project's governing intent.
-
-### Detection logic:
-1. Read `~/.plastic/projects.yml`
-2. **CWD match:** Match CWD against registered project paths
-   - If CWD is inside a registered project → **project intent (tactical)**
-3. **Explicit mention:** User mentions an existing project by name ("add this to reddit-kb", "new intent for plastic")
-   - Look up project in `projects.yml` by slug
-   - If found → **project intent (tactical)** in that project's store at `~/.plastic/projects/{slug}/store/`
-   - Agent changes working directory to the project path for execution
-4. **No match:** CWD is not in a project AND no project mentioned
-   - → **global intent (strategic)** in `~/.plastic/store/`
-
-When creating a tactical intent in a project store:
-- Read the project's `AGENTS.md` for project context and decisions
-- Link back to the project's governing intent (from `projects.yml` `parent` field) via `sources` (the project genuinely is formed from its founding intent, a true formative edge, reciprocated on the founding intent's `chain`)
-- Add `[[global:<parent_ID>]]` backlink in `## Links`
-- The intent's Folgezettel ID is scoped to the project store (run `folgezettel-id` against the project's store at `~/.plastic/projects/{slug}/store/`)
-
-## Workflow
+## Decide the store and the shape, before scaffolding
+
+- **CWD inside a registered project** (`~/.plastic/projects.yml`), or the user names a
+  project by slug -> **project intent (tactical)**, `~/.plastic/projects/{slug}/store/`,
+  linked back to the project's governing intent (`projects.yml` `parent` field) via
+  `sources`, with `[[global:<parent_ID>]]` in `## Links` and a Folgezettel id scoped to
+  that store.
+- **No match** -> **global intent (strategic)**, `~/.plastic/store/`.
+- **Duplicate or predecessor check (QMD-first):** before allocating an id, run
+  `ruby ~/.plastic/scripts/qmd-sync search "<terms>"` (a no-op when QMD is absent, fall
+  back to INDEX.md) so a near-duplicate is reused and a true predecessor lands in
+  `--sources`.
+- **Branch vs root**, decided by meaning, not by "a parent in mind": branch
+  (`--parent <parent_id>`) when the intent only makes sense as part of the parent's work;
+  root with `--sources <ascendant_id>` when it was created from another intent's
+  lifecycle; root with no `--sources` when it is merely related (record that relation on
+  the PREDECESSOR's `chain` instead - topic similarity alone is never a `sources` edge).
 
-### 1. Determine Store Location
-
-- **Global:** `~/.plastic/store/`
-- **Project:** `~/.plastic/projects/{slug}/store/`
-
-### 2. Check for a Duplicate or Predecessor (QMD-first)
-
-QMD-first (when available): before scanning the store with grep/Read, run
-`ruby ~/.plastic/scripts/qmd-sync search "<terms>"` to surface candidate, prior, or duplicate
-intents, then open the authoritative intent file for any hit you act on. The command is a no-op
-when QMD is absent, so fall back to the existing INDEX.md / file scan. Do this before allocating
-the id so a near-duplicate can be reused and a true predecessor can be set in `--sources`.
-
-### 3. Decide Branch vs Root
+When a branch intent exists because a late ruling arrived AFTER its parent was already
+completed, the parent is restored to v1 via `scripts/restore-intent-v1`, never a hand-run
+`git checkout`/revert (see `plastic-conventions > references/maintenance-and-revisions.md`,
+WORK vs MAINTENANCE).
 
-Decide this BEFORE scaffolding, because it sets whether you pass `--parent`.
-Having a "parent" in mind does NOT automatically mean branch. Choose by meaning:
+`## Links` is a DERIVED view of `sources`/`chain`: never hand-write a `## Links` line, add
+the frontmatter edge and reproject. Links follow context influence (a `chain` edge needs
+the candidate's context to materially help deliver this intent), never shared files or a
+similarity score; `scripts/link-suggest` and `scripts/project-links` gather candidates.
+Read `../plastic-conventions/references/knowledge-graph.md` for the full linking doctrine:
+the tiers of influence, sources versus chain, and how `## Links` is derived.
 
-- **Branch (`14a`, `14b`)**: a sub-task, refinement, or direct continuation. It only
-  makes sense as part of the parent's work. Pass `--parent <parent_id>`.
-- **Root (`15`, `16`)**: an independent thought. Two cases, decided by ORIGIN:
-  - **Created from another intent** (it emerged from that intent's lifecycle): make it a
-    root and set `--sources <ascendant_id>`. `sources` is reserved for true created-from /
-    direct-ascendant provenance (D1).
-  - **Merely related to / inspired by another intent** (it did NOT come out of that
-    intent's lifecycle): carry NO `--sources`. Record the relation on the PREDECESSOR's
-    `chain` instead (the related-but-not-spawned rule); the `## Links` section follows
-    from that edge, you do not write it by hand.
-- **Rule of thumb:** if the intent could exist without its parent, make it a root; only set
-  `--sources` when it was genuinely created from / emerged from that intent's lifecycle.
-  Topic similarity alone is not a `sources` edge.
+## Scaffold
 
-When a branch intent exists because a late ruling arrived AFTER its parent was already
-completed (the owner's late-ruling rule), the parent is restored to v1 via
-`scripts/restore-intent-v1`, never by a hand-run `git checkout`/revert. See
-`plastic-conventions > references/maintenance-and-revisions.md`, WORK vs MAINTENANCE, for the
-rule and the tool.
-
-`## Links` is a DERIVED view of `sources`/`chain`. Never hand-write a `## Links` line; add the
-frontmatter edge and reproject. Links are decided by context influence (a `chain` edge has a high
-bar: the candidate's context must materially help deliver this intent), not by shared files or a
-similarity score. To gather candidates with their context and record an edge, use the
-`scripts/link-suggest` and `scripts/project-links`.
-
-Read `../plastic-conventions/references/knowledge-graph.md` for the full linking doctrine: the
-tiers of influence, sources versus chain, and how the `## Links` projection is derived. This path
-resolves relative to this skill's own installed directory.
-
-### 4. Determine Intent Properties
-
-Ask or infer from context:
-- **intent**: one-line description
-- **slug**: short hyphenated handle for the directory name
-- **author**: `human` | `claude-code` | other agent name
-- **sources**: the direct ascendant(s) this intent was created from / emerged from the
-  lifecycle of (formation, not topic similarity), e.g., `4a1`. For a project intent,
-  include the governing intent's id. A branch's structural parent is ALSO recorded in
-  `sources` (the ID carries it for the human/paper tree, `sources` carries it for
-  software), which `new-intent` does automatically (see `new-intent:126`).
-- **tags**: freeform list (use `project-<name>` for project membership)
-
-`chain` carries what this intent spawns AND related-but-not-spawned successors it leads to;
-it starts empty and is populated later. See
-[`how-plastic-sources-and-chains-intents.md`](https://github.com/zalom/plastic/blob/main/docs/concepts/how-plastic-sources-and-chains-intents.md) for the full model.
-Place the intent in `## Active` or `## Future` in INDEX.md (status is
-convention-derived, not a frontmatter field).
-
-### 5. Scaffold via new-intent (single call)
-
-Delegate id allocation, directory and file creation, the born-complete intent
-file, the sentinel placeholder lifecycle files, the reciprocal file links, and
-self-validation to one `new-intent` invocation. Do NOT hand-author any of these
-files.
+One call does the rest: id allocation, the directory, `actions/` and `resources/`, the
+born-complete intent file, sentinel placeholder lifecycle files (each marked
+`<!-- plastic:placeholder -->` so no stage detector reads them as reached), reciprocal
+`[[id]]` links, and self-validation. Do NOT hand-author any of these files.
 
 ```bash
 ruby ~/.plastic/scripts/new-intent \
@@ -118,47 +59,31 @@ ruby ~/.plastic/scripts/new-intent \
   [--sources "id,id"] [--tags "project-<slug>,tag"]
 ```
 
-`new-intent` allocates the Folgezettel id (root, or a branch of `--parent`),
-creates `<STORE>/<id>--<slug>/` plus `actions/` and `resources/`, renders the
-born-complete `<id>--<slug>.md` from the intent template, writes the sentinel
-placeholder `spec.md`/`plan.md`/`checklist.md`/`outcome.md` (each marked
-`<!-- plastic:placeholder -->` so no stage detector reads them as reached), wires
-the reciprocal `[[id]]` links, and self-validates (frontmatter plus the sanctioned
-`##` sections). It prints the created directory path and exits 0.
-
-It does NOT touch INDEX.md, git, or project creation: those stay in this skill
-(steps 6 to 9 below).
-
-If `new-intent` exits non-zero, read the stderr report and fix the inputs (slug,
-intent, sources). Do not commit or announce an intent that did not scaffold
-cleanly, and do not work around the failure by hand-writing the files.
-
-### 6. If Implementation Intent Spawns a Project
-
-When the user says "start building" or the plan calls for a new project, invoke the
-`plastic-project-creating` skill; it owns project directory creation, AGENTS.md
-population, projects.yml registration, store provisioning, and the auto-commit of
-both stores. Add `project-<slug>` to this intent's `tags` array either before
-invoking it or as part of that skill's handoff.
-
-### 7. Update INDEX.md
+It does NOT touch INDEX.md, git, or project creation (Finish, below). If it exits
+non-zero, read the stderr report, fix the inputs (slug, intent, sources), and retry;
+never work around a failed scaffold by hand-writing the files.
 
-- **Global intents:** update `~/.plastic/INDEX.md`
-- **Project intents:** no global INDEX.md change (tactical intents are project-scoped)
-
-Add to `## Active` (or `## Future`) and appropriate cluster.
-
-### 8. Auto-commit
-
-```bash
-cd <store-root> && git add . && git commit -m "feat: create intent ID - [name]"
-```
+`chain` carries what this intent spawns AND related-but-not-spawned successors it leads
+to; it starts empty and is populated later. See
+[`how-plastic-sources-and-chains-intents.md`](https://github.com/zalom/plastic/blob/main/docs/concepts/how-plastic-sources-and-chains-intents.md)
+for the full model.
 
-### 9. Announce
+## Finish
 
-"Created intent ID - [name]. Placed in: [Active|Future]. Store: [global|project:<slug>|local]."
+1. **Global intent:** add a line to `~/.plastic/INDEX.md` under `## Active` (or
+   `## Future`) and the right cluster. **Project intent:** no global INDEX.md change.
+2. When the user says "start building" or the plan calls for a new project, invoke
+   `plastic-project-creating`; it owns project directory creation, AGENTS.md population,
+   `projects.yml` registration, store provisioning, and the auto-commit of both stores.
+   Add `project-<slug>` to this intent's `tags` either before invoking it or as part of
+   that skill's handoff.
+3. Commit: `cd <store-root> && git add . && git commit -m "feat: create intent ID - [name]"`.
+4. Announce: "Created intent ID - [name]. Placed in: [Active|Future]. Store:
+   [global|project:<slug>]."
 
 ## References
 
-- Read `references/lifecycle.md` for the full What→Why→How→Exec stage detail, filesystem-as-schema conventions, and creating-intent step-by-step
-- Read `references/wikilinks.md` for the wikilink syntax table when adding `## Links` to intents
+- Read `references/lifecycle.md` for the full What->Why->How->Exec stage detail and the
+  filesystem-as-schema conventions.
+- Read `references/wikilinks.md` for the wikilink syntax table when hand-checking a
+  `## Links` projection.

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

@@ -35,7 +35,7 @@
       "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 folds 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.",
+      "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": [
         {

package/skills/intent-ending/SKILL.md

@@ -1,9 +1,11 @@
 ---
 name: plastic-intent-ending
 description: >
-  Wrap, finish, close, or mark an intent Done, delivered or abandoned. Use
-  when completing or abandoning an intent, when a checklist reaches 100
-  percent and Exec is finished, or when asked to "wrap this up".
+  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
 ---
 
@@ -26,7 +28,7 @@ installed directory.
 | 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 | savepoint `Done` bookend | `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 |
@@ -45,50 +47,47 @@ 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. 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 that lands verbatim in the backfilled `## Follow-ups`.
-2. Confirm every acceptance criterion in spec.md is verifiable (tests pass,
-   or the manual check described in its HOW line was actually run).
-3. Decide what you have to say. For an intent with a `graph.md`, `outcome.md` is
-   GENERATED by `scripts/end-intent` itself, 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, never hand-typed. `## 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, so
-   writing a summary yourself still works exactly as before. For an intent with
-   no `graph.md`, or when the generated text would be refused by the close's own
-   gates, 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
-   diff on the intent's own worktree). A file you wrote, even under a
-   still-present sentinel, is never touched.
+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`
 
-Author outcome.md yourself when the summary deserves more prose than the generator's
-plain facts: copy `templates/outcome.md`, set the frontmatter to `disposition: delivered`
-or `disposition: abandoned`, and fill `## Summary`, `## Delivered`, `## Verification`,
-`## Follow-ups`. `## Delivered` is a `| Row | What |` table: one row per thing delivered,
-in plain wording a reader recognizes, not a method name or an implementation summary
-(that detail belongs in `## Summary`). Each row's label must appear as a standalone token
-in an action-file heading (or a node-file heading, for an intent whose graph replaces
-actions/ with nodes/) that owns the matrix table (`### S1 - ...` or
-`## n1 failure-mode matrix` with a table beneath it proves that row; a table-less
-heading naming the label is skipped); that heading's matrix rows become the row's
-Proven-by cell on `report-screen delivered`'s post-delivery screen. `## 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 a `graph.md` and no
-hand-written outcome.md gets one generated instead (Step 0.3 above); a placeholder
-outcome.md on an intent with no `graph.md` is backfilled from the record, 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.
+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:
 
@@ -110,23 +109,16 @@ 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 savepoint `Done` bookend, commits the store repo, and
+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.
 
-A pre-flight lock guard runs before anything is written: it resolves the
-calling session (`--session`, else `CLAUDE_CODE_SESSION_ID`, else the
-existing lock's own recorded owner, else a no-op) and checks it against any
-existing `delivery.lock`. A live foreign session refuses the whole run
-(exit 4, nothing written); a stale foreign lock is reclaimed automatically
-(audited to savepoint.md) and the run proceeds as the new owner. Before
-removing the worktree, step 5 also refuses on an unexpectedly dirty code
-worktree (exit 5, naming the worktree path) rather than force-discarding
-uncommitted changes; pass `--discard-worktree-changes` only when you mean
-to override that deliberately.
+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

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

@@ -19,7 +19,7 @@
       "scope": "behavior",
       "set": "train",
       "prompt": "Run the mechanical close (scripts/end-intent) for a delivered intent with a real outcome.md.",
-      "expected_output": "The savepoint Done bookend 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).",
+      "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" },