@zalom/plastic 1.0.0-alpha.8 → 1.0.0-beta.1

package/skills/continuing/evals/evals.json

@@ -0,0 +1,136 @@
+{
+  "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" }
+      ]
+    }
+  ]
+}

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.
 ---
 
@@ -41,45 +41,62 @@ When creating a tactical intent in a project store:
 - **Global:** `~/.plastic/store/`
 - **Project:** `~/.plastic/projects/{slug}/store/`
 
-### 2. Determine Folgezettel ID
+### 2. Decide Branch vs Root
 
-IDs are scoped to the store they live in. Use the correct store path:
+Decide this BEFORE scaffolding, because it sets whether you pass `--parent`.
+Having a "parent" in mind does NOT automatically mean branch. Choose by meaning:
 
-**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>"
-```
+- **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, even if inspired by another intent.
+  Capture the inspiration in `--sources`, not in the id. Omit `--parent`.
+- **Rule of thumb:** if the intent could exist without its parent, make it a root and
+  set `--sources`. Only branch when it genuinely cannot stand alone.
 
 ### 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**: Folgezettel ids that influenced this intent (e.g., `4a1`). For a
+  project intent, include the governing intent's id.
 - **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` starts empty and is populated later when this intent spawns others.
+Place the intent in `## Active` or `## Future` in INDEX.md (status is
+convention-derived, not a frontmatter field).
 
-### 4. Create Directory and Files
+### 4. Scaffold via new-intent (single call)
+
+Delegate id allocation, directory and file creation, the born-complete intent
+file, the sentinel placeholder lifecycle files, the reciprocal file links, and
+self-validation to one `new-intent` invocation. Do NOT hand-author any of these
+files.
 
 ```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).
 
-### 5. If Implementation Intent Spawns a Project
+If `new-intent` exits non-zero, read the stderr report and fix the inputs (slug,
+intent, sources). Do not commit or announce an intent that did not scaffold
+cleanly, and do not work around the failure by hand-writing the files.
+
+### 6. If Implementation Intent Spawns a Project
 
 When the user says "start building" or the plan calls for a new project:
 
@@ -89,8 +106,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 +116,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/references/lifecycle.md

@@ -0,0 +1,73 @@
+# Building an Intent — Full Lifecycle Detail
+
+## What → `## Intent` section
+
+The desire. One paragraph. What the human or agent wants.
+This exists from the moment the intent is created.
+
+**Deliverable:** `{ID}--{slug}.md`
+
+## Why → `## Context` + `### Decisions` sections
+
+Why this intent exists. Grows over time through brainstorming and exploration.
+
+- **Context** — what we knew going in + what we decided along the way
+- **Decisions** — main premises derived from Context plus decisions from brainstorming/grilling
+- Decisions are Why-level: "status belongs on actions because multiple workstreams", not How-level: "use ACTION_N.md files"
+
+**Deliverable:** `spec.md` (consolidated specification from Context + Decisions + brainstorming)
+
+## How → Planning and preparation
+
+Research decisions, create the implementation plan, define actions.
+
+**Deliverable:** `plan.md` + `actions/` + `checklist.md` (execution registry with checkboxes covering all actions)
+
+## Exec → Execute actions
+
+Execute actions from the plan, track progress via checklist.
+
+**Deliverable:** `outcome.md` (detailed result). `## Outcome` in intent.md = short summary written as last step.
+
+## `## Insights` — Append-only work log
+
+Captured throughout ALL stages. One-liner bullet points.
+Never modified, only appended.
+
+Tracks: stage transitions, decisions, shifts, blocks, cancellations, material for future intents.
+This is how execution is tracked. When this intent completes, Insights
+is where to look for what comes next. New intents spawned from Insights
+appear in the `chain` field.
+
+## `## Links`
+
+Wikilinks for Obsidian graph navigation. Human-facing counterpart to the
+frontmatter knowledge graph.
+
+## Conventions — Filesystem as Schema
+
+State is derived from what exists, not from what's declared.
+
+| Convention | Signal |
+|---|---|
+| No `## Context` | Intent is fleeting (quick capture, non-actionable) |
+| `## Context` has content | Intent is permanent (developed, actionable) |
+| `## Outcome` has content | Intent is done |
+| `## Insights` has `(autonomous)` entries | Intent is/was being delivered autonomously |
+
+### Transitions
+
+- Fleeting → permanent: add `## Context` (one-way, also makes it actionable)
+- There is no separate "non-actionable → actionable" transition — permanence implies actionability
+- Even research intents are actionable: the research itself is the action, the conclusion is the outcome
+
+## Creating an Intent — Full Steps
+
+1. Determine the target store: `~/.plastic/store/` for global intents (default), `~/.plastic/projects/{slug}/store/` for project intents
+2. Decide branch vs root (this sets whether you pass `--parent`)
+3. Scaffold with one call: `"${CLAUDE_PLUGIN_ROOT}/scripts/new-intent" --store <store> --intent "<one-line>" --slug <slug> [--parent <id>] [--sources id,id] [--tags ...]`. This allocates the id, creates the directory plus `actions/` and `resources/`, renders the born-complete intent file (frontmatter plus `## Intent`, `## Context`, `## Outcome`, `## Insights`, `## Links`), writes the sentinel placeholder lifecycle files, wires the reciprocal links, and self-validates.
+4. Update the appropriate `INDEX.md` — add to Active section and appropriate cluster
+
+The intent file is born complete with all five sanctioned `##` sections; the lifecycle files (`spec.md`/`plan.md`/`checklist.md`/`outcome.md`) are sentinel placeholders that read as "stage not reached" until an agent fills them and deletes the `<!-- plastic:placeholder -->` first line.
+
+Always scaffold through `new-intent` (or this skill). Never hand-author intent files: the write-time create gate blocks an incomplete or malformed intent file, and hand-authoring is the bypass this contract is designed to remove.

package/skills/creating-intent/references/wikilinks.md

@@ -0,0 +1,8 @@
+# Wikilink Conventions
+
+| Syntax | Meaning |
+|--------|---------|
+| `[[ID]]` | Link to intent in same store (e.g., `[[1a1]]`) |
+| `[[ID\|display text]]` | Link with human-readable label |
+| `[[global:ID]]` | Link to intent in `~/.plastic/store/` |
+| `[[project-slug:ID]]` | Link to intent in `~/.plastic/projects/{slug}/store/` |

package/skills/creating-project/SKILL.md

@@ -1,8 +1,8 @@
 ---
-name: plastic:creating-project
+name: plastic-creating-project
 description: >-
   Create a new project from an implementation intent. Sets up project directory,
-  git init, AGENTS.md with founding intent decisions, plastic:install --local,
+  git init, AGENTS.md with founding intent decisions, plastic-install --local,
   tactical mirror, projects.yml registration, and framework scaffolding.
   Use when an implementation intent spawns a project, or manually by user.
 ---
@@ -31,9 +31,9 @@ cd <project_root>/<slug>
 git init
 ```
 
-### 3. Run `plastic:install --local`
+### 3. Run `plastic-install --local`
 
-Invoke `plastic:install --local` in the project directory. This creates:
+Invoke `plastic-install --local` in the project directory. This creates:
 ```
 .plastic/
 ├── store/
@@ -127,7 +127,24 @@ Read `~/.plastic/projects.yml` and add:
 
 For Hub-spawned projects, `parent` references the primary founding intent.
 
-### 7. Mark Global Intent(s) Completed
+### 7. Provision the Project Store
+
+The `provision-project-store` verb is the single source of truth for store
+creation. Run it after the project is registered in step 6 (the provisioner
+requires registration), and before the QMD step:
+
+```bash
+ruby ~/.plastic/scripts/provision-project-store <slug>
+```
+
+This ensures `~/.plastic/projects/<slug>/store/` exists with `.gitkeep`, and
+writes `INDEX.md` and `project.yml` only if missing. It is idempotent, so it is
+safe even when the tactical mirror in step 5 already created the store directory.
+Do not create the store with an inline `mkdir`; the provisioner is the only place
+a store is made. For a project that is already registered but store-less, use the
+`plastic-add-project-store` skill instead.
+
+### 8. Mark Global Intent(s) Completed
 
 For each founding intent:
 
@@ -137,7 +154,7 @@ For each founding intent:
 3. Update `chain` to include `project-<slug>:1`
 4. Move from `## Active` to `## Completed` in `~/.plastic/INDEX.md` (with today's date)
 
-### 8. Framework Scaffolding
+### 9. Framework Scaffolding
 
 If decisions specify a framework, run the appropriate scaffolding command AFTER steps 3-4 (so scaffolding doesn't overwrite Plastic files or AGENTS.md):
 
@@ -150,17 +167,32 @@ If decisions specify a framework, run the appropriate scaffolding command AFTER
 
 After scaffolding, verify AGENTS.md and `.plastic/` still exist. If scaffolding overwrote them, restore.
 
-### 9. Auto-commit Both Stores
+### 10. Auto-commit Both Stores
 
 ```bash
 cd ~/.plastic && git add . && git commit -m "feat: spawn project <slug> from intent <ID>"
 cd <project> && git add . && git commit -m "feat: initialize project from intent <ID>"
 ```
 
-### 10. Announce
+### 11. Register the project store with QMD (optional)
+
+If QMD is installed, register the new project's store as a search collection:
+
+```bash
+ruby ~/.plastic/scripts/qmd-sync register --store ~/.plastic/projects/<slug>/store
+```
+
+`qmd-sync` no-ops when QMD is absent, so run it unconditionally. This adds the
+`plastic-<slug>` collection and indexes it.
+
+### 12. Announce
 
 Log in `## Insights` of each founding intent:
 > "Project `<slug>` created at `<path>`. Tactical mirror: `project-<slug>:1` (autonomous)"
 
 Announce to user:
 > "Project `<slug>` created at `<path>`. AGENTS.md populated with [N] decisions from [founding intent IDs]. Tactical mirror `1` is now the active intent in the project store."
+
+## References
+
+- Read `references/hubs-projects.md` for the full hub/project relationship model, project creation flow, and cross-linking conventions

package/skills/creating-project/references/hubs-projects.md

@@ -0,0 +1,55 @@
+# Hubs and Projects
+
+## Hubs
+
+A Hub is a cloud of intents around related topics. Hubs emerge naturally from
+Folgezettel branching — intents that spawn in the same direction cluster.
+
+- A Hub can spawn a Project. The Hub holds the founding ideas.
+- A single intent can also spawn a Project.
+- Hub-spawned projects revolve around different ideas around related topics.
+- Intent-spawned projects revolve around the single founding intent.
+- A Project is the deliverable outcome of one or more intents.
+
+Hubs are represented as clusters in INDEX.md.
+
+## Projects — Full Detail
+
+A Project is a deliverable grouping of intents. Projects have two stores:
+
+- **Global store** (`~/.plastic/store/`): strategic intents
+- **Project store** (`~/.plastic/projects/{slug}/store/`): tactical intents
+
+`projects.yml` maps project slugs to codebase paths:
+```yaml
+projects:
+  plastic:
+    path: "/path/to/plastic"
+    remote: "git@github.com:org/plastic.git"
+    registered: '2026-05-26'
+    status: active
+```
+
+Config resolution: `~/.plastic/projects/{slug}/config.yml` overrides `~/.plastic/config.yml`.
+
+Cross-linking: project intents reference global intents via `[[global:ID]]`. Global intents reference project intents via `[[project-slug:ID]]`.
+
+## Privacy and Collaboration
+
+**Plastic is personal.** All intent data lives under `~/.plastic/` — one location,
+one git repo, never pushed. Each person has their own intent store.
+
+Collaboration happens through pull requests and project conventions, not shared intents.
+When an intent delivers something that changes how a project works, the decision gets
+written into the project's shared files (README, docs, config). The intents themselves
+are private working memory.
+
+## Project Creation Flow
+
+When an implementation intent spawns a project:
+1. Determine project path from config `project_roots` or intent context
+2. `gh repo create --private` (agent-created repos are always private by default)
+3. Set up project directory, git init, AGENTS.md with founding intent decisions
+4. Register in `projects.yml`
+5. Create tactical mirror in project store
+6. The global intent completes; the tactical mirror becomes the active intent