intentdriven · REPPL · Sep 29, 2026 · Sep 28, 2026 · Sep 28, 2026 · Sep 28, 2026
diff --git a/.abcd/development/brief/01-product/01-press-release.md b/.abcd/development/brief/01-product/01-press-release.md
@@ -2,7 +2,7 @@
 
 ## Press Release
 
-> **abcd helps a product thinker realise an intent as a high-fidelity prototype or demonstrator — carrying the why from idea to shipped reality.** State what should exist, why, for whom, and what good looks like, as a press-release intent (`/abcd:intent "<text>"`); abcd holds that why through planning (`/abcd:intent plan`), the readiness gate (`/abcd:intent ready`) and delivery, and when the work lands it is audited against the intent's own acceptance criteria (`/abcd:intent audit`), with the verdict recorded on the intent, so what was promised and what was delivered are read side by side. The lifeboat is a key capability of the same product: point `/abcd:disembark <source-repo> to <dest>` at any repository — one that has grown unwieldy, or one that died years ago and that abcd never managed — and abcd reads it without writing a single byte back, packing its hard-won knowledge — decisions, principles, pitfalls, the graveyard of what failed, the spine of what was built and why — into a portable lifeboat artefact at `<dest>`, alongside a coverage report that names what it could *not* ground and the questions a human must answer. `/abcd:disembark probe <source-repo>` renders that coverage verdict on its own, and `/abcd:embark from <path>` unpacks a lifeboat into a clean foundation with the same wisdom but none of the cruft. A small command surface rounds out the workflow: install (`/abcd:ahoy install`) and public release (`/abcd:launch ship`); `/abcd:capture` keeps discovered issues structured as the project evolves; and `/abcd:memory` curates a queryable knowledge substrate from those same sources. Bare invocation of any command shows status + suggested next actions; state-mutating actions require an explicit sub-verb (the universal abcd convention).
+> **abcd helps a product thinker realise an intent as a high-fidelity prototype or demonstrator — carrying the why from idea to shipped reality.** State what should exist, why, for whom, and what good looks like, as a press-release intent (`/abcd:intent "<text>"`); abcd holds that why through planning (`/abcd:intent plan`), the readiness gate (`/abcd:intent ready`) and delivery, and when the work lands it is audited against the intent's own acceptance criteria (`/abcd:intent audit`), with the verdict recorded on the intent, so what was promised and what was delivered are read side by side. The lifeboat is a key capability of the same product: point `/abcd:disembark pack <source-repo> <dest>` at any repository — one that has grown unwieldy, or one that died years ago and that abcd never managed — and abcd reads it without writing a single byte back, packing its hard-won knowledge — decisions, principles, pitfalls, the graveyard of what failed, the spine of what was built and why — into a portable lifeboat artefact at `<dest>`, alongside a coverage report that names what it could *not* ground and the questions a human must answer. `/abcd:disembark probe <source-repo>` renders that coverage verdict on its own, and `/abcd:embark from <path>` unpacks a lifeboat into a clean foundation with the same wisdom but none of the cruft. A small command surface rounds out the workflow: install (`/abcd:ahoy install`) and public release (`/abcd:launch ship`); `/abcd:capture` keeps discovered issues structured as the project evolves; and `/abcd:memory` curates a queryable knowledge substrate from those same sources. Bare invocation of any command shows status + suggested next actions; state-mutating actions require an explicit sub-verb (the universal abcd convention).
 >
 > "I know what I want built and I can tell in a minute whether a prototype got it right. What I could never do was hold that line through the engineering. abcd takes the why as I wrote it, builds against it, and shows me what was promised next to what was delivered," said Iris, a product thinker.
 >
@@ -20,7 +20,7 @@ The lifeboat widens from whole repositories to narrower sources — a single fea
 
 ## What's In Scope
 
-- **Pack the lifeboat:** `/abcd:disembark <source-repo> to <dest>` runs three passes (settled artefacts → targeted chat retrieval → distil/compose/audit) over a project's specs, ADRs, transcripts, oracle reviews, and curated memory. `/abcd:disembark probe <source-repo>` is the user-facing read-only half: the coverage report alone, rendered to stdout and written nowhere. Pack is **read-only in the source repo and writes out-of-tree** (adr-35): the source is never modified, so any repository can be mined — including a dead one abcd has never touched. Output at `<dest>` is a structured directory with synthesised principles, decisions timeline, pitfalls, a `graveyard/` of what was tried and abandoned, press-release framing, verbatim copies of specs, ADRs, and user docs, and a first-class `coverage.{json,md}` pair recording what could not be grounded (`grounded` / `partial` / `blank`), what was searched, and the question a human must answer. abcd refuses a destination it did not produce — it writes only into an absent path, an empty directory, or one carrying a parseable `_provenance.json`. Operations state (the append-only voyage log) lives at the operator level under `~/.abcd/voyage/<source-root-sha>/`, keyed on the root-commit SHA and never committed.
+- **Pack the lifeboat:** `/abcd:disembark pack <source-repo> <dest>` runs three passes (settled artefacts → targeted chat retrieval → distil/compose/audit) over a project's specs, ADRs, transcripts, oracle reviews, and curated memory. `/abcd:disembark probe <source-repo>` is the user-facing read-only half: the coverage report alone, rendered to stdout and written nowhere. Pack is **read-only in the source repo and writes out-of-tree** (adr-35): the source is never modified, so any repository can be mined — including a dead one abcd has never touched. Output at `<dest>` is a structured directory with synthesised principles, decisions timeline, pitfalls, a `graveyard/` of what was tried and abandoned, press-release framing, verbatim copies of specs, ADRs, and user docs, and a first-class `coverage.{json,md}` pair recording what could not be grounded (`grounded` / `partial` / `blank`), what was searched, and the question a human must answer. abcd refuses a destination it did not produce — it writes only into an absent path, an empty directory, or one carrying a parseable `_provenance.json`. Operations state (the append-only voyage log) lives at the operator level under `~/.abcd/voyage/<source-root-sha>/`, keyed on the root-commit SHA and never committed.
 - **Unpack the lifeboat:** `/abcd:embark from <path>` reads the lifeboat, runs a press-release interview to confirm the framing with the user, scaffolds the new repo at canonical locations, and writes provenance so the rebuild knows where it came from. `<path>` is wherever a prior disembark landed its lifeboat; there is no in-tree lifeboat home and no `home` shorthand.
 - **Install / promote:** `/abcd:ahoy install` bootstraps abcd in any repo (transparent prompts, visibility-driven gitignore, marker block in CLAUDE.md/AGENTS.md, prompt-router hook). `/abcd:launch ship` cuts a curated release from the single repo — `.abcd/**` excluded from the artifact by packaging — with secret/PII scans and a version stamp.
 - **Forward-looking discipline:** `/abcd:intent` captures product intents in three structural kinds per itd-34 — `standalone` (one user moment, one spec), `bundle-member` (coupled intents share a spec), and `discipline` (cross-cutting rules with no user moment, e.g., the itd-1 acceptance-gates rule that enforces Given-When-Then on every other spec). Standalone and bundle-member intents are press-release-shaped; disciplines use a `## Rule` template instead. `/abcd:capture` runs a structured issue ledger at `.abcd/work/issues/` rather than free-form notes. `/abcd:intent ready` answers the question that gates the build: is this intent ready to implement, and if not, what is missing. After shipping, `/abcd:intent audit` (Role 1 of `intent-auditor`) reviews delivered reality against the press release, and `/abcd:intent consistency` (Role 2, per itd-48, which superseded itd-31) catches drift between documents, filing each contradiction it finds as an issue. Two companions are designed and not yet built: `/abcd:intent grill` (per itd-27), a Socratic interview that stress-tests an intent, or a brief section, before it is planned; and `/abcd:intent shape` (Role 3), which keeps each intent's `kind` honest as the corpus grows.
@@ -34,9 +34,9 @@ Code-bundling lifeboats, cross-corpus synthesis, public-source vendoring with pr
 
 ## Acceptance Criteria
 
-- **Given** a corpus repo with a spec store, ADRs, and a memory backend present, **when** `/abcd:disembark <source-repo> to <dest>` runs to completion, **then** `<dest>` contains all sections specified in [`04-surfaces/02-disembark.md § 5`](../04-surfaces/02-disembark.md#5-output-shape) plus `coverage.{json,md}`, the source repo's tree hash is byte-for-byte unchanged, and the lifeboat review returns a registered verdict (`SHIP` / `NEEDS_WORK` / `MAJOR_RETHINK`) with specific findings (not vague approval).
-- **Given** a destination directory that is non-empty and carries no parseable `_provenance.json`, **when** `/abcd:disembark <source-repo> to <dest>` runs, **then** the command refuses with the offending path cited and writes nothing — abcd never overwrites a directory it did not produce (adr-35).
-- **Given** a lifeboat produced by `/abcd:disembark <source-repo> to <dest>` and an empty target repo, **when** `/abcd:embark from <dest>` runs, **then** the user is presented with the press-release interview as the first interaction, the amended press release becomes the new repo's `.abcd/development/brief/README.md`, and all canonical-location files (specs, ADRs, memory, docs, terminology, principles) land at the locations specified in [`04-surfaces/03-embark.md § 3`](../04-surfaces/03-embark.md#3-scaffold-steps).
+- **Given** a corpus repo with a spec store, ADRs, and a memory backend present, **when** `/abcd:disembark pack <source-repo> <dest>` runs to completion, **then** `<dest>` contains all sections specified in [`04-surfaces/02-disembark.md § 5`](../04-surfaces/02-disembark.md#5-output-shape) plus `coverage.{json,md}`, the source repo's tree hash is byte-for-byte unchanged, and the lifeboat review returns a registered verdict (`SHIP` / `NEEDS_WORK` / `MAJOR_RETHINK`) with specific findings (not vague approval).
+- **Given** a destination directory that is non-empty and carries no parseable `_provenance.json`, **when** `/abcd:disembark pack <source-repo> <dest>` runs, **then** the command refuses with the offending path cited and writes nothing — abcd never overwrites a directory it did not produce (adr-35).
+- **Given** a lifeboat produced by `/abcd:disembark pack <source-repo> <dest>` and an empty target repo, **when** `/abcd:embark from <dest>` runs, **then** the user is presented with the press-release interview as the first interaction, the amended press release becomes the new repo's `.abcd/development/brief/README.md`, and all canonical-location files (specs, ADRs, memory, docs, terminology, principles) land at the locations specified in [`04-surfaces/03-embark.md § 3`](../04-surfaces/03-embark.md#3-scaffold-steps).
 - **Given** a fresh repo with no `.abcd/` directory, **when** `/abcd:ahoy install` runs to completion, **then** the repo is bootstrapped per [`04-surfaces/01-ahoy.md § Acceptance`](../04-surfaces/01-ahoy.md#acceptance), and re-running `install` at the same `setup_version` is idempotent (no marker duplication, transparent re-confirm of visibility).
 - **Given** a clean tree with a deliberate PII fixture (e.g., a real email in a comment), **when** `/abcd:launch ship` runs, **then** preflight hard-fails with the offending file/line cited and no payload is written; a `/abcd:launch dry-run` on the same tree prints the would-refuse finding and exits 0 (report-only preview per [`04-surfaces/04-launch.md`](../04-surfaces/04-launch.md)).
 - **Given** the user runs `/abcd:intent "<text>"` (canonical bare quoted create), **when** the interview completes, **then** an `intents/drafts/itd-N-<slug>.md` file exists with press-release content, customer quote from the persona registry, and a `## Acceptance Criteria` section in Given-When-Then format (per itd-1).

diff --git a/.abcd/development/brief/01-product/02-context.md b/.abcd/development/brief/01-product/02-context.md
@@ -5,7 +5,7 @@ You did a manual lifeboat from iDelphiZero → iDelphi (`idelphiDev/.work/lifebo
 abcd ships these user-facing commands:
 
 - **`/abcd:ahoy install`** — install / update abcd in any project (bootstraps configuration, gitignore, marker blocks, PATH symlink). Bare `/abcd:ahoy` shows status+help.
-- **`/abcd:disembark <source-repo> to <dest>`** — *pack* a lifeboat by **reading** `<source-repo>` — any repository, including one abcd has never touched — and writing the artefact **out-of-tree** to the operator-chosen `<dest>`. The source is never written to; the destination must be absent, an empty directory, or one carrying a parseable `_provenance.json` ([adr-35](../../decisions/adrs/0035-lifeboat-as-coverage-experiment.md)). Bare `/abcd:disembark` shows status+help; `probe <source-repo>` and `dry-run` sub-verbs preview without writing — `probe` reports **coverage** (which brief sections a repository can ground, and which come back blank).
+- **`/abcd:disembark pack <source-repo> <dest>`** — *pack* a lifeboat by **reading** `<source-repo>` — any repository, including one abcd has never touched — and writing the artefact **out-of-tree** to the operator-chosen `<dest>`. The source is never written to; the destination must be absent, an empty directory, or one carrying a parseable `_provenance.json` ([adr-35](../../decisions/adrs/0035-lifeboat-as-coverage-experiment.md)). Bare `/abcd:disembark` shows status+help; `probe <source-repo>` and `dry-run` sub-verbs preview without writing — `probe` reports **coverage** (which brief sections a repository can ground, and which come back blank).
 - **`/abcd:embark from <dest>`** — *unpack* the lifeboat at `<dest>` (wherever a disembark wrote it) into a (typically empty) target project. Bare `/abcd:embark` shows status+help; `scan` and `probe <path>` sub-verbs discover/inspect without unpacking.
 - **`/abcd:launch ship`** — cut a curated release from the single repo (the packaging filter denies `.abcd/**`, so the released binaries do not carry it), scrub for PII/secrets, stamp the version, update the marketplace entry. Bare `/abcd:launch` shows status+help; `dry-run` sub-verb runs the full pre-flight gate suite without writing the release artifact.
 - **`/abcd:intent`** — bare quoted `/abcd:intent "<text>"` is the canonical create (spc-30/itd-46), plus the `plan` / `ready` / `audit` / `link` / `consistency` sub-verbs that ship (alongside the deprecated `new` alias; `consistency` per itd-48, which superseded itd-31), with `refine` / `grill` / `ship` / `shape` / `reclassify` remaining design targets. There is no plain `list` sub-verb — it is folded into the bare render per SD001. Manages **intents** (press-release-format intent docs at `.abcd/development/intents/{drafts,planned,shipped,disciplines,superseded}/`). `plan` promotes an intent to `planned/` and plans the work as a spec on the native spec store ([adr-26](../../decisions/adrs/0026-native-spec-layer-ccpm-backend.md); the companion harness `ccpm` as the deeper backend); `ship` drives that spec to completion (or the full pipeline if from drafts/); a spec-close hook reconciles standalone/bundle intents planned → shipped automatically on a successful close (spc-28 `intent_lifecycle.reconcile`); disciplines move from drafts/ to disciplines/ on plan and stay there. Bare `/abcd:intent` shows status+help.
@@ -21,7 +21,7 @@ abcd ships these user-facing commands:
 ```
 [source repo: specs, .abcd/memory/ (or legacy memory/), ADRs, docs, code, transcripts]
         │                            READ-ONLY — the source tree is never written to
-        │ /abcd:disembark <source-repo> to <dest>   (PACK)
+        │ /abcd:disembark pack <source-repo> <dest>   (PACK)
         ▼
 [lifeboat artefact at <dest>: a portable directory, out-of-tree]
    ├── README.md, press-release.md, principles.md   ← synthesised

diff --git a/.abcd/development/brief/02-constraints/01-platform.md b/.abcd/development/brief/02-constraints/01-platform.md
@@ -14,7 +14,7 @@ The core is a transport-agnostic Go package ([adr-23](../../decisions/adrs/0023-
 
 ## Lifeboat path
 
-**Out-of-tree, at an operator-chosen destination** — `disembark <source-repo> to <dest>`. There is no in-tree lifeboat home and nothing to gitignore in the source, because **disembark never writes to the source repo** (a test hashes its tree before and after). Per [adr-35](../../decisions/adrs/0035-lifeboat-as-coverage-experiment.md), superseding adr-4's `.abcd/lifeboat/`: mining a dead or archived project must not require installing abcd into a repo we only want to read.
+**Out-of-tree, at an operator-chosen destination** — `disembark pack <source-repo> <dest>`. There is no in-tree lifeboat home and nothing to gitignore in the source, because **disembark never writes to the source repo** (a test hashes its tree before and after). Per [adr-35](../../decisions/adrs/0035-lifeboat-as-coverage-experiment.md), superseding adr-4's `.abcd/lifeboat/`: mining a dead or archived project must not require installing abcd into a repo we only want to read.
 
 **Lifeboat is always *output*.** `<dest>` holds the latest snapshot only — produced by `disembark`, regenerable from current state; there is no `lifeboat-v1/` / `lifeboat-v2/` proliferation. Re-running is governed by a **destination safety gate**, not adr-4's `.bak` overwrite: refuse unless the destination is absent, an empty directory, or one carrying a parseable `_provenance.json`. **abcd never overwrites a directory it did not produce.** Past disembarks are recorded as manifests (hash + file list + label) at the operator level, not as preserved snapshots — see [`04-surfaces/03-embark.md § 7`](../04-surfaces/03-embark.md#7-voyage-layout--embarkdisembark-provenance-and-history).
 
@@ -24,7 +24,7 @@ The core is a transport-agnostic Go package ([adr-23](../../decisions/adrs/0023-
 
 **Embark sources, in order (post bare-as-help refactor — see [`04-surfaces/03-embark.md`](../04-surfaces/03-embark.md)):**
 
-1. `embark from <path>` (any explicit path to a lifeboat destination a disembark wrote) — **there is no `home` shorthand**, because there is no in-tree lifeboat home to expand it to (adr-35). The round-trip / self-test case is just `disembark <repo> to <dest>` followed by `embark from <dest>`.
+1. `embark from <path>` (any explicit path to a lifeboat destination a disembark wrote) — **there is no `home` shorthand**, because there is no in-tree lifeboat home to expand it to (adr-35). The round-trip / self-test case is just `disembark pack <repo> <dest>` followed by `embark from <dest>`.
 2. `embark scan` (or `embark scan --deep`) → discovery sub-verb that walks sibling directories (`../`), lists **lifeboat destinations** — directories carrying a parseable `_provenance.json`, the same marker the destination safety gate keys on — ranked by mtime; does not unpack; pass the chosen path to `embark from <path>`
 3. Free-text path input via the embark interview if `<path>` is omitted on `from`