@zalom/plastic 1.0.0-alpha.9 → 1.0.0-beta.10

package/skills/continuing/SKILL.md

@@ -1,104 +1,121 @@
 ---
-name: plastic:continuing
-description: Use when the user says "continue" after a /clear, or when resuming work in a new session. Reads intent state from global store (~/.plastic/) or local store, offers active intents first, then future intents, and surfaces stale intents for triage.
+name: plastic-continuing
+description: Use when the user says "continue", "resume", or "pick up where we left off", or when starting a new session. Continues work with the latest project context: lands on the right dashboard, then presents choices. Boot (health check, core context, version, statusline) is owned by the SessionStart hook, not this skill. Does not drive work autonomously (that is plastic-auto).
 ---
 
 # Continuing
 
+`plastic-continuing` continues work. It presents the latest state via the dashboard and offers
+choices, then stops. It does NOT execute work autonomously (that is `plastic-auto`) and does
+NOT render the dashboard itself (it only invokes it).
+
+**Boot is not this skill's job.** The `hook-session-start` hook already runs by construction on
+every session start: it runs the core health check (`doctor --core`), primes `PLASTIC.md` +
+store/project state, and prints the `Plastic Core loaded — v{version}` banner. The
+`plastic-statusline` hook sets the statusline. So by the time this skill runs, core is loaded
+and healthy (or the banner already warned otherwise). This skill picks up from there and
+continues work. This is the seam future continue-flags build on (see [[39]]).
+
 ## When to Use
 - UserPromptSubmit hook detects "continue" (automatic)
 - User says "continue", "resume", or "pick up where we left off"
-- Starting a new session with existing active intents
+- Starting a new session and you want to resume work with the latest context
 
 ## Determine Store
 
-1. Check `~/.plastic/INDEX.md` → global mode
-2. 
-3. If neither exists → announce "No Plastic store found. Run /plastic:install."
-
-## Workflow
-
-### 1. Read INDEX.md
-Read the INDEX.md from the active store. Extract intents under `## Active` and `## Future`.
-
-### 2. Detect Current Project (global mode only)
-Read `~/.plastic/projects.yml`, match CWD against registered project paths. If in a project:
-- Load the governing intent (from `parent` in projects.yml)
-- Load tactical intents from `~/.plastic/projects/{slug}/store/`
-
-### 3. If Active Intents Exist → Resume
-
-For each active intent in the store:
-
-**a. Read `{ID}--{slug}.md`:**
-- What we're doing (`## Intent`)
-- Why (`## Context`)
-- What insights have emerged (`## Insights`)
-
-**b. Read savepoint.md** (if exists):
-- What was in progress, what's next, blockers
-
-**c. Read checklist.md** (if exists):
-- What's completed, what's next
-
-**d. Announce:**
-```
-Resuming intent [ID] — [name]
-Store: [global | project:<slug> | local]
-Status: active
-Last session: [date from savepoint]
-In progress: [from savepoint]
-Next step: [from checklist or savepoint]
-Blockers: [from savepoint, or "none"]
-```
-
-**e. Resume** — proceed with the next step.
-
-### 3b. Detect Autonomous Resume
-
-When resuming an active intent, check `## Insights` for entries containing `(autonomous)`.
-
-If found — this intent was being delivered autonomously:
-
-**Announce:**
-```
-Resuming autonomous delivery of intent [ID] — [name]
-Store: [global | project:<slug> | local]
-Last autonomous action: [last (autonomous) insight entry]
-Next step: [from checklist or savepoint]
-```
-
-**Then:** Continue autonomous execution by invoking `plastic:auto`. The auto skill will pick up from the current lifecycle stage (it reads filesystem state to determine where to resume).
-
-If NOT found — resume normally as described in step 3.
-
-### 4. If No Active Intents → Offer Future Intents
-
-Present future intents as options. When user picks one, move to Active in INDEX.md. Auto-commit.
-
-### 5. Surface Stale Future Intents
-
-If any future intent has `created` date older than the configured `stale_threshold_days` (default 3):
+1. **Global store** — `~/.plastic/INDEX.md` exists → global mode.
+2. **Local store** — a project store under `~/.plastic/projects/{slug}/` whose registered
+   path (in `~/.plastic/projects.yml`) matches the current working directory → project mode.
+   The SessionStart hook already detects this; here you only need the slug to scope the
+   dashboard.
+3. If neither exists → announce "No Plastic store found. Run /plastic-install."
+
+## Continue (present the dashboard)
+
+Land on the Markdown board via the `plastic-dashboard` skill. Rendering belongs there, not
+here — run the data payload and fill + present the matching template:
+- Project loaded → `ruby ~/.plastic/scripts/dashboard.rb project <slug> --data`
+- Otherwise → `ruby ~/.plastic/scripts/dashboard.rb continue --data`
+
+Fill the matching template from this skill's `templates/` and **present the filled Markdown
+in your reply** (every time). See `plastic-dashboard` for the fill rules and entry flow.
+
+The board load runs the scoped store check on every load (`doctor --store <scope>`): the
+global board runs `--store global` and a project board runs `--store <slug>`. The result
+arrives in the payload as `store_health`; surface it as a one-line store-health note. It is
+non-fatal (a warn or fail is shown as data, it does not block continuing).
+
+### Then stop
+Present "here is the state, what next?" and wait. Offer active intents first, then future
+intents. Do not start executing work. The branches below are the only follow-ups:
+- User/agent names a specific intent to continue → **Conditional ledger-resume** (below).
+- User says "auto" / an agent is instructed to deliver → hand to `plastic-auto`.
+
+## Conditional Ledger-Resume
+
+Fires ONLY when the user explicitly asks to continue a SPECIFIC intent, or an agent is
+instructed to continue one. It is not part of every boot.
+
+QMD-first (when available): when the user names the intent by description rather than id, before
+scanning the store with grep/Read run `ruby ~/.plastic/scripts/qmd-sync search "<terms>"` to
+surface the candidate intent, then open the authoritative intent file for the hit you resume. The
+command is a no-op when QMD is absent, so fall back to the existing INDEX.md / file scan.
+
+For that intent's directory:
+
+1. **Read `savepoint.md`.** It is a deterministic, append-only stage ledger (one line per
+   milestone, newest at the bottom): `{utc-iso8601}  {Stage}  {milestone}`. The **last line =
+   current stage**.
+2. **Verify the stage file.** Confirm the file the ledger names exists and is non-empty
+   (ledger `How  plan.md created` → `plan.md` must be present and non-empty).
+3. **Drift handling.** If the ledger's last line disagrees with files-on-disk, rebuild the
+   ledger from filesystem state and note the correction:
+   ```bash
+   ruby -r ~/.plastic/scripts/lib/bridge -e 'Bridge.rebuild_savepoint("<intent_dir>")'
+   ```
+4. **Derive the next step:**
+   - First unchecked item in `checklist.md` if it exists, else
+   - "advance to the next lifecycle stage" (e.g. ledger shows Why/spec.md → next is How).
+   - The newest `## Insights` entry supplies human-readable context (Insights are
+     append-only, newest at the bottom).
+5. **Announce and stop:**
+   ```
+   Resuming intent [ID] — [name]
+   Store: [global | project:<slug> | local]
+   Stage: [from ledger last line]
+   Next step: [first unchecked checklist item | advance to <stage>]
+   Context: [newest ## Insights entry]
+   Drift: [none | ledger rebuilt from filesystem]
+   ```
+   Then proceed with the next step. Autonomy is `plastic-auto`'s job — if the intent's
+   `## Insights` contains `(autonomous)` entries, it was being delivered autonomously; hand
+   to `plastic-auto` to continue from the current stage.
+
+## Priority Order
+
+1. **Active intents first** — surface work in progress.
+2. **Project context** — if in a registered project, show governing + tactical intents.
+3. **Stale future intents** — surface for triage (see below).
+4. **Fresh future intents** — offer as next work.
+
+## Stale Future Intents
+
+If a future intent's `created` date is older than the configured `stale_threshold_days`
+(default 3), surface it for triage without taking action:
 
 ```
 Stale future intents (no action taken):
 
 - [ID — name] (X days old)
-  Options:
   a) Activate — start working on it now
   b) Abandon — mark as abandoned
-  c) Defer to agent:
-     - implement: agent builds it
-     - research: agent investigates feasibility
-     - ideate: agent explores the problem space
-  d) Auto — go fully autonomous (invokes plastic:auto — agent delivers the intent end-to-end)
+  c) Defer to agent: implement | research | ideate
+  d) Auto — go fully autonomous (invokes plastic-auto)
 ```
 
-Auto-commit all triage changes.
+When the user activates a future intent, move it to `## Active` in INDEX.md and auto-commit.
 
-### 6. Priority Order
+## References
 
-1. **Active intents first** — resume work in progress
-2. **Project context** — if in a registered project, show governing intent + tactical intents
-3. **Stale future intents** — surface for triage
-4. **Fresh future intents** — offer as next work
+- Read `references/context-management.md` for the full save/continue protocol and for
+  debugging the resume flow.

package/skills/continuing/evals/evals.json

@@ -0,0 +1,145 @@
+{
+  "skill_name": "plastic-continuing",
+  "notes": "Intent 36, updated for 36a (boot moved into hook-session-start; the skill is now work-continuation only). Scopes: description triggering (1-8) and behavior/convention compliance of the work-continuation skill (9-14). Triggering assertions follow the plastic-auto eval style (one subagent router per case). Behavior assertions are convention checks against the SKILL.md.",
+  "results": {
+    "triggering": { "cases": 8, "passed": 8, "run": "2026-06-16, one subagent per case" },
+    "behavior": { "cases": 6, "passed": 6, "evidence": "convention checks against skills/continuing/SKILL.md after the intent-36 rewrite; doctor --core verified at 0.07s with 9 liveness checks and full doctor unchanged at 30 checks" }
+  },
+  "evals": [
+    {
+      "id": 1, "scope": "triggering", "set": "train",
+      "prompt": "continue",
+      "expected_output": "Activates plastic-continuing (the bare 'continue' keyword is the documented trigger).",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
+      ]
+    },
+    {
+      "id": 2, "scope": "triggering", "set": "train",
+      "prompt": "resume where we left off",
+      "expected_output": "Activates plastic-continuing.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
+      ]
+    },
+    {
+      "id": 3, "scope": "triggering", "set": "validation",
+      "prompt": "pick up where we left off in this project",
+      "expected_output": "Activates plastic-continuing.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
+      ]
+    },
+    {
+      "id": 4, "scope": "triggering", "set": "train",
+      "prompt": "boot plastic and show me where things stand",
+      "expected_output": "Activates plastic-continuing (continuing work + presenting state is the skill's purpose; boot itself is hook-owned).",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
+      ]
+    },
+    {
+      "id": 5, "scope": "triggering", "set": "train",
+      "prompt": "continue delivering this intent autonomously, don't ask me",
+      "expected_output": "Does NOT settle on plastic-continuing for execution. Shares 'continue' but the autonomous-delivery intent routes to plastic-auto.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-auto", "observed": "plastic-auto", "result": "pass" }
+      ]
+    },
+    {
+      "id": 6, "scope": "triggering", "set": "validation",
+      "prompt": "continue the for-loop to the next iteration in this function",
+      "expected_output": "Does NOT activate plastic-continuing. Near-miss: shares 'continue' but is a code-editing task.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE != plastic-continuing", "observed": "none", "result": "pass" }
+      ]
+    },
+    {
+      "id": 7, "scope": "triggering", "set": "train",
+      "prompt": "resume the paused background download",
+      "expected_output": "Does NOT activate plastic-continuing. Near-miss: shares 'resume' but is unrelated to Plastic sessions.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE != plastic-continuing", "observed": "none", "result": "pass" }
+      ]
+    },
+    {
+      "id": 8, "scope": "triggering", "set": "validation",
+      "prompt": "what's the dashboard look like right now",
+      "expected_output": "May activate plastic-dashboard rather than plastic-continuing; an overview request without 'continue/resume' is a dashboard task.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE != plastic-continuing", "observed": "plastic-dashboard", "result": "pass" }
+      ]
+    },
+    {
+      "id": 9, "scope": "behavior", "set": "train",
+      "prompt": "Does the skill defer boot to the SessionStart hook rather than running it itself?",
+      "expected_output": "SKILL.md states boot (health check, core context, version banner, statusline) is owned by hook-session-start / plastic-statusline, not this skill.",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "SKILL.md says boot is owned by the SessionStart hook and the skill does not run it", "observed": "'Boot is not this skill's job.' paragraph naming hook-session-start and plastic-statusline", "result": "pass" }
+      ]
+    },
+    {
+      "id": 10, "scope": "behavior", "set": "train",
+      "prompt": "Does the skill avoid running doctor / setting the statusline itself?",
+      "expected_output": "SKILL.md does NOT instruct running doctor.rb --core or setting the statusline; it attributes those to the hooks.",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "no in-skill boot step invokes doctor.rb --core or sets the statusline; both are attributed to hooks", "observed": "doctor --core and statusline mentioned only as hook-owned in the 'Boot is not this skill's job' note", "result": "pass" }
+      ]
+    },
+    {
+      "id": 11, "scope": "behavior", "set": "train",
+      "prompt": "Is dashboard selection project-aware?",
+      "expected_output": "Project loaded -> `dashboard.rb project <slug>`; otherwise -> `dashboard.rb continue`. Skill only invokes, does not render.",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "both dashboard invocations present and gated on project detection", "observed": "'dashboard.rb project <slug>' and 'dashboard.rb continue' in the 'Continue (present the dashboard)' section", "result": "pass" }
+      ]
+    },
+    {
+      "id": 12, "scope": "behavior", "set": "validation",
+      "prompt": "Is ledger-resume conditional and ledger-driven?",
+      "expected_output": "Resume fires only when a specific intent is named; reads savepoint.md last line as stage, verifies the stage file, rebuilds on drift, derives next step from first unchecked checklist item.",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "Conditional Ledger-Resume section reads last ledger line, verifies stage file, calls rebuild_savepoint on drift, uses first unchecked checklist item", "observed": "all four present in 'Conditional Ledger-Resume'", "result": "pass" }
+      ]
+    },
+    {
+      "id": 13, "scope": "behavior", "set": "validation",
+      "prompt": "Are the stale prose-savepoint fields gone?",
+      "expected_output": "No 'In progress' / 'Blockers' fields read from a prose savepoint remain; the ledger model is used instead.",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "no prose-savepoint announce template (In progress / Blockers from prose)", "observed": "absent; announce uses Stage/Next step/Context/Drift derived from ledger + checklist", "result": "pass" }
+      ]
+    },
+    {
+      "id": 14, "scope": "behavior", "set": "validation",
+      "prompt": "Is the 'Determine Store' local-store gap filled?",
+      "expected_output": "Step 2 of Determine Store describes local/project-store detection (no empty step).",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "Determine Store step 2 documents local/project store detection via projects.yml + CWD match", "observed": "filled", "result": "pass" }
+      ]
+    },
+    {
+      "id": 15, "scope": "behavior", "set": "validation",
+      "prompt": "QMD is present. The user says: continue the work on the statusline coloring (names the intent by description, not id).",
+      "expected_output": "Before scanning the store with grep/Read to locate the named intent, runs `ruby ~/.plastic/scripts/qmd-sync search \"statusline coloring\"` to surface the candidate intent, then opens the authoritative intent file for the hit it resumes. No-op fallback to INDEX.md / file scan when QMD is absent.",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "human", "check": "qmd-sync search is run before grep/Read when the intent is named by description; authoritative file opened for the hit", "observed": "Conditional Ledger-Resume carries the QMD-first step: run qmd-sync search before grep/Read, then open the authoritative file; no-op fallback when QMD is absent", "result": "pass" }
+      ]
+    }
+  ]
+}

package/skills/continuing/references/context-management.md

@@ -0,0 +1,32 @@
+# Context Management (Start-Save-Continue)
+
+## Save Point
+Triggered by PreCompact hook or manually:
+1. Find active intent(s) from `~/.plastic/INDEX.md`
+2. Update active intent's `checklist.md` (check off completed items)
+3. Update active intent's `savepoint.md` (in-progress, next steps, blockers, discoveries)
+4. Add observations to `## Insights`
+5. Update INDEX.md
+6. Commit: `cd ~/.plastic && git add . && git commit -m "chore: savepoint — [intent name]"`
+7. Notify user to `/clear`
+
+## Continue
+Triggered by UserPromptSubmit hook when user says "continue". Priority order:
+
+**1. Active intents first (resume work):**
+1. Read INDEX.md → find active intent(s)
+2. Read active intent's `intent.md` → what and why
+3. Read active intent's `savepoint.md` → where we left off
+4. Read active intent's `checklist.md` → what's next
+5. Announce: intent name, current state, next step, blockers
+6. Resume
+
+**2. No active intents → offer future intents:**
+1. List all future intents from INDEX.md
+2. Present them as options
+3. When user picks one, move to Active in INDEX.md
+
+**3. Stale future intents (untouched 3+ days) → triage:**
+- **activate** — start working on it now
+- **abandon** — mark as abandoned
+- **defer to agent** — implement, research, or ideate

package/skills/creating-intent/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: plastic:creating-intent
+name: plastic-creating-intent
 description: Use when new work begins, the user expresses a new goal, says "new intent", or no active intent exists for the current task. Creates intents in the global store (~/.plastic/store/) or in a project's store (~/.plastic/projects/{slug}/store/) depending on context.
 ---
 
@@ -30,7 +30,7 @@ description: Use when new work begins, the user expresses a new goal, says "new
 
 When creating a tactical intent in a project store:
 - Read the project's `AGENTS.md` for project context and decisions
-- Link back to the project's governing intent (from `projects.yml` `parent` field) via `sources`
+- Link back to the project's governing intent (from `projects.yml` `parent` field) via `sources` (the project genuinely is formed from its founding intent, a true formative edge, reciprocated on the founding intent's `chain`)
 - Add `[[global:<parent_ID>]]` backlink in `## Links`
 - The intent's Folgezettel ID is scoped to the project store (run `folgezettel-id` against the project's store at `~/.plastic/projects/{slug}/store/`)
 
@@ -41,45 +41,82 @@ When creating a tactical intent in a project store:
 - **Global:** `~/.plastic/store/`
 - **Project:** `~/.plastic/projects/{slug}/store/`
 
-### 2. Determine Folgezettel ID
-
-IDs are scoped to the store they live in. Use the correct store path:
-
-**Global store:**
-```bash
-"${CLAUDE_PLUGIN_ROOT}/scripts/folgezettel-id" "~/.plastic/store"
-```
-
-**Project store:**
-```bash
-"${CLAUDE_PLUGIN_ROOT}/scripts/folgezettel-id" "~/.plastic/projects/{slug}/store"
-```
-
-**Branch intent (has parent, either store):**
-```bash
-"${CLAUDE_PLUGIN_ROOT}/scripts/folgezettel-id" "<STORE>" "<parent_id>"
-```
+### 1b. Check for a Duplicate or Predecessor (QMD-first)
+
+QMD-first (when available): before scanning the store with grep/Read, run
+`ruby ~/.plastic/scripts/qmd-sync search "<terms>"` to surface candidate, prior, or duplicate
+intents, then open the authoritative intent file for any hit you act on. The command is a no-op
+when QMD is absent, so fall back to the existing INDEX.md / file scan. Do this before allocating
+the id so a near-duplicate can be reused and a true predecessor can be set in `--sources`.
+
+### 2. Decide Branch vs Root
+
+Decide this BEFORE scaffolding, because it sets whether you pass `--parent`.
+Having a "parent" in mind does NOT automatically mean branch. Choose by meaning:
+
+- **Branch (`14a`, `14b`)**: a sub-task, refinement, or direct continuation. It only
+  makes sense as part of the parent's work. Pass `--parent <parent_id>`.
+- **Root (`15`, `16`)**: an independent thought. Two cases, decided by ORIGIN:
+  - **Created from another intent** (it emerged from that intent's lifecycle): make it a
+    root and set `--sources <ascendant_id>`. `sources` is reserved for true created-from /
+    direct-ascendant provenance (D1).
+  - **Merely related to / inspired by another intent** (it did NOT come out of that
+    intent's lifecycle): carry NO `--sources`. Record the relation on the PREDECESSOR's
+    `chain` instead, and mirror it as a `[[id]]` wikilink in `## Links` (the
+    related-but-not-spawned rule).
+- **Rule of thumb:** if the intent could exist without its parent, make it a root; only set
+  `--sources` when it was genuinely created from / emerged from that intent's lifecycle.
+  Topic similarity alone is not a `sources` edge.
 
 ### 3. Determine Intent Properties
 
 Ask or infer from context:
 - **intent**: one-line description
+- **slug**: short hyphenated handle for the directory name
 - **author**: `human` | `claude-code` | other agent name
-- **sources**: array of Folgezettel IDs that influenced this intent (e.g., `["4a1"]`)
-- **chain**: starts empty `[]`, populated when this intent spawns others
+- **sources**: the direct ascendant(s) this intent was created from / emerged from the
+  lifecycle of (formation, not topic similarity), e.g., `4a1`. For a project intent,
+  include the governing intent's id. A branch's structural parent is ALSO recorded in
+  `sources` (the ID carries it for the human/paper tree, `sources` carries it for
+  software), which `new-intent` does automatically (see `new-intent:126`).
 - **tags**: freeform list (use `project-<name>` for project membership)
 
-Place in `## Active` or `## Future` in INDEX.md (status is convention-derived, not a frontmatter field).
+`chain` carries what this intent spawns AND related-but-not-spawned successors it leads to;
+it starts empty and is populated later. See
+`docs/concepts/how-plastic-sources-and-chains-intents.md` for the full model.
+Place the intent in `## Active` or `## Future` in INDEX.md (status is
+convention-derived, not a frontmatter field).
+
+### 4. Scaffold via new-intent (single call)
 
-### 4. Create Directory and Files
+Delegate id allocation, directory and file creation, the born-complete intent
+file, the sentinel placeholder lifecycle files, the reciprocal file links, and
+self-validation to one `new-intent` invocation. Do NOT hand-author any of these
+files.
 
 ```bash
-mkdir -p <STORE>/ID--slug
+"${CLAUDE_PLUGIN_ROOT}/scripts/new-intent" \
+  --store "<STORE>" --intent "<one-line>" --slug "<slug>" \
+  [--parent "<parent_id>"] [--author "<author>"] \
+  [--sources "id,id"] [--tags "project-<slug>,tag"]
 ```
 
-Write `{ID}--{slug}.md` using the intent template. For project intents, add the governing intent's ID to `sources` and add `[[global:ID]]` backlink in `## Links`.
+`new-intent` allocates the Folgezettel id (root, or a branch of `--parent`),
+creates `<STORE>/<id>--<slug>/` plus `actions/` and `resources/`, renders the
+born-complete `<id>--<slug>.md` from the intent template, writes the sentinel
+placeholder `spec.md`/`plan.md`/`checklist.md`/`outcome.md` (each marked
+`<!-- plastic:placeholder -->` so no stage detector reads them as reached), wires
+the reciprocal `[[id]]` links, and self-validates (frontmatter plus the sanctioned
+`##` sections). It prints the created directory path and exits 0.
+
+It does NOT touch INDEX.md, git, or project creation: those stay in this skill
+(steps 6 to 9 below).
+
+If `new-intent` exits non-zero, read the stderr report and fix the inputs (slug,
+intent, sources). Do not commit or announce an intent that did not scaffold
+cleanly, and do not work around the failure by hand-writing the files.
 
-### 5. If Implementation Intent Spawns a Project
+### 6. If Implementation Intent Spawns a Project
 
 When the user says "start building" or the plan calls for a new project:
 
@@ -89,8 +126,6 @@ When the user says "start building" or the plan calls for a new project:
    mkdir -p <project_root>/<slug>
    cd <project_root>/<slug>
    git init
-   mkdir -p ~/.plastic/projects/{slug}/store
-   touch ~/.plastic/projects/{slug}/store/.gitkeep
    ```
 3. Copy `AGENTS.md` template from `${CLAUDE_PLUGIN_ROOT}/templates/agents.md`
 4. Register in `~/.plastic/projects.yml`:
@@ -101,22 +136,33 @@ When the user says "start building" or the plan calls for a new project:
      registered: <today>
      status: active
    ```
-5. Add `project-<slug>` to the intent's `tags` array
-6. Auto-commit in both `~/.plastic/` and the new project
+5. Provision the project store (the single source of truth for store creation;
+   runs after step 4 because the provisioner requires the project to be
+   registered):
+   ```bash
+   ruby ~/.plastic/scripts/provision-project-store <slug>
+   ```
+6. Add `project-<slug>` to the intent's `tags` array
+7. Auto-commit in both `~/.plastic/` and the new project
 
-### 6. Update INDEX.md
+### 7. Update INDEX.md
 
 - **Global intents:** update `~/.plastic/INDEX.md`
 - **Project intents:** no global INDEX.md change (tactical intents are project-scoped)
 
 Add to `## Active` (or `## Future`) and appropriate cluster.
 
-### 7. Auto-commit
+### 8. Auto-commit
 
 ```bash
-cd <store-root> && git add . && git commit -m "feat: create intent ID — [name]"
+cd <store-root> && git add . && git commit -m "feat: create intent ID - [name]"
 ```
 
-### 8. Announce
+### 9. Announce
+
+"Created intent ID - [name]. Placed in: [Active|Future]. Store: [global|project:<slug>|local]."
+
+## References
 
-"Created intent ID — [name]. Placed in: [Active|Future]. Store: [global|project:<slug>|local]."
+- Read `references/lifecycle.md` for the full What→Why→How→Exec stage detail, filesystem-as-schema conventions, and creating-intent step-by-step
+- Read `references/wikilinks.md` for the wikilink syntax table when adding `## Links` to intents

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

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