@zalom/plastic 2.0.0-alpha.27 → 2.0.0-alpha.29

package/README.md

@@ -1,204 +1,416 @@
-# Plastic
+<h1 align="center">PLASTIC</h1>
 
-[![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)
+<p align="center">
+  <strong>One command that turns an intent into a durable, linked record of decisions, plans, delivery and outcomes</strong>
+</p>
 
-## Intent-based idea development system for AI-assisted work.
+<p align="center">
+  <a href="https://www.npmjs.com/package/@zalom/plastic"><img src="https://img.shields.io/npm/v/@zalom/plastic/alpha" 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?include_prereleases" alt="Release"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/npm/l/@zalom/plastic" alt="License: MIT"></a>
+</p>
 
-> 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.
+<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>
 
-[[Install]](#start-in-60-seconds) [[See it work]](#built-with-plastic) [[Read the manifesto]](MANIFESTO.md)
+---
 
+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.
 
-## Why Plastic?
+Plastic is named after neuroplasticity, the brain's ability to change as it learns.
 
-You do not always start with a task.
+## What Plastic does
 
-You start with an intent, something like:
+Plastic keeps the shape of the work fixed and leaves the thinking to you and your agent.
 
-> “I want users who are locked out to recover access safely.”
+| 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 |
 
-Plastic delivers this intent in successive stages: What -> Why -> How -> Exec.
+Every result ends with a `next:` line and a `because:` line. The `--json` option prints the
+same result as data with stable keys.
 
-The result is a readable, linked record of how an idea became real.
+## How the record is built
 
-**Plastic gives changing minds a durable way to develop ideas into work.**
+Each intent is one directory. It carries the same small set of files at every stage.
 
-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.
+| 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` |
 
-### What Plastic does?
+The files are plain Markdown in a Git repository that you own. See
+[the architecture](docs/architecture.md) for the full store layout.
 
-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
+## Installation
 
-Plastic leaves the human or AI model free to think - **non-deterministic** thinking system.
+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.
 
-Plastic makes that thinking legible, resumable, and useful later.
+### npm (recommended)
 
-## Who is Plastic for?
+```bash
+npx -y @zalom/plastic install --claude
+```
 
-**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.**
+Replace `--claude` with `--codex` for Codex CLI, or pass both flags.
 
-## What it solves?
+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`:
 
-It solves problems that builder already feels:
+```bash
+mkdir -p ~/.local/bin
+ln -sf ~/.plastic/bin/plastic ~/.local/bin/plastic
+```
 
-- "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."
+### Alpha channel
 
-## Start in 60 seconds
+Plastic 2.0 is on the alpha channel.
 
-One command installs Plastic for your agent:
+```bash
+npx -y @zalom/plastic@alpha install --claude
+```
+
+### Quick install without npm
 
 ```bash
-npx -y @zalom/plastic install --claude
+curl -fsSL https://raw.githubusercontent.com/zalom/plastic/main/install.sh | sh
+plastic install --claude
 ```
 
-Then load the conventions and begin:
+`install.sh` always installs the latest stable release. To move an installed Plastic to
+another channel, run `plastic update --beta` or `plastic update --alpha`. No stable release
+carries the archive yet. Until the first one does, the script reports that and exits, and
+npm is the way to install.
+
+### A clean Mac
+
+macOS ships Ruby 2.6, which is too old. Install a newer Ruby first:
 
 ```bash
-/clear
+curl https://mise.run | sh
+mise use --global ruby@4.0
+```
+
+### Verify the installation
 
-I would like to learn more about Plastic and how it works.
+```bash
+plastic version     # Prints the installed version and the file it came from
+plastic doctor      # Checks the install and the stores
 ```
 
-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).
+## Quick start
 
-## How Plastic works?
+```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
 
-A task assumes you already know the work.
+# 2. See what is open
+plastic status
 
-An intent begins earlier:
-something you want to accomplish, explore, or understand.
+# 3. Start an intent
+plastic intent new "Add a --version flag"
 
-Plastic helps you develop it until it becomes a decision,
-a plan, a delivery, and a reusable piece of project history.
+# 4. Ask what to do next, at any time
+plastic next
+```
 
-### Register What and start with Why
+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 delivers all work through successive stages ->
+## How it works
 
-| 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                                     |
+```
+  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       |
+        +--------------------------------------------------------------+
+```
 
-## How to use Plastic
+Plastic follows four rules:
 
-Plastic organizes all work as intents. Each intent is one directory, and it carries the same
-small set of files at every stage.
+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.
 
-**The intent directory**
+## Commands
 
-| 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 |
+### 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
+```
 
-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.
+### 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
+```
 
-**From idea to delivery, one line per stage**
+### 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
+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 log SLUG EVENT "TEXT" # Append a line to the roadmap ledger
+```
 
-| 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 |
+### 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
+```
 
-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.
+### 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
+```
 
-**Commands, by family**
+### Search
+```bash
+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
+```
 
-| 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` |
+### 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
+```
 
-See [`docs/guides/index.md`](docs/guides/index.md) for task-oriented walkthroughs.
+### 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 version                       # The installed version
+```
 
-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.
+### 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
+```
 
-## Compatibility and ownership
+## Global options
 
-- 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. Primary Advisor uses Fable at medium effort for normal
-  consultation. Secondary Advisor uses Fable at high effort for explicit escalation.
-  Choose the default at install, and switch it any time.
+```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
+```
 
-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:
+The installer commands do not take `--json`.
 
+## Examples
+
+**Active work in every store:**
 ```
-curl https://mise.run | sh        # only if mise is not installed yet
-mise use --global ruby@3.3
+$ plastic status
+global    0 active
+blog      1 active  14
+shop      2 active  7, 9
+
+next: plastic continue --project shop
+because: the working directory is inside shop
 ```
 
-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.
+**The next action:**
+```
+$ plastic next
+next work  9  in Batch 2: checkout flow
 
-## Built with Plastic
+next: read ~/.plastic/projects/shop/store/9--checkout-flow/plan.md
+because: 9 is first on the frontier of the roadmap
+```
+
+**The installed version:**
+```
+$ plastic version
+version  2.0.0-alpha.28
+source   ~/.local/share/plastic/package.json
+
+next: plastic status
+because: the command line works, so read the work next
+```
+
+The slugs and ids in these examples are samples.
+
+## Agent hooks
+
+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:
+
+```bash
+plastic hook EVENT      # The agent calls this, not you
+```
+
+Run `plastic install --reinstall --claude` when hooks do not fire.
+
+## Supported AI tools
+
+| Tool | Install | State |
+|------|---------|-------|
+| **Claude Code** | `plastic install --claude` | Supported |
+| **Codex CLI** | `plastic install --codex` | Supported |
+| **Hermes** | none | A packaging target only |
+
+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.
+
+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.
 
-Plastic is developed through Plastic.
+## Configuration
 
-The roadmap, intent history, plans, decisions, and outcomes
-behind releases are part of the repository, not a hidden process.
+`~/.plastic/config.yml`:
 
-[changelog](CHANGELOG.md).
+```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
+```
+
+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
+```
+
+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
+```
+
+Your stores under `~/.plastic` stay.
+
+## What changed in 2.0
+
+Plastic 2.0 moves from prose skills to one command with direct results.
+
+- **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.
+
+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

@@ -32,15 +32,15 @@ deliberately; the auto pipeline never dispatches them.
    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`; merge 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 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
@@ -55,7 +55,7 @@ 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; merge the review findings.
-3. Dispatch the executor through `plastic-intent-executing` with the whole consolidated action
+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
@@ -66,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
 
@@ -79,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`.

package/agents/plastic-executor.md

@@ -48,7 +48,7 @@ valid lifecycle artifacts. Honor it as your live state; do not re-derive or cont
 ## Completion Report
 
 END your turn with a structured completion report as your final message, per the spawn
-preamble's `REPORT_CONTRACT` and `skills/auto/references/agent-report-contract.md`. Do not
+preamble's `REPORT_CONTRACT` and `plastic help agent-report-contract`. Do not
 finish silently. Carry the common envelope (role, intent id, stage, status, artifacts written,
 verification, checklist deltas, deviations, blockers, insights) plus the executor payload:
 

package/bin/crap

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../tools/crap"
+
+exit Crap::CLI.new(ARGV, root: Dir.pwd).run