@zalom/plastic 1.0.3 → 1.1.0

package/skills/{executing-plan → intent-executing}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-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
 ---
@@ -12,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.
@@ -35,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:
@@ -63,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.
@@ -75,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
@@ -92,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:
@@ -101,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:
@@ -116,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,9 @@
 ---
-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
 ---
 
@@ -95,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 |
@@ -103,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,5 +1,5 @@
 ---
-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
 ---

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,5 +1,5 @@
 ---
-name: plastic-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
 ---

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

@@ -1,6 +1,6 @@
 ---
-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
 ---
 
@@ -12,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
 
@@ -59,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.

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

@@ -0,0 +1,66 @@
+{
+  "skill_name": "plastic-intent-planning",
+  "notes": "Intent 164. New evals.json for the writing-plans skill: tier-shape enforcement (S/M inline vs L actions/) and the checklist FORM plus [ORCHESTRATOR] hard-gate item convention. All assertions are pending a real observed run per the plastic-evaluating-skills convention.",
+  "evals": [
+    {
+      "id": 1,
+      "scope": "behavior",
+      "set": "train",
+      "prompt": "spec.md is stamped Tier: M and describes a single subsystem change touching four files across two tasks. Write the plan.",
+      "expected_output": "Produces an inline plan-as-checklist: all tasks with rationale live directly in plan.md, and checklist.md mirrors the task list. No actions/ACTION_N.md files are created; the actions/ directory stays empty or absent.",
+      "files": [],
+      "assertions": [
+        {
+          "type": "code",
+          "check": "no files created under actions/ for this intent; checklist.md exists and mirrors plan.md's task list",
+          "result": "expect-pass"
+        }
+      ]
+    },
+    {
+      "id": 2,
+      "scope": "behavior",
+      "set": "train",
+      "prompt": "spec.md is stamped Tier: S and describes a single-file config change. Write the plan.",
+      "expected_output": "Produces an inline plan-as-checklist. No actions/ files are created, matching the S/M default.",
+      "files": [],
+      "assertions": [
+        {
+          "type": "code",
+          "check": "no files created under actions/ for this intent",
+          "result": "expect-pass"
+        }
+      ]
+    },
+    {
+      "id": 3,
+      "scope": "behavior",
+      "set": "train",
+      "prompt": "spec.md is stamped Tier: L and describes a cross-cutting redesign decomposed into eight independent tasks meant to be dispatched to separate subagents in parallel. Write the plan.",
+      "expected_output": "Produces self-contained actions/ACTION_N.md, one file per task, each readable without the plan (full task text, code, and commands copied in). checklist.md has one item per task.",
+      "files": [],
+      "assertions": [
+        {
+          "type": "code",
+          "check": "actions/ directory contains one ACTION_N.md per task; each action file is self-contained (no bare references like \"see Task 3\" without the content)",
+          "result": "expect-pass"
+        }
+      ]
+    },
+    {
+      "id": 4,
+      "scope": "behavior",
+      "set": "validation",
+      "prompt": "spec.md names an owner decision (whether to delete or archive a legacy table) that must be ruled on before any code edit in the plan can proceed. Write the plan.",
+      "expected_output": "checklist.md includes a checklist item prefixed [ORCHESTRATOR] that names the owner decision and states it blocks all code edits until the owner rules; this item is ordered before the sweeping edit tasks that depend on it. checklist.md follows the FORM: ## In Progress, ## Completed (empty), ## Session Log with Date | Items Completed | Notes columns.",
+      "files": [],
+      "assertions": [
+        {
+          "type": "human",
+          "check": "an [ORCHESTRATOR] item exists, names the decision, states it blocks code edits, and precedes dependent tasks; checklist.md has the three FORM sections in the right shape",
+          "result": "expect-pass"
+        }
+      ]
+    }
+  ]
+}

package/skills/{writing-plans → intent-planning}/references/plan-format.md

@@ -18,7 +18,7 @@ plan.md so the shape matches on the first pass.
 ```markdown
 # [Feature Name] Implementation Plan
 
-> **For agentic workers:** Use `plastic-executing-plan` to implement this plan task-by-task.
+> **For agentic workers:** Use `plastic-intent-executing` to implement this plan task-by-task.
 
 **Goal:** [One sentence describing what this builds]
 
@@ -26,7 +26,10 @@ plan.md so the shape matches on the first pass.
 
 **Tech Stack:** [Key technologies/libraries]
 
-**Intent:** {id} — {name}
+**Intent:** {id}: {name}
+
+**Tier:** S|M|L, copied from the spec's stamped `Tier:` line. S and M plans are
+inline plan-as-checklist (no `actions/`); L plans use `actions/ACTION_N.md`.
 
 ---
 ```
@@ -78,25 +81,46 @@ git commit -m "feat: add specific feature"
 
 ## checklist.md format
 
-Execution registry with one checkbox per task. Format:
+Execution registry with one checkbox per task, following this FORM regardless
+of tier (S, M, or L):
 
 ```markdown
-# Checklist — Intent {id}: {name}
+# Checklist: {name}
 
+## In Progress
 - [ ] Task 1: {task title}
 - [ ] Task 2: {task title}
 - [ ] Task 3: {task title}
-...
+
+## Completed
+(empty at plan time; move each item here, checked, the moment its task lands)
+
+## Session Log
+| Date | Items Completed | Notes |
+|------|-----------------|-------|
 ```
 
+- `## In Progress` holds every unchecked task, in plan order.
+- `## Completed` starts empty. As execution lands a task, move its item here
+  (checked) instead of leaving a checked box under `## In Progress`.
+- `## Session Log` gets one row per work session: the date, which items
+  completed, and any deviation or finding worth recording.
+- An owner-decision hard-gate item (see the parent SKILL.md's
+  `## Owner-decision hard-gate items`) is a normal checklist item prefixed
+  `[ORCHESTRATOR]`; it lives under `## In Progress` until the owner rules, then
+  moves to `## Completed` like any other item.
+
 ## actions/ACTION_N.md format
 
-One file per task. Each action is self-contained — a subagent can execute it without reading the plan.
+L tier only. S and M plans skip this file type entirely; their tasks live
+inline in `plan.md` (see the parent SKILL.md's `## Tier shapes`).
+
+One file per task. Each action is self-contained: a subagent can execute it without reading the plan.
 
 ```markdown
 # Action {N}: {task title}
 
-{Full task text copied from plan.md — all steps, all code, all commands. Nothing omitted.}
+{Full task text copied from plan.md: all steps, all code, all commands. Nothing omitted.}
 ```
 
 Create the `actions/` directory inside the intent directory: `{intent_dir}/actions/`

package/skills/{research → intent-researching}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: plastic-research
+name: plastic-intent-researching
 description: "Research a topic for the active intent. Agent decides shallow vs deep based on scope. Produces reports in the intent's resources/ directory."
 user-invocable: true
 ---
@@ -15,7 +15,7 @@ Investigate a topic related to the active intent. Choose the right depth, produc
 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}/`
 
 ## Check Prior Work First

package/skills/{research → intent-researching}/evals/evals.json

@@ -1,5 +1,5 @@
 {
-  "skill_name": "plastic-research",
+  "skill_name": "plastic-intent-researching",
   "notes": "Intent 66a. Spec for the QMD-first step before researching (reuse prior intents/reports before grep/Read or web search). Runner is intent 76; spec only.",
   "evals": [
     {

package/skills/{savepoint → intent-savepoint}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: plastic-savepoint
+name: plastic-intent-savepoint
 description: Use when verifying or repairing an intent's savepoint ledger, when the user says "save" or "savepoint", or when a PreCompact hook fires. The ledger is written automatically by the gate hook at each lifecycle boundary; this skill only reads, verifies, and rebuilds it.
 user-invocable: false
 ---