@zalom/plastic 1.0.2 → 1.1.0

package/skills/intent-ending/SKILL.md

@@ -0,0 +1,151 @@
+---
+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".
+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.
+
+## The 8 steps (0-7)
+
+| # | Step | Who does it |
+|---|---|---|
+| 0 | Precondition check | You, before touching outcome.md |
+| 1 | outcome.md + 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` |
+| 4 | store auto-commit | `scripts/end-intent` |
+| 5 | disarm (worktree + lock) | You, after end-intent exits 0 |
+| 6 | QMD reindex, async, LAST | You |
+| 7 | EM-to-CTO report | You |
+
+Steps 1-4 are ONE callable script, not four 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). Never restate outcome/INDEX/savepoint prose inline again; call
+`scripts/end-intent`.
+
+### Step 0. Precondition (the gate is section-blind, not selective)
+
+`Bridge.check_gate` (scripts/lib/bridge.rb) is LIVE code already wired into
+the write-time hook. Its outcome.md rule is a blind scan of the WHOLE
+checklist.md: `content.scan(/^- \[ \]/)` counts every unchecked box, in
+every section, with no awareness of which section a box lives in. ANY
+unchecked box anywhere blocks the outcome.md write; there is no exemption
+for orchestrator-owned or completion-tracking items.
+
+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, so tick it at the moment you begin the close,
+   before authoring outcome.md. By the time outcome.md is written,
+   checklist.md must read 100 percent checked; there is no other way past
+   the gate.
+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. If checklist.md still has an unchecked box, stop here. Finish it first
+   (tick it if the described work is actually done, or do the remaining
+   work); do not attempt outcome.md and fight the gate's deny.
+
+### Step 1-4. Run `scripts/end-intent`
+
+First author outcome.md for real (never leave the scaffold placeholder in
+place): copy `templates/outcome.md`, set the frontmatter to
+`disposition: delivered` or `disposition: abandoned`, and fill `## Summary`,
+`## Delivered`, `## Verification`, `## Follow-ups`. On abandon, `## Summary`
+states the abandonment reason and the trail (see Pivot below). Also author
+the rich INDEX entry note now (a short line in the store's existing
+Completed/Abandoned convention: mode/tier, 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 \
+  --outcome-summary "<one-line ## Outcome summary for the intent file>" \
+  --index-note "<rich Completed/Abandoned entry description>"
+```
+
+This does all of steps 1-4 in order: guards outcome.md (refuses a missing,
+still-placeholder, or wrong-disposition file with exit 2 and authors
+nothing), stamps the intent file's `## Outcome` section, moves the INDEX.md
+line from `## Active` to `## Completed` or `## Abandoned` (dated today,
+idempotent) with the `--index-note` text appended after the date so the
+entry stays rich, appends the savepoint `Done` bookend, and commits the
+store repo. Omit `--index-note` for a thin id+date entry, add `--no-commit`
+when a separate commit step already covers the store, and `--dry-run` to
+preview with no writes. Exit 0 is success; exit 1 is a usage or resolution
+failure; exit 2 is the outcome.md guard refusing (fix outcome.md and re-run,
+nothing was written).
+
+### Step 5. Disarm (worktree + lock)
+
+Two branches, decided by how this intent ships:
+
+- **Shipped through a release** (the `plastic-releasing` flow reached this
+  close): merge the code branch back BEFORE removing the worktrees, via
+  `Worktree.finish(bridge_data, merge: true)`. Releasing's own workflow
+  already drives this; this skill's job here is only the outcome/INDEX/
+  savepoint/commit core above.
+- **Auto mode or the curator path** (no release involved): plain remove,
+  branch survives for reclaim.
+  ```bash
+  ruby -r ~/.plastic/scripts/lib/bridge -e \
+    'Bridge.disarm_auto(ENV["CLAUDE_CODE_SESSION_ID"], intent_id: "<ID>")'
+  ```
+  `disarm_auto` releases both worktrees, clears the `delivery.lock`, and only
+  then makes the bridge purge-eligible, in that order. Never leave an
+  orphaned worktree; run `git worktree prune` on a stale reference.
+
+### 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. EM-to-CTO report
+
+Brief the human like an engineering manager to a CTO: impact and risk first,
+in plain language, the decision left to them (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`, the curator agent, `store-curating`, and
+`store-indexing` all delegate their mechanical close to this skill (or call
+`scripts/end-intent` directly for steps 1-4). None of them restate the
+outcome/INDEX/savepoint 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

@@ -0,0 +1,74 @@
+{
+  "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": "Defers to the existing Bridge.check_gate hard gate rather than writing outcome.md; tells the user to finish the checklist item first instead of fighting the deny.",
+      "files": [],
+      "assertions": [
+        { "type": "human", "check": "SKILL.md Step 0 states the gate blocks outcome.md while unchecked non-completion items remain, and instructs finishing the checklist rather than attempting the write", "result": "expect-pass" },
+        { "type": "code", "check": "Bridge.check_gate(intent_dir, 'outcome.md') returns a non-nil block reason when checklist.md has an unchecked '- [ ]' item (scripts/lib/bridge.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 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).",
+      "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 boarding request (plastic-intent-starting), 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/{executing-plan → intent-executing}/SKILL.md

@@ -1,6 +1,7 @@
 ---
-name: plastic-executing-plan
+name: plastic-intent-executing
 description: Use when you have a written implementation plan to execute. Default mode is subagent-driven (dispatches fresh subagent per task with two-stage review). Fallback mode is inline execution for environments without subagent support. If superpowers:subagent-driven-development or superpowers:executing-plans are available, delegates to them.
+user-invocable: true
 ---
 
 # Executing a Plan
@@ -11,20 +12,33 @@ Load plan from the active intent's `plan.md`, execute all tasks, review between
 
 **Announce at start:** "I'm using the executing-plan skill to implement this plan."
 
+## Step 0: Sync Worktree First
+
+Before Step 1 (Load Plan) in either workflow below, sync the code worktree with
+main first, 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
+```
+
+After syncing, verify the plan's target files exist at the paths plan.md names.
+If a named file or directory is missing (renamed or removed upstream), stop and
+report it rather than editing a stale path.
+
 ## Mode Selection
 
 ### Check for superpowers first
 If `superpowers:subagent-driven-development` is available as a skill, delegate to it. If only `superpowers:executing-plans` is available, delegate to that. If neither is available, use Plastic's own execution engine below.
 
-**CRITICAL — when delegating to superpowers:**
+**CRITICAL: when delegating to superpowers:**
 - Tell the skill that the plan is at `~/.plastic/store/ID--slug/plan.md` (not `docs/superpowers/plans/`)
 - Tell the skill that specs live at `~/.plastic/store/ID--slug/spec.md` (not `docs/superpowers/specs/`)
 - All meta-artifacts must stay inside `~/.plastic/store/ID--slug/`
 - Code files go in the project tree as normal
-- Superpowers skills respect "user preferences for plan/spec location" — Plastic IS that preference
+- Superpowers skills respect "user preferences for plan/spec location"; Plastic IS that preference
 
 ### Subagent-Driven (Default)
-Dispatches a fresh subagent per task. Controller never implements — only dispatches, reviews, and tracks progress. Two-stage review after each task: spec compliance first, then code quality.
+Dispatches a fresh subagent per task. Controller never implements, only dispatches, reviews, and tracks progress. Two-stage review after each task: spec compliance first, then code quality.
 
 ### Inline (Fallback)
 Executes tasks sequentially in the current session. Use when subagents aren't available or user explicitly requests inline mode.
@@ -34,13 +48,14 @@ To select: user says "inline", "execute inline", or "no subagents".
 ## Subagent-Driven Workflow
 
 ### Step 1: Load Plan
+Run Step 0 (Sync Worktree First) before this step.
 1. Read the active intent's `plan.md`
-2. Extract ALL tasks with their full text — store in memory. Never make subagents read the plan file.
+2. Extract ALL tasks with their full text, store in memory. Never make subagents read the plan file.
 3. Create a task list to track progress
 
 ### Step 2: Execute Each Task
 
-For each task sequentially (never parallel — conflict risk):
+For each task sequentially (never parallel: conflict risk):
 
 **a. Dispatch implementer subagent**
 Use the Agent tool with the implementer prompt template. Include:
@@ -62,7 +77,8 @@ Use the Agent tool with spec-reviewer prompt. The reviewer reads actual code and
 Only after spec compliance passes. Reviews clean code, testing, architecture. Pass/fail.
 - If fail: implementer fixes, quality reviewer re-reviews (loop until pass)
 
-**e. Mark task complete**, move to next
+**e. Tick as it lands, then move to next**
+Follow `## Tick-as-you-land` below: move the task's checklist item to `## Completed` and add a `## Session Log` row in the same edit.
 
 ### Step 3: Final Review
 After all tasks complete, dispatch a final reviewer for the entire implementation.
@@ -74,16 +90,17 @@ Capture observations in `## Insights`. When ALL checklist items are checked:
 2. Write `## Outcome` summary in the intent file (1-2 sentences)
 3. Move intent from `## Active` to `## Completed` in INDEX.md (with today's date)
 4. Update cluster entries to show `_(completed)_`
-5. Auto-commit: `cd <store-root> && git add . && git commit -m "feat: complete intent <ID> — <name>"`
+5. Auto-commit: `cd <store-root> && git add . && git commit -m "feat: complete intent <ID>: <name>"`
 6. QMD reindex LAST (canonical End tail). As the final End-tail step, after the terminal move and any disarm, ALWAYS refresh the QMD search index for this store (no-op when QMD is absent), running in the background so it never blocks the turn: `ruby ~/.plastic/scripts/qmd-sync reindex --store <store-root> --async`. Completion is the lifecycle event that keeps the search index fresh, and the reindex runs last so the index never references a bridge or lock that is about to disappear (see PLASTIC.md `## Delivery Isolation and the Single-Owner Lock`).
 
-**This is NOT optional.** An intent with all checklist items done but no Outcome is a broken state. Complete the intent immediately — do not leave it for later.
+**This is NOT optional.** An intent with all checklist items done but no Outcome is a broken state. Complete the intent immediately, do not leave it for later.
 
 ## Inline Workflow
 
 ### Step 1: Load and Review Plan
+Run Step 0 (Sync Worktree First) before this step.
 1. Read plan file from active intent
-2. Review critically — raise concerns before starting
+2. Review critically, raise concerns before starting
 3. Create task list to track progress
 
 ### Step 2: Execute Tasks
@@ -91,7 +108,7 @@ For each task:
 1. Mark as in_progress
 2. Follow each step exactly
 3. Run verifications as specified
-4. Mark as completed
+4. Tick as it lands: follow `## Tick-as-you-land` below
 
 ### Step 3: Update Intent and Complete
 Capture observations in `## Insights`. When ALL checklist items are checked:
@@ -100,11 +117,55 @@ Capture observations in `## Insights`. When ALL checklist items are checked:
 2. Write `## Outcome` summary in the intent file (1-2 sentences)
 3. Move intent from `## Active` to `## Completed` in INDEX.md (with today's date)
 4. Update cluster entries to show `_(completed)_`
-5. Auto-commit: `cd <store-root> && git add . && git commit -m "feat: complete intent <ID> — <name>"`
+5. Auto-commit: `cd <store-root> && git add . && git commit -m "feat: complete intent <ID>: <name>"`
 6. QMD reindex LAST (canonical End tail). As the final End-tail step, after the terminal move and any disarm, ALWAYS refresh the QMD search index for this store (no-op when QMD is absent), running in the background so it never blocks the turn: `ruby ~/.plastic/scripts/qmd-sync reindex --store <store-root> --async`. Completion is the lifecycle event that keeps the search index fresh, and the reindex runs last so the index never references a bridge or lock that is about to disappear (see PLASTIC.md `## Delivery Isolation and the Single-Owner Lock`).
 
 **This is NOT optional.** Complete the intent immediately when work is done.
 
+## Tick-as-you-land
+
+As each task lands, in the same edit: move its checklist item from `## In
+Progress` to `## Completed` in `checklist.md`, and add one `## Session Log`
+row (Date, Items Completed, Notes). 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.
+
+## Verify before every owner gate
+
+Hard rule: before presenting any completed work to the owner, independently
+verify it. Grep or run the artifact the work just produced (the test suite,
+the changed file, the installed output) rather than restating the intended
+change. Never present an unverified claim to the owner. If verification
+fails, fix it before the gate, not after.
+
+## Methods report (audits and sweeps)
+
+When the work is an audit or a sweep (checking many files or many instances of
+something rather than building one artifact), deposit a methods report to
+`{intent_dir}/resources/` before the gate: what was checked, how it was
+checked, and what was found. This lets the owner review the method, not just
+the conclusion.
+
+## Reroute vs dispatch
+
+A human-facing instruction like "run /plastic-intent-speccing" means the user
+types that slash command themselves; it is never handed to a
+subagent. Agent-facing dispatch text is a prompt passed to the Agent tool for
+a subagent to execute. Keep the two separate: do not address a slash command
+to a subagent, and do not paste a dispatch prompt at the user.
+
+## Owner decisions during Exec
+
+When presenting a batch of Exec decisions for the owner to rule, read
+`~/.plastic/_decision-tables.md` and follow the numbered-table procedure,
+persisting each ruling with `--stage Exec`.
+
+## Gate position
+
+- **Before:** `plan.md` and `checklist.md` exist; the worktree is armed.
+- **Produces:** code changes, a ticked checklist, and (for audits or sweeps) a methods report in `resources/`.
+- **Next:** intent-ending owns `outcome.md` (see intent 161). This skill's own Update-Intent-and-Complete step above is unchanged by this note.
+
 ## Model Selection for Subagents
 
 Match model to task complexity:
@@ -115,8 +176,8 @@ Match model to task complexity:
 ## Prompt Templates
 
 Subagent prompts are in this skill's directory:
-- `implementer-prompt.md` — template for implementer subagents
-- `spec-reviewer-prompt.md` — template for spec compliance reviewers
-- `code-quality-reviewer-prompt.md` — template for code quality reviewers
+- `implementer-prompt.md`: template for implementer subagents
+- `spec-reviewer-prompt.md`: template for spec compliance reviewers
+- `code-quality-reviewer-prompt.md`: template for code quality reviewers
 
 Read the appropriate template when dispatching each subagent type.

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

@@ -0,0 +1,66 @@
+{
+  "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/{brainstorming-grill-me → intent-grilling}/SKILL.md

@@ -1,9 +1,10 @@
 ---
-name: plastic-brainstorming-grill-me
+name: plastic-intent-grilling
 description: >-
   Deep brainstorming that interviews the user relentlessly about a plan or design until reaching shared understanding.
   Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".
-  Pair with plastic-brainstorming for quick ideation and use grill-me for thorough interrogation. If superpowers:brainstorming is installed it complements this skill, but it is not required.
+  Pair with plastic-intent-brainstorming for quick ideation and use grill-me for thorough interrogation. If superpowers:brainstorming is installed it complements this skill, but it is not required.
+user-invocable: true
 ---
 
 # Grill Me — Deep Brainstorming
@@ -94,7 +95,7 @@ This offer replaces the final question in Close Out ("Ready to plan implementati
 
 ## Relationship to superpowers:brainstorming
 
-| | superpowers:brainstorming | plastic-brainstorming-grill-me |
+| | superpowers:brainstorming | plastic-intent-grilling |
 |---|---|---|
 | Speed | Quick (5-10 min) | Thorough (20-45 min) |
 | Depth | Surface-level exploration | Exhaustive decision tree |
@@ -102,4 +103,4 @@ This offer replaces the final question in Close Out ("Ready to plan implementati
 | Output | Initial spec | Battle-tested spec with all branches resolved |
 | Style | Collaborative, exploratory | Interrogative, relentless |
 
-Use `superpowers:brainstorming` to generate ideas. Use `plastic-brainstorming-grill-me` to pressure-test them.
+Use `superpowers:brainstorming` to generate ideas. Use `plastic-intent-grilling` to pressure-test them.

package/skills/{linking-intents → intent-linking}/SKILL.md

@@ -1,6 +1,7 @@
 ---
-name: plastic-linking-intents
+name: plastic-intent-linking
 description: Use when creating connections between intents, the user says "link" or "connect", or when discovering that two intents are related. Manages sources, chain, and cross-reference links.
+user-invocable: false
 ---
 
 # Linking Intents

package/skills/{linking-intents → intent-linking}/evals/evals.json

@@ -1,5 +1,5 @@
 {
-  "skill_name": "plastic-linking-intents",
+  "skill_name": "plastic-intent-linking",
   "notes": "Intent 66a. Spec for the QMD-first discovery step (surface candidate/related intents to propose as sources/chain before grep/Read). Runner is intent 76; this case is a spec, not executed.",
   "evals": [
     {

package/skills/{lock → intent-locking}/SKILL.md

@@ -1,6 +1,7 @@
 ---
-name: lock
+name: plastic-intent-locking
 description: Inspect, repair, release, or reclaim an intent's delivery lock. Use when a lock-gate deny names /plastic-lock, when resuming interrupted work after a crash, reboot, or /tmp wipe, when a lock reads held or stale, or when the user says "fix the lock", "who holds the lock", or "reclaim the lock".
+user-invocable: false
 ---
 
 # Plastic Lock

package/skills/{writing-plans → intent-planning}/SKILL.md

@@ -1,6 +1,7 @@
 ---
-name: plastic-writing-plans
-description: "Write implementation plans from a spec. Produces plan.md, checklist.md, and actions/ in the active intent directory."
+name: plastic-intent-planning
+description: "Write implementation plans from a spec. Produces plan.md, checklist.md, and (L tier only) actions/ in the active intent directory."
+user-invocable: true
 ---
 
 # Writing Plans
@@ -11,22 +12,31 @@ Write comprehensive implementation plans assuming the engineer has zero context
 
 Assume they are a skilled developer, but know almost nothing about our toolset or problem domain. Assume they don't know good test design very well.
 
-**Announce at start:** "I'm using the writing-plans skill to plan intent {id} — {name}."
+**Announce at start:** "I'm using the writing-plans skill to plan intent {id}: {name}."
 
 ## Active Intent Gate
 
 Before proceeding, resolve the active intent:
 
 1. **Detect store:** Read `~/.plastic/projects.yml`, match CWD against registered project paths. If match → project store at `~/.plastic/projects/{slug}/store/`. If no match → global store at `~/.plastic/store/`.
-2. **Find active intent:** Read `INDEX.md` from the detected store. Look under `## Active`. If exactly one → use it. If multiple → ask which. If none → refuse: "No active intent. Create one first with /plastic-creating-intent"
+2. **Find active intent:** Read `INDEX.md` from the detected store. Look under `## Active`. If exactly one → use it. If multiple → ask which. If none → refuse: "No active intent. Create one first with /plastic-intent-creating"
 3. **Resolve intent directory:** `{store}/store/{id}--{slug}/`
-4. **Read spec:** Load `{intent_dir}/spec.md`. If no spec exists → refuse: "No spec found. Run /plastic-brainstorming first."
+4. **Read spec:** Load `{intent_dir}/spec.md`. If no spec exists → refuse: "No spec found. Run /plastic-intent-speccing first."
 
 All artifacts go to the intent directory. Never write to external paths.
 
 ## Scope Check
 
-If the spec covers multiple independent subsystems, it should have been broken into sub-project specs during brainstorming. If it wasn't, suggest breaking this into separate plans — one per subsystem. Each plan should produce working, testable software on its own.
+If the spec covers multiple independent subsystems, it should have been broken into sub-project specs during brainstorming. If it wasn't, suggest breaking this into separate plans, one per subsystem. Each plan should produce working, testable software on its own.
+
+## Tier shapes
+
+Read the spec's stamped `Tier:` line (written by intent-speccing) and pick the plan shape it calls for:
+
+- **S or M (default):** an inline plan-as-checklist. Tasks live directly in `plan.md` with rationale inline; `checklist.md` mirrors the task list. Do NOT create any `actions/` files. Leave the `actions/` directory empty (or absent).
+- **L (many independent tasks, dispatched in parallel):** self-contained `actions/ACTION_N.md`, one per task, each readable without the plan (see `references/plan-format.md`).
+
+Default to inline for S and M. Reserve `actions/` for L, where tasks are independent enough to hand to separate subagents in parallel. When in doubt, prefer inline; creating unnecessary `actions/` files is a plan failure at S/M tier.
 
 ## File Structure
 
@@ -58,48 +68,67 @@ into tasks matching the Task Structure shape.
 
 ## No Placeholders
 
-Every step must contain the actual content an engineer needs. These are **plan failures** — never write them:
+Every step must contain the actual content an engineer needs. These are **plan failures**, never write them:
 - "TBD", "TODO", "implement later", "fill in details"
 - "Add appropriate error handling" / "add validation" / "handle edge cases"
 - "Write tests for the above" (without actual test code)
-- "Similar to Task N" (repeat the code — the engineer may be reading tasks out of order)
+- "Similar to Task N" (repeat the code; the engineer may be reading tasks out of order)
 - Steps that describe what to do without showing how (code blocks required for code steps)
 - References to types, functions, or methods not defined in any task
 
 ## Remember
 - Exact file paths always
-- Complete code in every step — if a step changes code, show the code
+- Complete code in every step: if a step changes code, show the code
 - Exact commands with expected output
 - DRY, YAGNI, TDD, frequent commits
 
 ## Self-Review
 
-After writing the complete plan, look at the spec with fresh eyes and check the plan against it. This is a checklist you run yourself — not a subagent dispatch.
+After writing the complete plan, look at the spec with fresh eyes and check the plan against it. This is a checklist you run yourself, not a subagent dispatch.
 
 **1. Spec coverage:** Skim each section/requirement in the spec. Can you point to a task that implements it? List any gaps.
 
-**2. Placeholder scan:** Search your plan for red flags — any of the patterns from the "No Placeholders" section above. Fix them.
+**2. Placeholder scan:** Search your plan for red flags, any of the patterns from the "No Placeholders" section above. Fix them.
 
 **3. Type consistency:** Do the types, method signatures, and property names you used in later tasks match what you defined in earlier tasks? A function called `clear_layers` in Task 3 but `clear_full_layers` in Task 7 is a bug.
 
-If you find issues, fix them inline. No need to re-review — just fix and move on. If you find a spec requirement with no task, add the task.
+If you find issues, fix them inline. No need to re-review, just fix and move on. If you find a spec requirement with no task, add the task.
 
 ## Plastic Artifacts
 
-After writing `plan.md`, create two additional artifacts in the intent directory:
-`checklist.md` (execution registry with one checkbox per task) and
-`actions/ACTION_N.md` (one self-contained file per task, in an `actions/`
-directory inside the intent directory). For the exact format of both, read
-`references/plan-format.md`.
+After writing `plan.md`, create `checklist.md` (execution registry following the
+FORM: `## In Progress`, `## Completed`, `## Session Log`) in the intent directory.
+For L tier only, also create `actions/ACTION_N.md` (one self-contained file per
+task, in an `actions/` directory inside the intent directory). For S/M tier, do
+not create `actions/` files at all (see Tier shapes above). For the exact format
+of both, read `references/plan-format.md`.
+
+## Owner-decision hard-gate items
+
+When a task depends on an owner decision that must be made before any code edit
+happens (a destructive step, a structural ruling, a merge that must land first),
+add a checklist item prefixed `[ORCHESTRATOR]` that names the decision and states
+plainly that it blocks all code edits until the owner rules on it. Order these
+items first: destructive or structural rulings apply before the sweeping edits
+that depend on them.
+
+When collecting owner rulings for `[ORCHESTRATOR]` hard-gate items, read
+`~/.plastic/_decision-tables.md` and follow the numbered-table procedure.
+
+## Gate position
+
+- **Before:** `spec.md` exists.
+- **Produces:** `plan.md` and `checklist.md` (plus `actions/` for L tier only).
+- **Next:** /plastic-intent-executing.
 
 ## Git Commit
 
-After writing all artifacts (plan.md, checklist.md, actions/), commit to the store:
+After writing all artifacts (plan.md, checklist.md, actions/ for L tier), commit to the store:
 
 ```bash
-cd {store_root} && git add . && git commit -m "docs: plan for intent {id} — {name}"
+cd {store_root} && git add . && git commit -m "docs: plan for intent {id}: {name}"
 ```
 
 ## Execution Handoff
 
-Plan complete. Invoke `plastic-executing-plan` to begin execution.
+Plan complete. Invoke `plastic-intent-executing` to begin execution.