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

package/scripts/insight-append

@@ -11,8 +11,16 @@
 # `now:` seam is the test seam; the CLI uses the default Time.now, which is fine
 # because determinism is covered at the library level (test/insights_test.rb).
 #
+# --rule (intent 341, G8, C37): tags the entry as a rule, not just an
+# observation, by prepending the literal "rule: " onto the text before it
+# ever reaches Insights.append_insight; the library itself stays untouched,
+# since a tag is a text-level convention, not a new field on the ledger.
+# Doctor's unpromoted_rules check (scripts/doctor.rb) later lists any tagged
+# entry whose exact text no skills/conventions/references/*.md chapter
+# carries yet.
+#
 # Usage:
-#   insight-append <intent_dir> <text> --stage S --author A
+#   insight-append <intent_dir> <text> --stage S --author A [--rule]
 #
 # Exit codes: 0 (entry appended), 2 (usage).
 
@@ -21,6 +29,7 @@ require_relative "lib/insights"
 def parse_args(argv)
   stage = nil
   author = nil
+  rule = false
   positional = []
   i = 0
   while i < argv.length
@@ -31,21 +40,26 @@ def parse_args(argv)
     when "--author"
       author = argv[i + 1]
       i += 2
+    when "--rule"
+      rule = true
+      i += 1
     else
       positional << argv[i]
       i += 1
     end
   end
-  [positional[0], positional[1], stage, author]
+  [positional[0], positional[1], stage, author, rule]
 end
 
-intent_dir, text, stage, author = parse_args(ARGV)
+intent_dir, text, stage, author, rule = parse_args(ARGV)
 
 if [intent_dir, text, stage, author].any? { |v| v.nil? || v.to_s.empty? }
-  warn "usage: insight-append <intent_dir> <text> --stage S --author A"
+  warn "usage: insight-append <intent_dir> <text> --stage S --author A [--rule]"
   exit 2
 end
 
+text = "rule: #{text}" if rule
+
 entry = Insights.append_insight(File.expand_path(intent_dir), text,
                                 stage: stage, author: author)
 puts "appended: #{entry}"

package/scripts/lib/installer_core.rb

@@ -49,9 +49,9 @@ class InstallerCore
   # hand-curated pointer rather than embedding the core wholesale, and it never drifts
   # because it only ever points, never duplicates.
   CODEX_AGENTS_MD_BODY = <<~MD.freeze
-    Plastic is installed for this agent. Plastic is intent-driven state management: all
-    work flows through an intent, moved through What, Why, How, then Exec. Do not jump
-    straight to code.
+    Plastic is installed for this agent. Plastic is intent-driven state management: work runs
+    in one of three modes, direct, thinking, or auto (a team drives the runner loop:
+    `runner step`, `status`, `answer`). Do not jump straight to code.
 
     Standing rules:
     - Core conventions live in ~/.plastic/PLASTIC.md. Read it and follow it exactly. For

package/scripts/skill-lint

@@ -2,11 +2,13 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-# skill-lint: deterministic CLI over SkillLint (intent 85b).
+# skill-lint: deterministic CLI over SkillLint (intent 85b), plus one CLI-local
+# check (intent 341, G8, n1, C35).
 #
-# Runs the five structural skill checks (body-budget, frontmatter-validity,
-# bare-pointer, orphan-files, references-depth) over a directory of Agent
-# Skills and reports every violation. Mirrors `scripts/validate-intent`'s
+# Runs the five structural checks (body-budget, frontmatter-validity,
+# bare-pointer, orphan-files, references-depth) via SkillLint, then this
+# script's own refusal-restatement check, over a directory of Agent Skills,
+# and reports every violation. Mirrors `scripts/validate-intent`'s
 # CLI-over-lib shape and exit-code contract.
 #
 # Usage:
@@ -17,6 +19,112 @@
 
 require_relative "lib/skill_lint"
 
+# RefusalRestatementCheck (C35): a skill body must not restate, past a short
+# run of words, a refusal rule the conventions chapter already carries; it
+# must link that chapter instead. No-op when <skills_dir>/conventions/references
+# does not exist, so an older tree or a fixture dir with no conventions chapter
+# is unaffected.
+#
+# Deliberately lives in this CLI, not in scripts/lib/skill_lint.rb: C35 is a
+# doctrine-duplication check, one level removed from SkillLint's five
+# structural checks, and keeping it here means adding it touches only the
+# files this change is scoped to.
+class RefusalRestatementCheck
+  REFUSAL_KEYWORD_RE = /\brefus(e|es|ed|ing|al)\b/i
+  CONVENTIONS_LINK_RE = %r{conventions/references/|plastic-conventions}i
+
+  # How many consecutive normalized words must match, verbatim, between a
+  # skill's refusal paragraph and the doctrine text before it counts as a
+  # restatement rather than a coincidental shared phrase.
+  NGRAM = 6
+
+  def initialize(skills_dir)
+    @skills_dir = skills_dir
+  end
+
+  def run
+    doctrine = doctrine_blob
+    return [] unless doctrine
+
+    skill_md_paths.flat_map do |skill_md|
+      skill_dir = File.dirname(skill_md)
+      next [] if File.basename(skill_dir) == "conventions" # the source never restates itself
+
+      check_skill(skill_dir, skill_md, File.read(skill_md), doctrine)
+    end
+  end
+
+  private
+
+  def skill_md_paths
+    Dir.glob(File.join(@skills_dir, "*", "SKILL.md")).sort
+  end
+
+  def doctrine_blob
+    chapters = Dir.glob(File.join(@skills_dir, "conventions", "references", "*.md")).sort
+    return nil if chapters.empty?
+
+    text = chapters.map { |f| File.read(f) }.join(" ")
+    " #{normalize_words(text).join(" ")} "
+  end
+
+  def normalize_words(text)
+    text.downcase.gsub("`", "").gsub(/[^a-z0-9\s-]/, " ").split(/\s+/).reject(&:empty?)
+  end
+
+  # Same split as SkillLint's own frontmatter/body divide: `content.split("---", 3)`.
+  def body_and_offset(content)
+    parts = content.split("---", 3)
+    return [content, 0] if parts.length < 3
+
+    prefix_len = parts[0].length + 3 + parts[1].length + 3
+    [parts[2], content[0...prefix_len].count("\n")]
+  end
+
+  # Blank-line-delimited paragraph blocks, so a refusal keyword and its
+  # doctrine echo are compared across the whole paragraph, not one line.
+  def paragraph_blocks(lines)
+    blocks = []
+    start = nil
+    lines.each_with_index do |line, i|
+      if line.strip.empty?
+        blocks << { start: start, text: lines[start..(i - 1)].join } if start
+        start = nil
+      else
+        start ||= i
+      end
+    end
+    blocks << { start: start, text: lines[start..].join } if start
+    blocks
+  end
+
+  def restated?(block_text, doctrine)
+    words = normalize_words(block_text)
+    return false if words.length < NGRAM
+
+    (0..(words.length - NGRAM)).any? do |i|
+      doctrine.include?(" #{words[i, NGRAM].join(" ")} ")
+    end
+  end
+
+  def check_skill(skill_dir, skill_md, content, doctrine)
+    name = File.basename(skill_dir)
+    body, offset = body_and_offset(content)
+
+    paragraph_blocks(body.lines).filter_map do |block|
+      next unless block[:text].match?(REFUSAL_KEYWORD_RE)
+      next if block[:text].match?(CONVENTIONS_LINK_RE) # links the chapter instead of restating
+      next unless restated?(block[:text], doctrine)
+
+      {
+        check: "refusal-restatement", skill: name, file: skill_md, line: offset + block[:start] + 1,
+        message: "this paragraph restates a refusal rule word-for-word from " \
+                  "skills/conventions/references/; link the chapter instead of repeating its text",
+      }
+    end
+  end
+end
+
 def resolve_skills_dir(args)
   if (i = args.index("--skills-dir"))
     args[i + 1]
@@ -37,14 +145,15 @@ end
 
 dir = File.expand_path(resolve_skills_dir(ARGV))
 result = SkillLint.new(skills_dir: dir).run
+violations = result.violations + RefusalRestatementCheck.new(dir).run
 
-if result.ok?
+if violations.empty?
   puts "OK: #{dir}"
   exit 0
 end
 
 warn "VIOLATIONS: #{dir}"
-result.violations.each do |v|
+violations.each do |v|
   warn "#{v[:check]} #{v[:skill]} #{v[:file]}:#{v[:line].nil? ? "-" : v[:line]} #{v[:message]}"
 end
 exit 1

package/skills/auto/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: plastic-auto
 description: >-
-  Autonomous intent delivery - a background team takes a registered intent from How to Done.
+  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.
@@ -71,35 +71,29 @@ 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 (five steps, two agent boots)
+## The shape
 
-Every auto delivery runs the same shape, ruled by the owner on 2026-08-29. There is no intent
-tier and no stage agent; depth follows the work.
+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.
 
-| Step | Who | What lands |
-|---|---|---|
-| 1. The lead writes How | this session | `plan.md`, at least one `actions/ACTION_N.md` carrying a failure-mode matrix (one row per operation: the failure and the test that catches it), `checklist.md` |
-| 2. Adversarial plan review | boot 1, a fresh agent on `plan-reviewer-prompt.md` | a review file; the lead folds every finding into the spec, the matrix, and the tests |
-| 3. Execute, tests first | boot 2, `plastic-executor` | the red commit (the matrix's tests, failing), then the code, then a green suite |
-| 4. Review by risk | boot 3 only when risk calls for it (below) | a pass or a list of fixes the executor applies |
-| 5. One suite run, then close | this session | `outcome.md`, `end-intent`, the roadmap ledger |
+`runner step` computes readiness and prints a spawn block per dispatched node - agent, model,
+packet 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.
 
-Two boots is the normal delivery; the third is the exception the risk rule names. The lead is
-this session (the `plastic-enforcer` role), never a dispatched agent.
-
-A lead is a choice, not a requirement (D8, 355). `runner step` computes the plan and prints a
-spawn block per node - agent, model, packet path, the test command, the call cap - fenced for a
-session to paste into the Agent tool; the runner never spawns (327 D42). 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.
+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, folds reviews,
-  verifies, closes.
+- **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**: one dispatch before code, from `plastic-intent-executing`'s
+- **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.
@@ -154,7 +148,9 @@ 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 five steps itself, still writing the matrix and the tests first and reviewing its own plan against the matrix before code, saying so in `## Insights`.
+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
 
@@ -168,7 +164,7 @@ ledger is missing (then rebuild it with `Savepoint.rebuild_savepoint`).
 | `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 |
-| `Done  delivered|abandoned` | Terminal; do not resume |
+| 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 |
 
 Filesystem fallback, in order: `checklist.md` with items checked means resume Exec from the
@@ -179,42 +175,43 @@ Announce which stage you are entering and why.
 
 ## Why (the lead)
 
-1. Read `## Context` and `### Decisions`; assess the gaps.
-2. Research yourself: code, docs, related intents through `## Links`, the web if needed. No
-   questions to the human.
-3. Decide: pick the best option per gap, record it in `## Context > ### Decisions` with the
-   rationale, and log it in `## Insights` with the `(autonomous)` marker through
-   `scripts/insight-append`.
-4. Write `spec.md`. Then How.
+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
 
-1. Write `plan.md`: numbered steps.
-2. Write at least one real `actions/ACTION_N.md` (one consolidated `ACTION_1.md` by default;
-   several only when the work splits into independent, parallel-safe actions). Each action
-   carries the failure-mode matrix: one row per operation, the failure mode, and the test that
-   catches it. A `.gitkeep`-only `actions/` is not a finished How.
-3. Write `checklist.md` covering every action.
-4. Dispatch the plan reviewer (boot 1) with `plastic-intent-executing`'s
-   `plan-reviewer-prompt.md`, the spawn preamble, and the intent directory. Fold every finding
-   into the spec, the matrix, and the tests; record what was dropped and why in the action
-   file's review fold. A REVISE verdict is folded and not re-reviewed unless a finding changes
-   a decision.
-5. 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.
+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)
 
-1. Dispatch `plastic-executor` (boot 2) through `plastic-intent-executing` with the whole
-   consolidated action pasted in: the spec decisions, the matrix, the checklist items, the
-   worktree path from the preamble. Tests first: the executor commits the matrix's tests red,
-   then builds, then drives the full suite green.
-2. Read its return by code: DONE or DONE_WITH_CONCERNS proceeds; NEEDS_CONTEXT re-dispatches
-   with the missing context; BLOCKED stops under the error procedure.
-3. 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.
+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)
 
@@ -224,13 +221,14 @@ holds, each checkable from disk with no judgment; otherwise the green suite is t
 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 `actions/ACTION_N.md` failure-mode matrix names a test file that is not in that
-   diff, or a test the green run did not execute.
+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.
+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`

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/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/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