doctrina-cli 0.20.0 → 0.21.0

package/src/commands/review.js

@@ -6,6 +6,7 @@ import { exists, isDir, isFile, read } from "../lib/fs-ops.js";
 import { flagBool, flagString } from "../lib/args.js";
 import { c } from "../lib/colors.js";
 import { rankCapabilitiesByDiff } from "../lib/work-model.js";
+import { applyOps, extractOps } from "../lib/spec-ops.js";
 import { readLedger, churnByCapability } from "../lib/ledger.js";
 import { changedFiles, windowCutoff, historyState, refExists } from "../lib/git.js";
 import { dependentsOf, deltaCapabilities } from "../lib/scan.js";
@@ -67,6 +68,8 @@ export async function run(_positional, flags) {
   const changeId = flagString(flags, "change");
   /** @type {Set<string> | null} */
   let changeCaps = null;
+  /** @type {Map<string, string>} the change's delta text per capability */
+  const pending = new Map();
   if (changeId !== undefined) {
     const refused = refuseChangeRef(changeId);
     if (refused !== null) return refused;
@@ -76,6 +79,19 @@ export async function run(_positional, flags) {
       return EXIT.USAGE;
     }
     changeCaps = new Set(deltaCapabilities(changeDir));
+    // The specs as this change leaves them: an ops delta applied in memory,
+    // as `change check` dry-runs it; a delta without ops (a manual merge)
+    // read beside the spec, since nothing can apply it.
+    for (const cap of changeCaps) {
+      const delta = path.join(changeDir, "specs", cap, "delta.md");
+      const spec = path.join(projectRoot, ".doctrina", "specs", cap, "spec.md");
+      if (!isFile(delta)) continue;
+      const deltaText = read(delta);
+      const current = isFile(spec) ? read(spec) : "";
+      const ops = extractOps(deltaText);
+      const after = ops.length > 0 ? applyOps(current, ops) : null;
+      pending.set(cap, after && after.errors.length === 0 ? after.text : `${current}\n${deltaText}`);
+    }
   }
 
   const { all, sourceFiles } = reviewScope(projectRoot, against);
@@ -102,11 +118,19 @@ export async function run(_positional, flags) {
     all.filter((f) => /(^|\/)\.doctrina\/specs\/[^/]+\/spec\.md$/.test(f.replace(/\\/g, "/")))
       .map((f) => f.replace(/\\/g, "/").match(/\.doctrina\/specs\/([^/]+)\/spec\.md$/)[1]),
   );
-  const ranked = rankCapabilitiesByDiff(projectRoot, sourceFiles, { limit: Infinity });
+  const ranked = rankCapabilitiesByDiff(projectRoot, sourceFiles, { limit: Infinity, pending });
   const touched = new Set([...specChanged, ...ranked.map((m) => m.id)]);
   const stale = ranked.map((m) => m.id).filter((id) => !specChanged.has(id) && !changeCaps?.has(id));
+  // Without --change, an OPEN change that carries a delta for the capability
+  // updates its spec at close (fifth audit, change 0236): the bare review
+  // reported "its spec was not updated" for exactly the work a planner had
+  // in flight — the real agent read it as a break and went to fix the spec.
+  const inFlight = changeCaps === null ? openDeltaOwners(projectRoot) : new Map();
   if (changeCaps === null) {
-    for (const id of stale) {
+    for (const id of stale.filter((x) => inFlight.has(x))) {
+      notes.push(`code under capability "${id}" changed; its spec is updated when ${inFlight.get(id)?.join(", ")} closes (\`doctrina review --change <id>\` reviews it as that close does)`);
+    }
+    for (const id of stale.filter((x) => !inFlight.has(x))) {
       breaks.push(`code under capability "${id}" changed, but its spec was not updated — confirm \`.doctrina/specs/${id}/spec.md\` still describes the code (update it, or note why not)`);
     }
   } else if (stale.length > 0) {
@@ -151,7 +175,7 @@ export async function run(_positional, flags) {
   //    file in the change. A review of an adapter change reported
   //    "Capabilities touched: docs" and said nothing about the adapter.
   const orphans = sourceFiles.filter(
-    (f) => rankCapabilitiesByDiff(projectRoot, [f], { limit: 1 }).length === 0,
+    (f) => rankCapabilitiesByDiff(projectRoot, [f], { limit: 1, pending }).length === 0,
   );
   if (orphans.length > 0) {
     const shown = orphans.slice(0, ORPHAN_LIST_LIMIT).map((f) => `\`${f}\``).join(", ");
@@ -274,3 +298,15 @@ from specs that declare no Source.
 Read-only. Exits 0 as a report; with --strict, exits 1 when any hard break
 exists (CI gate). Notes (advisory) never fail the gate.
 `;
+
+/** Capability → the open changes that carry a delta for it. */
+function openDeltaOwners(projectRoot) {
+  const out = new Map();
+  const changes = path.join(projectRoot, ".doctrina", "changes");
+  if (!isDir(changes)) return out;
+  for (const id of readdirSync(changes).sort()) {
+    if (id === "archive" || id.startsWith(".") || !isDir(path.join(changes, id))) continue;
+    for (const cap of deltaCapabilities(path.join(changes, id))) out.set(cap, [...(out.get(cap) ?? []), id]);
+  }
+  return out;
+}

package/src/commands/skill.js

@@ -455,7 +455,8 @@ knowledge loaded only when relevant.
 
 Subcommands:
   new <name>    Scaffold a new skill from the template and index
-                it. Name must match [a-z][a-z0-9-]*.
+                it. Name must match [a-z][a-z0-9-]*. --force
+                overwrites an existing skill.
   list          Print one line per skill with name + description.
                 Read-only.
   sync          Copy each skill's frontmatter description into

package/src/commands/status.js

@@ -11,6 +11,7 @@ import { renderView, VIEWS } from "../lib/views.js";
 import { draftAgentChangelog, renderDraft } from "../lib/agent-changelog.js";
 import { cliVersion } from "../lib/version.js";
 import { suggest } from "../lib/suggest.js";
+import { contextRouting, workspaceActions, workspaceFindings, workspaceHandoff, workspaceRootAt, workspaceSnapshot, workspaceStatus } from "../lib/workspace-view.js";
 
 // One-glance project health (review 2026-06-27 passive-user feature #1): a
 // dashboard that answers "where do things stand?" in a single read, so neither
@@ -38,6 +39,8 @@ const STATUS_VIEWS = [...VIEWS, "agent-changelog"];
 
 export async function run(_positional, flags) {
   const projectRoot = process.cwd();
+  const wsRoot = workspaceRootAt(projectRoot);
+  if (wsRoot) return workspaceStatusView(wsRoot, flags);
   if (!exists(path.join(projectRoot, ".doctrina"))) {
     throw notADoctrinaProject();
   }
@@ -90,6 +93,9 @@ signals (index drift, framework stamp, coverage %, trace anchors, whether
 verify is configured) and the artifact counts (specs by implementation
 state, open changes, decisions, skills). Read-only; always exits 0.
 
+At a workspace root it prints the workspace instead: projects ready,
+pending and missing, open changes, deliveries open and closed, tools.
+
 Flags:
   --view <name>   Render a different shape of the same snapshot:
                     dashboard  the default one-glance health board
@@ -116,3 +122,25 @@ It is a fast summary, not the authoritative gate: run \`doctrina validate\`
 and \`doctrina verify\` for the full structural and build checks, and
 \`doctrina next\` for the recommended next action.
 `;
+
+// At a workspace root: one glance at the workspace (change 0230).
+function workspaceStatusView(wsRoot, flags) {
+  const snap = workspaceSnapshot(wsRoot);
+  const st = workspaceStatus(snap);
+  if (flagBool(flags, "json", false)) {
+    emitJson("status", { workspace: wsRoot, ...st });
+    return 0;
+  }
+  console.log(c.bold(`Doctrina workspace "${st.name}"`) + c.gray(` — ${wsRoot}`));
+  console.log("");
+  console.log(`Projects    ${st.ready}/${st.projects} ready` + (st.pending.length ? c.yellow(` · pending: ${st.pending.join(", ")}`) : "")
+    + (st.missing.length ? c.red(` · missing: ${st.missing.join(", ")}`) : "") + ` · ${st.openChanges} open change${st.openChanges === 1 ? "" : "s"}`);
+  console.log(`Deliveries  ${st.deliveries.open} open · ${st.deliveries.closed} closed`);
+  console.log(`Tools       ${st.tools} declared`);
+  const first = workspaceActions(snap)[0];
+  if (first) {
+    console.log("");
+    console.log(c.gray("next: ") + `${first.text} — ` + c.cyan(first.command));
+  }
+  return 0;
+}

package/src/commands/upgrade.js

@@ -10,6 +10,9 @@ import { c } from "../lib/colors.js";
 import { today } from "../lib/dates.js";
 import { notADoctrinaProject } from "../lib/exit-codes.js";
 import { planSkillExport, applySkillExport } from "../lib/skill-export.js";
+import { applyAdapterMigration, planAdapterMigration } from "../lib/adapters.js";
+import { projectName } from "../lib/project.js";
+import { relinkShadow, shadowRootOf } from "../lib/workspace.js";
 import { collectFindings } from "../lib/templates-model.js";
 import * as templates from "./templates.js";
 import * as validate from "./validate.js";
@@ -78,6 +81,8 @@ export async function run(_positional, flags) {
   // The skill exports (change 0212) follow the index: regenerated by the
   // write, reported by the preview.
   const exportPlan = planSkillExport(projectRoot);
+  // Adapter files that moved (change 0238): Cursor's slash commands became skills.
+  const movePlan = planAdapterMigration(projectRoot, { PROJECT_NAME: projectName(projectRoot), PROJECT_DESCRIPTION: "", DATE: today() }, shadowRootOf(projectRoot) ?? projectRoot);
   const exportChanges = exportPlan.writes.length + exportPlan.removes.length;
 
   // 3. Index: rebuild from the tree, which also migrates the framework stamp.
@@ -96,6 +101,19 @@ export async function run(_positional, flags) {
         pending += 1;
       }
     }
+    const moves = movePlan.writes.length + movePlan.removes.length;
+    if (moves > 0) {
+      if (writeMode) {
+        const gone = applyAdapterMigration(shadowRootOf(projectRoot) ?? projectRoot, movePlan);
+        relinkShadow(projectRoot, gone);
+        console.log(c.green("moved  ") + ` ${movePlan.writes.length} adapter file${movePlan.writes.length === 1 ? "" : "s"} to the skills the agent reads now` +
+          (movePlan.removes.length ? `, ${movePlan.removes.length} retired cop${movePlan.removes.length === 1 ? "y" : "ies"} removed` : ""));
+      } else {
+        console.log(c.yellow("would  ") + `move ${movePlan.removes.length || movePlan.writes.length} Cursor command${(movePlan.removes.length || movePlan.writes.length) === 1 ? "" : "s"} to .cursor/skills/ (Cursor reads skills now)`);
+        pending += 1;
+      }
+    }
+    for (const rel of movePlan.kept) console.log(c.yellow("kept   ") + ` ${rel} — edited since install; its skill replaces it, so move your edits and remove it`);
     if (!drifted && !staleStamp) {
       console.log(c.green("ok") + " index.json matches the tree and the stamp is current");
     } else if (writeMode) {

package/src/commands/validate.js

@@ -7,6 +7,7 @@ import { c } from "../lib/colors.js";
 import { emitJson } from "../lib/json-out.js";
 import { notADoctrinaProject } from "../lib/exit-codes.js";
 import { collectValidation } from "../lib/validation-model.js";
+import { contextRouting, workspaceActions, workspaceFindings, workspaceHandoff, workspaceRootAt, workspaceSnapshot, workspaceStatus } from "../lib/workspace-view.js";
 
 // The structural gate. The checks themselves live in lib/validation-model.js
 // so a driver can ASK for them instead of spawning this binary and parsing
@@ -27,6 +28,19 @@ export async function run(_positional, flags) {
   // Outside a Doctrina project this is a PRECONDITION, not a pile of
   // gate failures about missing files: the remedy is `doctrina init`,
   // not editing artifacts that do not exist yet (C7).
+  // At a workspace root: the workspace's own integrity — registry, shadow
+  // links, deliveries (change 0230). Each project validates inside itself.
+  const wsRoot = workspaceRootAt(projectRoot);
+  if (wsRoot) {
+    const { errors, warnings } = workspaceFindings(workspaceSnapshot(wsRoot));
+    for (const e of errors) console.log(c.red("error: ") + e);
+    for (const w of warnings) console.log(c.yellow("warn:  ") + w);
+    console.log("");
+    console.log(errors.length === 0
+      ? c.green("ok") + ` the workspace is consistent${warnings.length ? ` (${warnings.length} warning${warnings.length === 1 ? "" : "s"})` : ""} — each project validates inside itself: \`cd <path> && doctrina validate\``
+      : c.red("fail") + ` ${errors.length} workspace error${errors.length === 1 ? "" : "s"}`);
+    return errors.length > 0 || (flagBool(flags, "strict", false) && warnings.length > 0) ? 1 : 0;
+  }
   if (!isDir(path.join(projectRoot, ".doctrina"))) throw notADoctrinaProject();
 
   const { errors, warnings, fixes } = collectValidation(projectRoot, {
@@ -82,6 +96,10 @@ Run schema, artifact-existence, and structural checks against the
 .doctrina/ tree in the current working directory. Exits 0 if no errors
 (warnings allowed), 1 otherwise. With --strict, a warning fails it too.
 
+At a workspace root it checks the workspace instead — registered
+projects and their dependencies, shadow links, deliveries — and leaves
+each project's validation to \`cd <path> && doctrina validate\`.
+
 Two structural checks worth naming:
 
   Pipeline    a spec's optional "### Pipeline" block declares ordered

package/src/commands/verify.js

@@ -5,6 +5,7 @@ import { readdirSync } from "node:fs";
 import { wantsJson } from "../lib/json-out.js";
 import { spawn, spawnSync } from "node:child_process";
 import { exists, isDir, isFile, read, write, relPath } from "../lib/fs-ops.js";
+import { inventory } from "../lib/code-inventory.js";
 import { flagBool, flagString } from "../lib/args.js";
 import { today } from "../lib/dates.js";
 import { c } from "../lib/colors.js";
@@ -38,6 +39,16 @@ const STARTER = {
   ],
 };
 
+const SEEDED_COMMENT =
+  "doctrina verify runs each check below, in order, through your shell. " +
+  "These were seeded from the project's own manifests by the code " +
+  "inventory — confirm each one runs what its name says, and remove or add " +
+  "checks until this file is the project's executable definition of 'the " +
+  "code actually works'. A non-zero exit fails the gate. A check may add an " +
+  "\"expect\" block — {\"fail_if_output_matches\": \"<regex>\"} and/or " +
+  "{\"require_output_matches\": \"<regex>\"} — so that a run which exits 0 " +
+  "having executed NOTHING fails the gate instead of passing it.";
+
 // Flags this command accepts. Declared HERE, with the command, so
 // adding a command never requires editing the entrypoint — the gap that
 // let six flags ship undeclared and silently swallow a positional (C3).
@@ -69,9 +80,24 @@ export async function run(_positional, flags) {
       console.error(c.red("error:") + ` ${CONFIG_REL} already exists (pass --force to overwrite)`);
       return 1;
     }
-    write(configPath, JSON.stringify(STARTER, null, 2) + "\n", { force: true });
-    console.log(c.green("created") + ` ${CONFIG_REL}`);
-    console.log(c.gray("Edit the `checks` array with your real commands, then run `doctrina verify`."));
+    // Seeded from the code inventory when it found the project's own build
+    // and test commands (change 0228): the absorb playbook says "declare the
+    // build gate from the inventory's candidate commands", and the inventory
+    // lists them under that heading — while --init wrote `exit 1` anyway,
+    // leaving the agent to copy by hand what the CLI had just read. With no
+    // candidate the starter stays fail-closed: a gate nobody declared must
+    // not pass.
+    // A check that belongs to one unit of a monorepo runs there (`cwd`).
+    const seeded = inventory(projectRoot).checks.map((ch) => ({ name: ch.name, run: ch.command, ...(ch.cwd ? { cwd: ch.cwd } : {}) }));
+    const config = seeded.length > 0
+      ? { ...STARTER, $comment: SEEDED_COMMENT, checks: seeded }
+      : STARTER;
+    write(configPath, JSON.stringify(config, null, 2) + "\n", { force: true });
+    console.log(c.green("created") + ` ${CONFIG_REL}` +
+      (seeded.length > 0 ? c.gray(` — seeded from the code inventory: ${seeded.map((s) => s.cwd ? `${s.run} (in ${s.cwd}/)` : s.run).join(", ")}`) : ""));
+    console.log(c.gray(seeded.length > 0
+      ? "Confirm each check runs what its name says (add an \"expect\" block where a run could execute nothing), then run `doctrina verify`."
+      : "Edit the `checks` array with your real commands, then run `doctrina verify`."));
     return 0;
   }
 
@@ -488,7 +514,9 @@ copy accumulates for the match. An "expect" pattern that is not a valid
 regular expression fails at config time, not silently.
 
 Flags:
-  --init     Scaffold a starter ${CONFIG_REL} (refuses to overwrite without --force)
+  --init     Scaffold a starter ${CONFIG_REL} (refuses to overwrite without --force):
+             the build and test commands the code inventory finds in the
+             project's manifests, or a fail-closed example when it finds none
   --list     Print the configured checks without running them
   --clean    Don't run checks; lint the project's package.json files for
              reproducibility footguns (entry points in a build dir with no

package/src/commands/work.js

@@ -2,15 +2,17 @@
 import path from "node:path";
 import process from "node:process";
 import { readdirSync } from "node:fs";
-import { exists, isDir, isFile, mkdirp, read, relPath, write } from "../lib/fs-ops.js";
+import { eolOf, exists, isDir, isFile, mkdirp, read, relPath, withEol, write } from "../lib/fs-ops.js";
 import { flagString, flagBool } from "../lib/args.js";
 import * as idx from "../lib/index-json.js";
 import { c } from "../lib/colors.js";
 import { assessBrief } from "../lib/clarity.js";
 import { locateTemplatesDir, substitute } from "../lib/templates.js";
 import { findWorkspace, projectAt, readWorkspace } from "../lib/workspace.js";
-import { readDelivery, resolveDeliveryId } from "../lib/delivery.js";
+import { readDelivery, resolveDeliveryId, sectionText } from "../lib/delivery.js";
+import { parseLedger } from "../lib/ledger.js";
 import { EXIT, notADoctrinaProject } from "../lib/exit-codes.js";
+import { listHeader } from "../lib/scan.js";
 import { changeNew, reindexChange, addAffectedSpec } from "../lib/change-ops.js";
 import { classify } from "../lib/triage-model.js";
 import { printPlaybookTemplate } from "../lib/playbook.js";
@@ -67,6 +69,7 @@ export async function run(positional, flags) {
   // workspace delivery. Checked BEFORE anything is scaffolded, so a typo or a
   // repository the delivery was never routed to opens nothing.
   let delivery = null;
+  let deliveryStory = "";
   if (flags.has("delivery")) {
     const resolved = resolveDeliveryFor(projectRoot, flagString(flags, "delivery"));
     if (resolved.error) {
@@ -75,13 +78,14 @@ export async function run(positional, flags) {
       return resolved.code;
     }
     delivery = resolved.id;
+    deliveryStory = resolved.story ?? "";
   }
 
   // --resume <id>: reprint the playbook for an existing open change rather than
   // open a new one (review G1 — `work "continue"` used to slug the word and
   // fabricate a junk `NNNN-continue` change the operator had to delete).
   if (flags.has("resume")) {
-    return resumeChange(projectRoot, flagString(flags, "resume"));
+    return resumeChange(projectRoot, flagString(flags, "resume"), delivery);
   }
 
   // --from-diff backfills from code already written (review F8): the
@@ -237,14 +241,17 @@ export async function run(positional, flags) {
     if (delivery) {
       updated = updated.replace(/^(-[ \t]+\*\*Lane:\*\*[^\r\n]*)/m, `$1\n- **Delivery:** ${delivery}`);
     }
-    if (updated !== txt) write(proposalPath, updated, { force: true });
+    if (updated !== txt) write(proposalPath, withEol(updated, eolOf(txt)), { force: true });
   }
 
   // Capability hint: term overlap for a prompt, changed-file overlap for a diff
   // (review F10 — rank by what the working tree touched, not just prompt words).
   const allChanged = fromDiff ? files : changedFiles(projectRoot).files;
   const diffMatches = pinned ? [] : rankCapabilitiesByDiff(projectRoot, allChanged);
-  const promptMatches = pinned || fromDiff ? [] : rankCapabilities(projectRoot, effPrompt);
+  // A delivery's change is ranked by its story too (second audit, change
+  // 0233): the title of a tracker item rarely names the capability — "lock
+  // the account after 3 wrong passwords" — while its story says "login".
+  const promptMatches = pinned || fromDiff ? [] : rankCapabilities(projectRoot, deliveryStory ? `${effPrompt}\n${deliveryStory}` : effPrompt);
   const matches = pinned ? [] : (fromDiff ? diffMatches : promptMatches);
   const capability = pinned ?? matches[0]?.id ?? null;
   const clarity = assessBrief(effPrompt, { kind: "prompt" });
@@ -399,7 +406,7 @@ function resolveDeliveryFor(projectRoot, ref) {
       code: EXIT.PRECONDITION,
     };
   }
-  return { id };
+  return { id, story: sectionText(d.text, "Story") ?? "" };
 }
 
 function writeLane(projectRoot, id, verdict, opts) {
@@ -437,6 +444,11 @@ function nextChangeNumber(projectRoot) {
       harvest(entry.replace(/^\d{4}-\d{2}-\d{2}-/, ""));
     }
   }
+  // An abandoned change leaves no folder, only its ledger line (third audit,
+  // change 0234): its number was handed out again, and the ledger then named
+  // two different changes by one id — the abandoned part of a delivery among them.
+  const ledger = path.join(archiveDir, "LEDGER.md");
+  if (isFile(ledger)) for (const e of parseLedger(read(ledger)).entries) harvest(e.id);
   return String(max + 1).padStart(4, "0");
 }
 
@@ -481,7 +493,7 @@ function printResumeSuggestion(open) {
 
 // Reprint the work playbook for an already-open change, ranking capabilities
 // from its recorded title (the original prompt). Creates nothing.
-function resumeChange(projectRoot, resumeId) {
+function resumeChange(projectRoot, resumeId, delivery = null) {
   const open = openChanges(projectRoot);
   if (!resumeId || resumeId === true) {
     console.error(c.red("error:") + " --resume needs a change id");
@@ -496,6 +508,25 @@ function resumeChange(projectRoot, resumeId) {
     if (open.length) console.error(c.gray("open: ") + open.map((ch) => ch.id).join(", "));
     return 1;
   }
+  // --resume <id> --delivery <id> (change 0226): a change opened before its
+  // delivery existed — or without the flag — joins it, so the delivery's
+  // status and check see it. A change already in another delivery is not
+  // moved silently.
+  if (delivery) {
+    const proposalPath = path.join(projectRoot, ".doctrina", "changes", resumeId, "proposal.md");
+    const text = isFile(proposalPath) ? read(proposalPath) : "";
+    const current = (listHeader(text, "Delivery") ?? "").trim();
+    if (current && current !== delivery) {
+      console.error(c.red("error:") + ` ${resumeId} already belongs to delivery ${current}`);
+      return EXIT.PRECONDITION;
+    }
+    if (!current) {
+      const stamped = text.replace(/^(-[ \t]+\*\*Lane:\*\*[^\r\n]*)/m, `$1\n- **Delivery:** ${delivery}`);
+      const updated = stamped !== text ? stamped : text.replace(/^(-[ \t]+\*\*Status:\*\*[^\r\n]*)/m, `$1\n- **Delivery:** ${delivery}`);
+      write(proposalPath, withEol(updated, eolOf(text)), { force: true });
+      console.log(c.green("joined") + ` ${resumeId} to delivery ${delivery}`);
+    }
+  }
   const prompt = entry?.title ?? resumeId;
   const matches = rankCapabilities(projectRoot, prompt);
   const capability = matches[0]?.id ?? null;
@@ -610,7 +641,9 @@ function printPlaybook(projectRoot, { id, prompt, pinned, matches, capability, c
 // The prompt as a `context --for` argument: one line, no double quotes, short
 // enough to read — the slicer only needs its content words.
 export function forQuery(prompt) {
-  const flat = String(prompt ?? "").replace(/["`]/g, "").replace(/\s+/g, " ").trim();
+  // `$` and `\\` too (change 0235): between the double quotes the playbook
+  // prints, `$(…)` in a prompt still ran.
+  const flat = String(prompt ?? "").replace(/["`$\\]/g, "").replace(/\s+/g, " ").trim();
   return flat.length > 80 ? flat.slice(0, 80).replace(/\s+\S*$/, "") : flat;
 }
 
@@ -667,6 +700,8 @@ Options:
                        (backlog entry; reprint later with --resume <id>)
   --id <id>            Override the derived change id
   --resume <id>        Reprint the playbook for an open change; create nothing
+  --delivery <id>      Stamp the change with the workspace delivery it is part
+                       of (ADR 0030); with --resume, join an open change to it
   --from-diff          Backfill: scaffold from the working-tree changes (no
                        prompt needed) and print a code-first playbook (F8)
   --consolidate <cap>  Open a change that consolidates <cap>'s spec — merge