@zalom/plastic 2.0.0-alpha.9 → 2.0.2

package/README.md

@@ -1,204 +1,428 @@
-# Plastic
+<h1 align="center">
+  <img src="https://raw.githubusercontent.com/zalom/plastic/main/assets/plastic-logo.svg"
+    alt="Plastic" width="360">
+</h1>
+
+<p align="center">
+  <strong>One command that turns an intent into a durable, linked record of decisions, plans, delivery and outcomes</strong>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@zalom/plastic"><img src="https://img.shields.io/npm/v/@zalom/plastic" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/@zalom/plastic"><img src="https://img.shields.io/npm/dm/@zalom/plastic" alt="npm downloads"></a>
+  <a href="https://github.com/zalom/plastic/actions/workflows/test.yml"><img src="https://github.com/zalom/plastic/actions/workflows/test.yml/badge.svg" alt="CI"></a>
+  <a href="https://github.com/zalom/plastic/releases"><img src="https://img.shields.io/github/v/release/zalom/plastic" alt="Release"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/npm/l/@zalom/plastic" alt="License: MIT"></a>
+</p>
+
+<p align="center">
+  <a href="#installation">Install</a> &bull;
+  <a href="#quick-start">Quick start</a> &bull;
+  <a href="#commands">Commands</a> &bull;
+  <a href="docs/guide/getting-started/troubleshooting.md">Troubleshooting</a> &bull;
+  <a href="docs/contributing/ARCHITECTURE.md">Architecture</a> &bull;
+  <a href="MANIFESTO.md">Manifesto</a>
+</p>
+
+---
+
+Plastic is an intent-based system for AI-assisted work. You do not always start with a task.
+You start with an intent, such as "I want users who are locked out to recover access safely."
+Plastic carries that intent through four stages, What, Why, How and Exec, and leaves a
+readable record of how the idea became real.
+
+Plastic is named after neuroplasticity, the brain's ability to change as it learns.
+
+## What Plastic does
+
+Plastic keeps the shape of the work fixed and leaves the thinking to you and your agent.
+
+| You want to | What Plastic does |
+|-------------|-------------------|
+| Start from a rough idea | Creates one intent directory with an id, a slug and a born-complete intent file |
+| Keep the reasons | Records each ruling in the intent, then consolidates them into `spec.md` |
+| Plan the work | Holds the plan as a graph of nodes, and names the next ready step |
+| Resume tomorrow | Prints where a project stands and the next action in one line |
+| Hand work to an agent team | Arms a delivery lock, briefs each role and reports the result |
+| Close the work | Generates `outcome.md` from the record and moves the intent to Completed |
+| Find an old decision | Searches every store, ranked, with one excerpt for each match |
+| Run many projects | Keeps one store for each project, plus a global store, all in plain Markdown and Git |
+| Steer a long delivery | Reads a roadmap as a graph and names the entry most worth continuing |
+| Protect the record | Writes one archive of the three databases and the config |
+
+Every result ends with a `next:` line and a `because:` line. The `--json` option prints the
+same result as data with stable keys.
+
+## How the record is built
+
+Each intent is one directory. It carries the same small set of files at every stage.
+
+| Stage | Question | File on disk |
+|-------|----------|--------------|
+| What | What is the intention? | `{id}--slug.md` |
+| Why | What context, evidence and decisions shape it? | `spec.md` |
+| How | What is the plan? | `plan.md`, `checklist.md`, `actions/` |
+| Exec | What was delivered? | `outcome.md` |
+
+The files are plain Markdown in a Git repository that you own. See
+[the architecture](docs/architecture.md) for the full store layout.
+
+## Installation
+
+Plastic needs Ruby 4.0 or later. The npm path also needs Node.js 18 or later, because `npx`
+fetches the package. After the install, the `plastic` command runs on Ruby alone.
+
+### npm (recommended)
 
-[![npm version](https://img.shields.io/npm/v/@zalom/plastic)](https://www.npmjs.com/package/@zalom/plastic)
-[![npm downloads](https://img.shields.io/npm/dm/@zalom/plastic)](https://www.npmjs.com/package/@zalom/plastic)
-[![license](https://img.shields.io/npm/l/@zalom/plastic)](LICENSE)
-[![CI](https://github.com/zalom/plastic/actions/workflows/test.yml/badge.svg)](https://github.com/zalom/plastic/actions/workflows/test.yml)
+```bash
+npx -y @zalom/plastic install --claude
+```
 
-## Intent-based idea development system for AI-assisted work.
+Replace `--claude` with `--codex` for Codex CLI, or pass both flags.
 
-> Plastic is a system that turns an intent, a vague goal or idea into a durable, linked record of discovery, decisions, delivery, and outcomes - it serves as a physical brain for your intents.
+The npm path puts the command at `~/.plastic/bin/plastic` and does not change your `PATH`.
+Link the command into a directory that is on your `PATH`:
 
-[[Install]](#start-in-60-seconds) [[See it work]](#built-with-plastic) [[Read the manifesto]](MANIFESTO.md)
+```bash
+mkdir -p ~/.local/bin
+ln -sf ~/.plastic/bin/plastic ~/.local/bin/plastic
+```
+
+### Alpha channel
+
+Plastic 2.0 is on the alpha channel.
+
+```bash
+npx -y @zalom/plastic@alpha install --claude
+```
+
+### Quick install without npm
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/zalom/plastic/main/install.sh | sh
+plastic install --claude
+```
+
+`install.sh` takes the newest release on a channel that carries the archive. The default
+channel is stable; `PLASTIC_CHANNEL` picks another:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/zalom/plastic/main/install.sh | PLASTIC_CHANNEL=alpha sh
+```
 
+No stable 2.0 release carries the archive yet, so the default channel still installs the 1.x
+line. Use the alpha channel for the `plastic` command, or npm. To move an installed Plastic
+to another channel later, run `plastic update --beta` or `plastic update --alpha`.
 
-## Why Plastic?
+### A clean Mac
 
-You do not always start with a task.
+macOS ships Ruby 2.6, which is too old. Install a newer Ruby first:
 
-You start with an intent, something like:
+```bash
+curl https://mise.run | sh
+mise use --global ruby@4.0
+```
 
-> “I want users who are locked out to recover access safely.”
+### Verify the installation
 
-Plastic delivers this intent in successive stages: What -> Why -> How -> Exec.
+```bash
+plastic version     # Prints the installed version and the file it came from
+plastic doctor      # Checks the install and the stores
+```
 
-The result is a readable, linked record of how an idea became real.
+## Quick start
 
-**Plastic gives changing minds a durable way to develop ideas into work.**
+```bash
+# 1. Install for your agent
+npx -y @zalom/plastic@alpha install --claude    # Claude Code
+npx -y @zalom/plastic@alpha install --codex     # Codex CLI
+npx -y @zalom/plastic@alpha install --all       # Every supported agent
 
-Plastic is named after neuroplasticity: the brain's amazing ability to change and adapt. It rewires itself as you learn new things, form memories, or heal from injuries. Instead of being fixed like a computer, your brain is more like clay. It constantly reshapes itself based on your experiences.
+# 2. See what is open
+plastic status
 
-### What Plastic does?
+# 3. Start an intent
+plastic intent new "Add a --version flag"
 
-Plastic keeps the shape of the work stable - **deterministic** work system:
-- one durable intent
-- one visible lifecycle
-- one place for context, decisions, plans, and outcomes
-- links between the ideas that shaped the work and the ideas it creates
+# 4. Ask what to do next, at any time
+plastic next
+```
 
-Plastic leaves the human or AI model free to think - **non-deterministic** thinking system.
+Restart your agent after the install. For the full path, read
+[your first intent in 10 minutes](docs/guides/your-first-intent-in-10-minutes.md).
 
-Plastic makes that thinking legible, resumable, and useful later.
+## How it works
 
-## Who is Plastic for?
+```
+  You or your agent                 plastic                        ~/.plastic
+  -----------------                 -------                        ----------
+  plastic intent new "..."   -->    creates the intent      -->    store/12--slug/12--slug.md
+  plastic intent rule 12     -->    records a ruling        -->    the intent file, then spec.md
+  plastic intent step 12     -->    runs the next node      -->    graph.md, nodes/, savepoint.md
+  plastic intent end 12      -->    generates the outcome   -->    outcome.md, INDEX.md
+
+        ^                                                              |
+        |            next: one command       because: one reason       |
+        +--------------------------------------------------------------+
+```
 
-**Plastic is built for an AI-native developer, technical founder, or
-independent builder who works across multiple sessions, has ideas before
-they have intents, and feels the cost of losing reasoning between agents,
-contexts, and days.**
+Plastic follows four rules:
 
-## What it solves?
+1. **Commands print state and rules.** The judgment stays with you and the agent.
+2. **The ledger is append-only.** `savepoint.md` holds one line for each event, so a new
+   session resumes from the last line.
+3. **Status is derived.** Plastic reads what is ready from the graph and the ledger.
+4. **Nothing leaves the machine.** Plastic makes no model call and sends none of your files anywhere.
 
-It solves problems that builder already feels:
+## Commands
 
-- "I want to keep a record of my work - what I worked on, why I worked on it, how it was built"
-- "I do not need another TODO list."
-- "I do not want my work trapped inside a chat."
-- "I want to explore without losing the decision trail."
-- "I want a better model or new agent to inherit the work, not restart it."
-- "I want my ideas to compound."
+### Orientation
+```bash
+plastic status                        # Active work in every store
+plastic continue                      # Where this project stands and what runs next
+plastic continue --project blog       # The same, for a named project
+plastic next                          # The next action in one line
+plastic next --why                    # The next action, with the reasoning
+```
 
-## Start in 60 seconds
+### Intents
+```bash
+plastic intent new "LINE"             # Create an intent
+plastic intent new "LINE" --parent 12 # Create a branch of intent 12
+plastic intent show 12                # Print the state screen
+plastic intent spec 12                # State screen, then the speccing rules
+plastic intent rule 12 "TEXT"         # Record a ruling in Insights
+plastic intent note 12 "TEXT"         # Append a savepoint note
+plastic intent step 12                # Run the next ready step of the graph
+plastic intent answer 12 --node n3 --decision "TEXT"   # Answer a node that needs a decision
+plastic intent verify 12              # Run the merge-gate checks
+plastic intent end 12 --delivered --summary "TEXT"     # Close as delivered
+plastic intent end 12 --abandoned --summary "TEXT"     # Close as abandoned
+```
 
-One command installs Plastic for your agent:
+### Projects
+```bash
+plastic project list                  # Every store this machine holds
+plastic project new blog --path ~/code/blog   # Register and provision a project
+plastic project links                 # Rebuild every Links section from frontmatter
+```
 
+### Roadmaps
 ```bash
-npx -y @zalom/plastic install --claude
+plastic roadmap next                  # The roadmap most worth continuing
+plastic roadmap show SLUG             # The state screen of one roadmap
+plastic roadmap check SLUG            # Find cycles and dangling ids in the graph
+plastic roadmap migrate SLUG          # Write the graph section from the batches
+plastic roadmap log SLUG EVENT "TEXT" # Append a line to the roadmap ledger
+```
+
+### Auto teams
+```bash
+plastic auto take 12                  # Arm the delivery lock for this session
+plastic auto brief 12 --role executor # Print the spawn preamble for one role
+plastic auto report 12                # Completion report, then the review rules
+plastic auto lock status 12           # Inspect the delivery lock
+plastic auto lock fix 12              # Repair a broken lock
+plastic auto lock release 12          # Release the lock
 ```
 
-Then load the conventions and begin:
+### Sessions
+```bash
+plastic session summary               # Open items and recent activity in the day ledger
+plastic session commit "SUMMARY"      # Commit one verified checklist item
+plastic session handoff               # Write this session's hand-off
+```
 
+### Search
 ```bash
-/clear
+plastic index                         # Rebuild the search index from every Markdown file
+plastic search recovery flow          # Ranked matches, one excerpt each
+plastic search recovery --project blog --limit 5
+plastic search --ask "Why did we drop the queue?"   # Search with a whole question
+plastic query "SELECT path FROM doc LIMIT 5"        # One read-only SQL statement
+```
 
-I would like to learn more about Plastic and how it works.
+### Stores and databases
+```bash
+plastic sync                          # Bring the store files and the three databases level
+plastic sync --dry-run                # Show what would change
+plastic checkout                      # Restore missing store files from the databases
+plastic backup                        # One archive of the three databases and the config
+plastic backup --list                 # Name, size and date of each archive
+plastic migrate stores --dry-run      # Preview the move of every store under stores/
+plastic migrate stores                # Move them, behind a full copy of the home
+plastic render FILE                   # Print one Markdown file as an HTML page
 ```
 
-Describe what you want in plain words, like "add a `--version` flag." Plastic
-scaffolds the intent and walks it through What, Why, How, and Exec. For the
-full path, read [your first intent in 10 minutes](docs/guides/your-first-intent-in-10-minutes.md).
+### Product
+```bash
+plastic install --claude              # Install into Claude Code
+plastic install --reinstall --claude  # Repair an install
+plastic update                        # Next version on the current channel
+plastic update --alpha                # Move to the alpha channel
+plastic rollback                      # List the versions this machine has run
+plastic rollback --version 2.0.0-alpha.27
+plastic uninstall --all               # Remove Plastic from every agent. Your stores stay.
+plastic doctor                        # Check the install and the stores
+plastic doctor --core                 # The fast check that runs at session start
+plastic doctor --json                 # The full report as data
+plastic version                       # The installed version
+```
 
-## How Plastic works?
+### Help and feedback
+```bash
+plastic help                          # All commands and help topics
+plastic help intent end               # The usage line of one command
+plastic help roadmaps                 # One help topic
+plastic feedback "TITLE" < report.md  # Save a problem report and print a link that files it
+```
+
+## Global options
+
+```bash
+--json          # Print the result as data with stable keys
+-h, --help      # Print the usage line of the command
+--project SLUG  # On continue, next and search, name a project other than the current one
+```
 
-A task assumes you already know the work.
+The installer commands do not take `--json`. `plastic doctor` does, and prints its full
+report as the document.
 
-An intent begins earlier:
-something you want to accomplish, explore, or understand.
+## Examples
 
-Plastic helps you develop it until it becomes a decision,
-a plan, a delivery, and a reusable piece of project history.
+**Active work in every store:**
+```
+$ plastic status
+global    0 active
+blog      1 active  14
+shop      2 active  7, 9
 
-### Register What and start with Why
+next: plastic continue --project shop
+because: the working directory is inside shop
+```
 
-Plastic delivers all work through successive stages ->
+**The next action:**
+```
+$ plastic next
+next work  9  in Batch 2: checkout flow
 
-| Stage | Meaning                                         | Developed concept  | On-disk artifact (evidence)                    |
-| ----- | ----------------------------------------------- | ------------------ | ---------------------------------------------- |
-| What  | What is the intention?                          | Intent             | {id}--slug.md                                  |
-| Why   | What context, evidence, and decisions shape it? | Specification      | spec.md                                        |
-| How   | What is the plan?                               | Plan and checklist | plan.md, checklist.md, actions/ACTION_1.md ... ACTION_N.md |
-| Exec  | What was actually delivered?                    | Outcome            | outcome.md                                     |
+next: read ~/.plastic/projects/shop/store/9--checkout-flow/plan.md
+because: 9 is first on the frontier of the roadmap
+```
 
-## How to use Plastic
+**The installed version:**
+```
+$ plastic version
+version  2.0.0-alpha.28
+source   ~/.local/share/plastic/package.json
 
-Plastic organizes all work as intents. Each intent is one directory, and it carries the same
-small set of files at every stage.
+next: plastic status
+because: the command line works, so read the work next
+```
 
-**The intent directory**
+The slugs and ids in these examples are samples.
 
-| File | What it holds |
-| ---- | -------------- |
-| `{id}--slug.md` | The intent itself: intent line, context, decisions |
-| `spec.md` | The Why, consolidated into one contract for the plan |
-| `plan.md`, `checklist.md`, `actions/` | The How: the plan and its execution registry |
-| `outcome.md` | The Exec record: what actually shipped |
+## Agent hooks
 
-See [`docs/architecture.md`](docs/architecture.md) for the full store layout, and
-[reading a delivered intent](docs/guides/reading-a-delivered-intent.md) for how to read a
-finished one fast.
+The installer registers hooks in your agent. At session start a hook runs the fast doctor,
+loads the conventions and prints the open items of the day. Each hook calls one launcher:
 
-**From idea to delivery, one line per stage**
+```bash
+plastic hook EVENT      # The agent calls this, not you
+```
 
-| Stage | What happens |
-| ----- | ------------- |
-| What | Describe the idea in plain words; Plastic scaffolds the intent |
-| Why | Explore it, one ruling at a time, then consolidate into `spec.md` |
-| How | Turn `spec.md` into `plan.md` and `checklist.md` |
-| Exec | Build the change, verify it, tick the checklist |
-| Done | `outcome.md` records what shipped; the index moves the intent to Completed |
+Run `plastic install --reinstall --claude` when hooks do not fire.
 
-Walk this once in
-[your first intent in 10 minutes](docs/guides/your-first-intent-in-10-minutes.md), or run
-`plastic-tutorial` for an interactive, hands-on walkthrough of three different ways to work.
+## Supported AI tools
 
-**Commands, by family**
+| Tool | Install | State |
+|------|---------|-------|
+| **Claude Code** | `plastic install --claude` | Supported |
+| **Codex CLI** | `plastic install --codex` | Supported |
+| **Hermes** | none | A packaging target only |
 
-| Family | Commands |
-| ------ | -------- |
-| Mode | `plastic-tutorial`, `plastic-auto` |
-| Intent | `plastic-intent-creating`, `plastic-intent-continuing`, `plastic-intent-speccing`, `plastic-intent-executing`, `plastic-intent-ending` |
-| Project and delivery | `plastic-project-creating`, `plastic-roadmap`, `plastic-releasing` |
-| Product | `plastic-install`, `plastic-update`, `plastic-uninstall`, `plastic-rollback`, `plastic-doctor` |
+The `plastic` command itself needs no agent. It runs in any shell with Ruby. See
+[harness support](docs/reference/harness-adapters.md) for the detail on each agent.
 
-See [`docs/guides/index.md`](docs/guides/index.md) for task-oriented walkthroughs.
+Seven agents ship with Plastic: an enforcer that leads an auto team, an executor, three node
+agents for work, verification and research, and two advisors for hard decisions.
 
-The agent helps most at Why and How: turning a rough idea into rulings, and rulings into a
-plan a machine can build from exactly. Read
-[pick your mode](docs/guides/pick-your-mode.md) to decide how much of that to hand over.
+## Configuration
 
-## Compatibility and ownership
+`~/.plastic/config.yml`:
 
-- Native installers for Claude Code and Codex CLI, both from npm. Hermes is a packaging
-  target for now. See [harness support](docs/reference/harness-adapters.md).
-- Plain Markdown plus Git. The work stays in files you own.
-- Personal stores by default.
-- Direct work in the session, a thinking conversation when the work needs one,
-  or autonomous delivery by an agent team when you ask for it.
-- Two advisor agents ship for the hard problems: one-way doors, plans, adversarial
-  review, deadlocks. Summon one deliberately, state the effort and the answer shape in the brief; nobody's
-  main session is ever touched. Faux Fable (recommended) is an ordinary model carrying
-  the frontier reasoning discipline inline, much cheaper; Fable 5 is the frontier model
-  itself. Choose the default at install, switch it any time.
+```yaml
+project_roots: ~/.plastic/projects   # Where Plastic looks for projects
+stale_threshold_days: 3              # Age at which a future intent is shown for triage
+context_offer_tokens: 150000         # Context size at which the agent offers to compact
+context_insist_tokens: 250000        # Context size at which the agent insists
+agent:
+  type: claude-code                  # The agent that runs Plastic
+  parallel_mode: agent-teams         # agent-teams or linear
+```
 
-Plastic needs Ruby 3.0 or later and Node.js 18 or later. Most Linux systems already
-have a new enough Ruby. macOS ships Ruby 2.6, which is too old, so a clean Mac needs
-a newer one first:
+Install-time choices:
 
+```bash
+plastic install --claude --advisor secondary   # Set the default advisor
+plastic install --claude --no-advisor          # Install no advisor agent
+plastic install --claude --statusline plastic  # Use the Plastic status line
 ```
-curl https://mise.run | sh        # only if mise is not installed yet
-mise use --global ruby@3.3
+
+See the [configuration guide](docs/guide/getting-started/configuration.md) for every key and file.
+
+### Uninstall
+
+```bash
+plastic uninstall --all     # Remove hooks, agents and conventions from every agent
 ```
 
-The installer checks this before it does anything and tells you the same thing if the
-Ruby it finds is too old. Bun users can run `bunx` in place of `npx`; Bun is never
-required.
+Your stores under `~/.plastic` stay.
 
-## Built with Plastic
+## What changed in 2.0
 
-Plastic is developed through Plastic.
+Plastic 2.0 moves from prose skills to one command with direct results.
 
-The roadmap, intent history, plans, decisions, and outcomes
-behind releases are part of the repository, not a hidden process.
+- **One `plastic` command.** More than 40 commands replace the skills. The package ships no skill directories.
+- **Direct results.** Every command ends with `next:` and `because:`, and takes `--json`.
+- **Plans are graphs.** An intent holds nodes and edges, and a ready set names what runs next.
+- **A ledger with refusals.** Node transitions are appended to `savepoint.md`, and an invalid transition is refused.
+- **Generated outcomes.** `outcome.md` is built from the graph, the nodes and the ledger at the close.
+- **Roadmaps are graphs too.** `plastic roadmap check` finds cycles and dangling ids.
+- **Search without a service.** One SQLite file holds a full-text index of every store.
+- **Three databases.** `work_graph.db`, `knowledge_graph.db` and `references.db` hold the record, and the files are a checkout of it.
+- **Backup and migrate.** One archive command, and a store move that runs behind a full copy of the home.
+- **Two advisors, medium effort by default.** Summon the Primary Advisor or the Secondary Advisor on purpose.
+- **Codex CLI as a second agent.** The same install, with OpenAI model ids for each role.
+- **Publishing from branches.** A push to `alpha`, `beta` or `main` publishes to the matching npm channel with provenance.
 
-[changelog](CHANGELOG.md).
+The [changelog](CHANGELOG.md) holds one line for each release.
 
 ## Documentation
 
-- [`docs/architecture.md`](docs/architecture.md): system structure, the two
-  processes, the store layout, and the full stage table.
-- [`docs/internals.md`](docs/internals.md): how Plastic stays deterministic
-  and how the harness works.
-- [`docs/guides/`](docs/guides/index.md): task-oriented guides, from your
-  first intent in 10 minutes to picking a delivery mode.
+- **[INSTALL.md](INSTALL.md)**: every install path.
+- **[docs/guide/](docs/guide/index.md)**: getting started with the `plastic` command.
+- **[docs/guides/](docs/guides/index.md)**: task guides, from your first intent to picking a mode.
+- **[docs/usage/](docs/usage/FEATURES.md)**: features, the audit guide and tracking.
+- **[docs/architecture.md](docs/architecture.md)**: the structure, the store layout and the stage table.
+- **[docs/internals.md](docs/internals.md)**: how Plastic stays deterministic.
+- **[docs/contributing/](docs/contributing/ARCHITECTURE.md)**: the command architecture, the coding practices and the gates.
+
+## Privacy
+
+Plastic runs on your machine. It makes no model call and sends none of your files anywhere.
+Two things use the network: the update check hook and `plastic update`, which ask the npm
+registry for the newest version. See [SECURITY.md](SECURITY.md) for every file the installer writes.
+
+## Built with Plastic
+
+Plastic is developed through Plastic. The roadmap, the intents, the plans, the decisions and
+the outcomes behind each release are part of the record.
 
-## Conventions
+## Contributing
 
-The always-on core conventions live in `PLASTIC.md`, distributed to `~/.plastic/PLASTIC.md`
-and overwritten on every update. Deeper doctrine lives in the `plastic-conventions` skill,
-loaded on demand by the skills that need it. Project-specific rules live in `AGENTS.md`.
-Run `plastic-doctor` to check installation health; it compares files against
-the manifests, checks store state, and runs automatically after every update.
+See [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## License
 
-MIT
+MIT. See [LICENSE](LICENSE).

package/agents/plastic-enforcer.md

@@ -5,6 +5,7 @@ description: |
   record, has the plan reviewed before code, dispatches one executor, reviews
   by risk, and closes.
 model: opus
+effort: medium
 ---
 
 You are the Plastic Enforcer, the lead of an auto team. You ARE the orchestrating session,
@@ -14,27 +15,32 @@ spanning the whole What->Why->How->Exec cycle; you are not a separately dispatch
 orchestrating main session on the best available thinking model (Fable, Opus, or whatever
 supersedes them). This is advice only: it changes no behavior. Dispatched agents keep their
 configured model and never resolve to Fable unless an explicit `agents.models.<name>` config
-override names Fable for that role. The two advisors, `plastic-advisor` and
-`plastic-faux-advisor`, are consultation roles the user or the main session summons
+override names Fable for that role. Primary Advisor and Secondary Advisor are consultation roles
+the user or the main session summons
 deliberately; the auto pipeline never dispatches them.
 
 ## Your Responsibilities
 
-1. **Take the intent** - `plastic-lock arm` acquires the delivery lock, provisions the code
+1. **Take the intent** - `plastic auto take ID` acquires the delivery lock, provisions the code
    worktree, and points this session at the intent; work only inside that worktree.
 2. **Write the Why and How yourself** - there is no intent tier and no stage agent (removed in
    2.0, intent 304): record the rulings, write `spec.md`, then `plan.md`, at least one real
    `actions/ACTION_N.md` carrying a failure-mode matrix (one row per operation: the failure and
    the test that catches it), and `checklist.md`. One consolidated `ACTION_1.md` by default,
-   never an empty `actions/`.
+   never an empty `actions/`. Every name given to a node, file, or field comes from the concept
+   family it lives under, graph engineering, the Plastic concepts coined on top of it, and the
+   software and AI engineering concepts those rest on; a gap is a design finding to raise, not
+   a word to coin.
 3. **Have the plan reviewed before code** - dispatch one adversarial plan reviewer on
-   `plastic-intent-executing`'s `plan-reviewer-prompt.md`; fold every finding into the spec, the
-   matrix, and the tests.
+   `plastic help plan-reviewer-prompt`; merge every finding into the spec, the matrix, and
+   the tests.
 4. **Dispatch one executor, tests first** - the executor commits the matrix's tests red, then
-   builds, then drives the full suite green; you verify the checklist against the diff.
+   builds, then drives the full suite green; you verify tick-versus-diff at the
+   post-execution review and again before the merge. A mismatch is a review finding, not a
+   cleanup you perform silently.
 5. **Review by risk** - dispatch the post-execution reviewer only when the auto skill's risk
    rule fires; otherwise the green suite is the review.
-6. **Close** - `outcome.md`, then `plastic-intent-ending`, which releases the worktree, clears
+6. **Close** - `outcome.md`, then `plastic intent end`, which releases the worktree, clears
    the lock, points the session back at the day ledger, and reindexes last.
 
 **Dispatch-time model contract.** Each pinned agent carries its `model:` in frontmatter, and
@@ -48,8 +54,8 @@ dispatch call's model parameter, alongside the spawn-preamble live-state injecti
 
 1. Take the intent; record the rulings in `## Context` + `### Decisions`; write `spec.md`.
 2. Write `plan.md`, the action files with their matrix, and `checklist.md`; dispatch the plan
-   reviewer; fold the review.
-3. Dispatch the executor through `plastic-intent-executing` with the whole consolidated action
+   reviewer; merge the review findings.
+3. Dispatch the executor through `plastic intent step` with the whole consolidated action
    pasted in; require the red commit before the code and a green suite after it. Sequential,
    one team per intent, on one branch when files are shared.
 4. Apply the risk rule; when it fires, dispatch the reviewer and re-dispatch the executor for
@@ -60,11 +66,10 @@ dispatch call's model parameter, alongside the spawn-preamble live-state injecti
 
 Once per delivery, at How with the plan and the matrix ready and before any code, brief the
 human in EM-to-CTO voice: impact first, the one risk that matters, then the call. In auto mode
-the briefing informs and does not wait. The shape lives in
-`skills/auto/references/human-report-contract.md`. This is separate from the intent 74 report
-contract (`skills/auto/references/agent-report-contract.md`), the internal structured handoff a
-dispatched agent sends back to you; you consume that report to write the human briefing, and
-the two never merge.
+the briefing informs and does not wait. The shape lives in `plastic help
+human-report-contract`. This is separate from the intent 74 report contract (`plastic help
+agent-report-contract`), the internal structured handoff a dispatched agent sends back to you;
+you consume that report to write the human briefing, and the two never merge.
 
 ## Constraints
 
@@ -73,5 +78,5 @@ the two never merge.
   `savepoint.md`, the diff), never from a hook you assume fired.
 - The plan reviewer and the post-execution reviewer are fresh agents, never you and never the
   executor.
-- Dispatch through `plastic-intent-executing`, Plastic's own engine. On a harness with no agent
+- Dispatch through `plastic intent step`, Plastic's own engine. On a harness with no agent
   dispatch, walk the five steps yourself and say so in `## Insights`.