@printpractical/cruze 0.0.13 → 0.0.14

package/src/domain/trace.ts

@@ -1,44 +1,27 @@
-import { headingElements, statusOf } from "./elements.ts";
-import { findIds } from "./ids.ts";
-import { PATHS } from "./project/layout.ts";
-import type { ProjectView } from "./project/project_view.ts";
-import { readScope } from "./project/plan_parts.ts";
-import { readDelta } from "./project/deltas.ts";
-import type { WorkItem } from "./project/work_items.ts";
+import { findScenarioIds } from "./ids.ts";
+import type { Feature } from "./project/features.ts";
 
 export interface TraceReport {
   /** Scenarios that must have a test, and the test files that carry each one. */
   scenarios: Array<{ id: string; tests: string[] }>;
   missing: string[];
-  /** Scenario IDs in tests that no living doc or active delta defines. */
+  /** Scenario IDs in tests that no feature document defines. */
   unknown: Array<{ id: string; path: string; line: number }>;
 }
 
-/**
- * Links scenarios to the tests that prove them. For a change: every scenario it delivers.
- * For the whole project: every built scenario in the living specs.
- */
-export function traceScenarios(view: ProjectView, tests: ReadonlyMap<string, string>, change?: WorkItem): TraceReport {
-  const required = change === undefined ? builtScenarios(view) : (readScope(change.doc)?.delivers ?? []).filter((id) => id.startsWith("SCN-"));
-  const known = new Set([...view.living.elements.keys()]);
-  for (const item of view.items.filter((i) => !i.archived)) for (const id of readDelta(item.doc).ids) known.add(id);
-
+/** Links the required features' scenarios to the tests that carry their IDs. */
+export function traceScenarios(features: readonly Feature[], required: readonly Feature[], tests: ReadonlyMap<string, string>): TraceReport {
+  const known = new Set(features.flatMap((f) => f.scenarios.map((s) => s.id)));
   const carriers = new Map<string, string[]>();
   const unknown: TraceReport["unknown"] = [];
   for (const [path, text] of tests) {
     text.split("\n").forEach((line, index) => {
-      for (const id of findIds(line).filter((id) => id.startsWith("SCN-"))) {
+      for (const id of findScenarioIds(line)) {
         carriers.set(id, [...new Set([...(carriers.get(id) ?? []), path])]);
         if (!known.has(id)) unknown.push({ id, path, line: index + 1 });
       }
     });
   }
-  const scenarios = required.map((id) => ({ id, tests: carriers.get(id) ?? [] }));
+  const scenarios = required.flatMap((f) => f.scenarios).map((s) => ({ id: s.id, tests: carriers.get(s.id) ?? [] }));
   return { scenarios, missing: scenarios.filter((s) => s.tests.length === 0).map((s) => s.id), unknown };
 }
-
-function builtScenarios(view: ProjectView): string[] {
-  return [...view.living.docs]
-    .filter(([path]) => path.startsWith(`${PATHS.specsDir}/`))
-    .flatMap(([, doc]) => headingElements(doc).filter((e) => e.kind === "SCN" && statusOf(doc, e) === "built").map((e) => e.id));
-}

package/src/domain/validation/document_rules.ts

@@ -0,0 +1,70 @@
+import { featureOfScenario } from "../ids.ts";
+import { findSection, type MarkdownDoc } from "../markdown.ts";
+import { FEATURE_SECTIONS, FEATURE_STATUSES, statusLine, strayScenarioIds, type Feature } from "../project/features.ts";
+import { PATHS } from "../project/layout.ts";
+import type { ProjectDocs } from "../project/project_docs.ts";
+import { error, warning, type Problem } from "./problem.ts";
+
+/** Each document's required sections, its size, its scenarios, and leftover template guides. */
+
+const VISION_SECTIONS = ["Problem", "Users", "Release"];
+const ARCHITECTURE_SECTIONS = ["Overview", "Ports", "Adapters", "Runtime"];
+
+/** Words past which a document stops being something a person reads in one sitting. */
+export const WORD_LIMITS = { vision: 1500, architecture: 3000, feature: 2500 } as const;
+
+const GUIDE = /(?<!`)<(?!!--|\/|https?:|br\b)[A-Za-z][^<>\n]*>(?!`)/;
+const PLACEHOLDER = /\{\{[a-z_]+\}\}/;
+
+export function documentProblems(docs: ProjectDocs): Problem[] {
+  const problems: Problem[] = [];
+  if (docs.vision !== undefined) problems.push(...shapeOf(PATHS.vision, docs.vision, VISION_SECTIONS, WORD_LIMITS.vision));
+  if (docs.architecture !== undefined) problems.push(...shapeOf(PATHS.architecture, docs.architecture, ARCHITECTURE_SECTIONS, WORD_LIMITS.architecture));
+  for (const feature of docs.features) {
+    problems.push(...shapeOf(feature.path, feature.doc, [...FEATURE_SECTIONS], WORD_LIMITS.feature), ...featureProblems(feature));
+  }
+  problems.push(...duplicateScenarios(docs.features));
+  return problems;
+}
+
+function shapeOf(path: string, doc: MarkdownDoc, sections: string[], limit: number): Problem[] {
+  const problems: Problem[] = sections.filter((title) => findSection(doc, title) === null).map((title) => error(path, undefined, "missing-section", `needs a ## ${title} section`));
+  const words = doc.lines.filter((_, i) => !doc.inFence[i]).join(" ").split(/\s+/).filter((w) => w !== "").length;
+  if (words > limit) problems.push(warning(path, undefined, "too-long", `${words} words, over the ${limit} a person reads in one sitting; cut what the agent decided and the user needn't read, or split it`));
+  doc.lines.forEach((line, i) => {
+    if (doc.inFence[i]) return;
+    const withoutCode = line.replace(/`[^`]*`/g, "");
+    if (GUIDE.test(withoutCode) || PLACEHOLDER.test(withoutCode)) problems.push(error(path, i, "template-leftover", "replace the template guide or placeholder on this line"));
+  });
+  return problems;
+}
+
+function featureProblems(feature: Feature): Problem[] {
+  const problems: Problem[] = [];
+  const status = statusLine(feature.doc);
+  if (status === undefined) problems.push(error(feature.path, undefined, "status", `needs a "- Status: shaped" line under the title`));
+  else if (feature.status === undefined) problems.push(error(feature.path, status.line, "status", `the status is one of ${FEATURE_STATUSES.join(" or ")}`));
+  if (feature.scenarios.length === 0 && findSection(feature.doc, "Behaviour") !== null) {
+    problems.push(error(feature.path, undefined, "no-scenarios", `## Behaviour needs at least one ### SCN-${feature.slug}.<name>: <title> scenario`));
+  }
+  for (const scenario of feature.scenarios) {
+    if (featureOfScenario(scenario.id) !== feature.slug) problems.push(error(feature.path, scenario.line, "scenario-id", `${scenario.id} belongs to this feature, so it starts SCN-${feature.slug}.`));
+  }
+  for (const stray of strayScenarioIds(feature)) {
+    problems.push(error(feature.path, stray.line, "scenario-heading", `a scenario heading reads exactly "${stray.id}: <title>"`));
+  }
+  return problems;
+}
+
+function duplicateScenarios(features: Feature[]): Problem[] {
+  const seen = new Map<string, string>();
+  const problems: Problem[] = [];
+  for (const feature of features) {
+    for (const scenario of feature.scenarios) {
+      const first = seen.get(scenario.id);
+      if (first !== undefined) problems.push(error(feature.path, scenario.line, "duplicate-scenario", `${scenario.id} is already defined in ${first}`));
+      else seen.set(scenario.id, feature.path);
+    }
+  }
+  return problems;
+}

package/src/domain/validation/release_rules.ts

@@ -0,0 +1,45 @@
+import { isSlug } from "../ids.ts";
+import { PATHS } from "../project/layout.ts";
+import type { ProjectDocs } from "../project/project_docs.ts";
+import { error, warning, type Problem } from "./problem.ts";
+
+/** The vision's Release table: feature slugs, what each needs, and no cycles. */
+export function releaseProblems(docs: ProjectDocs): Problem[] {
+  if (docs.vision === undefined) return [];
+  if (docs.release.length === 0) return [warning(PATHS.vision, undefined, "release", "## Release has no Feature | Summary | Needs table with features in it yet")];
+  const problems: Problem[] = [];
+  const slugs = new Set<string>();
+  for (const row of docs.release) {
+    if (!isSlug(row.slug)) problems.push(error(PATHS.vision, row.line, "release", `"${row.slug}" must be a feature slug: lowercase words joined by single hyphens`));
+    if (slugs.has(row.slug)) problems.push(error(PATHS.vision, row.line, "release", `${row.slug} is listed twice`));
+    slugs.add(row.slug);
+  }
+  for (const row of docs.release) {
+    for (const need of row.needs.filter((n) => !slugs.has(n))) {
+      problems.push(error(PATHS.vision, row.line, "release-needs", `${row.slug} needs ${need}, which isn't a feature of this release`));
+    }
+  }
+  const cycle = findCycle(docs.release.map((r) => [r.slug, r.needs.filter((n) => slugs.has(n))] as const));
+  if (cycle !== undefined) problems.push(error(PATHS.vision, docs.release.find((r) => r.slug === cycle[0])?.line, "release-needs", `features need each other in a circle: ${cycle.join(" → ")}`));
+  return problems;
+}
+
+function findCycle(graph: ReadonlyArray<readonly [string, readonly string[]]>): string[] | undefined {
+  const edges = new Map(graph);
+  const done = new Set<string>();
+  const visit = (node: string, path: string[]): string[] | undefined => {
+    if (path.includes(node)) return [...path.slice(path.indexOf(node)), node];
+    if (done.has(node)) return undefined;
+    for (const next of edges.get(node) ?? []) {
+      const found = visit(next, [...path, node]);
+      if (found !== undefined) return found;
+    }
+    done.add(node);
+    return undefined;
+  };
+  for (const [node] of graph) {
+    const found = visit(node, []);
+    if (found !== undefined) return found;
+  }
+  return undefined;
+}

package/src/domain/validation/validate_project.ts

@@ -1,36 +1,29 @@
-import type { ProjectView } from "../project/project_view.ts";
-import { futureProblems } from "./future_rules.ts";
-import { livingProblems } from "./living_rules.ts";
+import { PATHS } from "../project/layout.ts";
+import type { ProjectDocs } from "../project/project_docs.ts";
+import { documentProblems } from "./document_rules.ts";
 import { error, sortProblems, type Problem } from "./problem.ts";
-import { configProblems, readmeProblems, roadmapProblems, templateLeftovers } from "./project_rules.ts";
-import { visionProblems } from "./vision_rules.ts";
-import { workItemProblems } from "./work_item_rules.ts";
+import { releaseProblems } from "./release_rules.ts";
 
 /** Every rule in the cruze-formats skill, applied to the whole project. */
-export function validateProject(view: ProjectView): Problem[] {
-  const approvalProblems = [...view.approvalProblems].map(([path, message]) => error(path, undefined, "approvals-file", message));
-  const journalProblems = [...view.journalProblems].flatMap(([path, lines]) =>
-    lines.map((line) => error(path, line - 1, "journal-line", "this journal line is not a valid entry")),
-  );
-  return sortProblems([
-    ...configProblems(view),
-    ...livingProblems(view),
-    ...visionProblems(view),
-    ...futureProblems(view),
-    ...roadmapProblems(view),
-    ...workItemProblems(view),
-    ...templateLeftovers(view),
-    ...readmeProblems(view),
-    ...approvalProblems,
-    ...journalProblems,
-  ]);
-}
-
-/** Problems that concern one document. */
-export function problemsFor(problems: Problem[], path: string): Problem[] {
-  return problems.filter((problem) => problem.path === path);
+export function validateProject(docs: ProjectDocs): Problem[] {
+  const config = docs.config === undefined
+    ? [error(PATHS.config, undefined, "config", "the project has no config; run cruze init")]
+    : docs.config.problems.map((message) => error(PATHS.config, undefined, "config", message));
+  const approvals = approvalsFileProblems(docs.snapshot.get(PATHS.approvals));
+  return sortProblems([...config, ...approvals, ...documentProblems(docs), ...releaseProblems(docs)]);
 }
 
 export function hasErrors(problems: Problem[]): boolean {
   return problems.some((problem) => problem.severity === "error");
 }
+
+function approvalsFileProblems(text: string | undefined): Problem[] {
+  if (text === undefined) return [];
+  try {
+    const parsed: unknown = JSON.parse(text);
+    if (!Array.isArray((parsed as { approvals?: unknown }).approvals)) return [error(PATHS.approvals, undefined, "approvals-file", "needs an approvals list; only cruze approve writes this file")];
+    return [];
+  } catch {
+    return [error(PATHS.approvals, undefined, "approvals-file", "not valid JSON; only cruze approve writes this file")];
+  }
+}

package/src/domain/versions/cruze_version.ts

@@ -36,15 +36,9 @@ export function versionSkew(cli: string, recorded: string | undefined): VersionS
  * after `version:`, so the file's comments and layout survive.
  */
 export function withRecordedVersion(configText: string, version: string): string {
-  return withVersionLine(configText, "cruze", version);
-}
-
-/** The config text with a top-level version key, such as `cruze:` or `standards:`, set in place. */
-export function withVersionLine(configText: string, key: "cruze" | "standards", version: string): string {
-  const line = `${key}: ${JSON.stringify(version)}`;
-  const existing = new RegExp(`^${key}:.*$`, "m");
-  if (existing.test(configText)) return configText.replace(existing, line);
-  const anchor = key === "standards" ? /^cruze:.*$/m.exec(configText) ?? /^version:.*$/m.exec(configText) : /^version:.*$/m.exec(configText);
+  const line = `cruze: ${JSON.stringify(version)}`;
+  if (/^cruze:.*$/m.test(configText)) return configText.replace(/^cruze:.*$/m, line);
+  const anchor = /^version:.*$/m.exec(configText);
   if (anchor === null) return `${line}\n${configText}`;
   const end = anchor.index + anchor[0].length;
   return `${configText.slice(0, end)}\n${line}${configText.slice(end)}`;

package/src/main.ts

@@ -10,7 +10,7 @@ import { ProcessAgentRunner } from "./adapters/outbound/process_agent_runner.ts"
 import { SystemClock } from "./adapters/outbound/system_clock.ts";
 import { DefaultAnswerPrompter, TerminalPrompter } from "./adapters/outbound/terminal_prompter.ts";
 
-// A reader that stops early, such as `cruze journal list | head`, closes the pipe; that is not an error worth a stack trace.
+// A reader that stops early, such as `cruze status --text | head`, closes the pipe; that is not an error worth a stack trace.
 process.stdout.on("error", (error: NodeJS.ErrnoException) => {
   if (error.code === "EPIPE") process.exit(0);
   throw error;

package/templates/init/AGENTS.md

@@ -1,28 +1,20 @@
 # {{project_name}}
 
-Instructions for coding agents working in this repository. Cruze keeps the managed sections current as changes land; edit everything else freely.
+Instructions for coding agents working in this repository.
 
 ## Workflow
 
-This project uses [Cruze](https://github.com/PrintPractical/cruze) for spec-driven development. Durable documents live in `docs/`: vision, glossary, architecture, ADRs, specs and roadmap. Work in progress lives in `.cruze/`. Before changing code, read the design the change builds with `cruze show <change>`, once it exists. Each Cruze step runs in a new session, so its context holds what the step reads and nothing else. The Cruze skills run the `cruze` command; when it is missing, install it as https://github.com/PrintPractical/cruze#quick-start describes.
+This project uses [Cruze](https://github.com/PrintPractical/cruze). `docs/vision.md` says what the product is for and which features the release holds; `docs/architecture.md` maps its ports, adapters and runtime; each `docs/features/<slug>.md` holds one feature's behaviour, public API and stack sketch, approved by the user before it is built. Run `cruze next` to see what comes next. The Cruze skills run the `cruze` command; when it is missing, install it as https://github.com/PrintPractical/cruze#quick-start describes.
 
 ## Commands
 
-<!-- cruze:managed -->
-No build or test commands yet. `cruze land` fills this in when the foundation change lands.
-<!-- /cruze:managed -->
+No build or test commands yet. The foundation feature fills this in.
 
 ## Layout
 
-<!-- cruze:managed -->
-Not defined yet. `cruze land` fills this in from the module map in `docs/architecture.md`.
-<!-- /cruze:managed -->
+Not defined yet. The foundation feature fills this in from `docs/architecture.md`.
 
 ## Conventions
 
 - Commit messages follow [Conventional Commits](https://www.conventionalcommits.org/).
 - Record notable changes under `[Unreleased]` in `CHANGELOG.md`.
-
-## Known pitfalls
-
-None recorded yet. `land` adds a line here when the same review finding or defect about this project's code happens twice.

package/templates/init/ci.yml

@@ -13,11 +13,11 @@ jobs:
       - uses: actions/setup-node@v5
         with:
           node-version: 22
-      # The foundation change adds the language's format, lint, build and
-      # test steps here, from `commands:` in .cruze/config.yaml.
+      # The foundation feature adds the language's format, lint, build and
+      # test steps here, with a coverage gate.
       - name: Documents match the Cruze formats
         run: npx --yes --package={{cruze_package}} cruze validate
       - name: Layer rules and file budgets
         run: npx --yes --package={{cruze_package}} cruze check --ci
       - name: Every built scenario has a test
-        run: npx --yes --package={{cruze_package}} cruze trace --all
+        run: npx --yes --package={{cruze_package}} cruze trace

package/templates/init/config.yaml

@@ -1,33 +1,24 @@
 # Cruze project configuration, created by cruze {{cruze_version}}.
-# The format is described in .agents/skills/cruze-formats/reference/config.md.
-version: 1
+# The format is described in .agents/skills/cruze-formats/config.md.
+version: 2
 # The Cruze whose skills this project installed. `cruze install` keeps it current.
 cruze: "{{cruze_version}}"
-# The Cruze whose expectations the code meets. `realign` moves it forward.
-standards: "{{cruze_version}}"
 project: {{project_name_quoted}}
 
-# Where work items are tracked. V1 supports markdown in the repository only.
-tracker: markdown
-
-# Source files `cruze check` inspects, and files `cruze trace` searches for
-# scenario IDs. Project-scope architecture design sets these.
+# Source files `cruze check` inspects, and test files `cruze trace` searches
+# for scenario IDs. The foundation feature sets these.
 source: []
 tests: []
 
-# Budgets enforced by `cruze check`: a backstop against a file that has
-# outgrown one responsibility, not a size to design to. List a file under
-# exceptions, with a reason, to allow it past a budget.
+# Budgets `cruze check` warns on: a backstop against a file that has outgrown
+# one responsibility, not a size to design to. List a file under exceptions,
+# with a reason, to allow it past a budget.
 check:
   max_lines: 600
   max_types: 12
   exceptions: []
 
-# Layer rules, written by project-scope architecture design from the module map.
+# Layer rules from docs/architecture.md: which layer may import which.
 layers: []
 
-# The project's commands, by name, such as `test: cargo test`. The
-# foundation change fills them in; `cruze land` copies them into AGENTS.md.
-commands: {}
-
 {{review_setting}}

package/templates/init/review/claude.yaml

@@ -1,7 +1,7 @@
 # How `cruze review` starts an agent in a fresh context to run a role, with the
 # prompt on standard input. This lets Claude Code read the project and run git
-# and cruze. The verifier runs the system, so add the project's build and run
-# commands, such as "Bash(cargo:*)". Without review.command, your agent runs each
+# and cruze. To let the reviewer run the tests, add the project's test
+# command, such as "Bash(cargo test:*)". Without review.command, your agent runs each
 # role in a helper of its own.
 review:
   command: ["claude", "-p", "--allowedTools", "Read Grep Glob Bash(git diff:*) Bash(git log:*) Bash(git show:*) Bash(cruze:*)"]

package/dist/adapters/inbound/cli/argument_files.js

@@ -1,29 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { UsageError } from "./cli_context.js";
-
-// Files a person or agent names on the command line, such as a scratch file of review blockers or
-// the path for an exported bundle. They may be anywhere, unlike project files, and relative paths
-// resolve against the working directory.
-
-export async function readArgumentFile(path        )                  {
-  try {
-    return await readFile(resolve(path), "utf8");
-  } catch (error) {
-    throw new UsageError(`cannot read ${path}: ${reason(error)}`);
-  }
-}
-
-export async function writeArgumentFile(path        , text        )                {
-  try {
-    await mkdir(dirname(resolve(path)), { recursive: true });
-    await writeFile(resolve(path), text, "utf8");
-  } catch (error) {
-    throw new UsageError(`cannot write ${path}: ${reason(error)}`);
-  }
-}
-
-function reason(error         )         {
-  if (error instanceof Error && "code" in error && typeof error.code === "string") return error.code;
-  return error instanceof Error ? error.message : String(error);
-}

package/dist/adapters/inbound/cli/commands/diff.js

@@ -1,23 +0,0 @@
-import { upstreamDiff,                         } from "../../../../app/use_cases/upstream_diff.js";
-import { requireArgs,                                     } from "../cli_context.js";
-
-export async function runDiff(context            , args          )                         {
-  requireArgs(args, ["ref"]);
-  const report = await upstreamDiff(context, args[0] ?? "");
-  return { json: report, human: render(report) };
-}
-
-function render(report                    )         {
-  const lines = [`${report.artifact}: ${report.state}`];
-  if (report.changes.length === 0) lines.push("Nothing it cites changed since its approval.");
-  for (const change of report.changes) {
-    lines.push("", `${change.key}${change.path === undefined ? "" : ` in ${change.path}`}:`);
-    lines.push(...(change.diff ?? [change.note ?? ""]).map((line) => `  ${line}`));
-  }
-  if (report.rebase.length > 0) {
-    lines.push("", `Its delta changes ${report.rebase.join(", ")}: rewrite the delta to keep the new text, then approve with ${report.rebase.map((id) => `--rebase ${id}`).join(" ")}.`);
-  } else if (report.ref !== undefined && report.state === "upstream-changed") {
-    lines.push("", `No rebase needed. When the work still holds against this, re-stamp it with cruze approve ${report.ref} --restamp-unchanged.`);
-  }
-  return lines.join("\n");
-}

package/dist/adapters/inbound/cli/commands/journal.js

@@ -1,32 +0,0 @@
-import { exportFeedback, listEvents, recordEvent } from "../../../../app/use_cases/journal_events.js";
-import { writeArgumentFile } from "../argument_files.js";
-import { UsageError, requireArgs,                                                   } from "../cli_context.js";
-
-export async function runJournal(context            , args          , options         )                         {
-  requireArgs(args, ["add|list"]);
-  if (args[0] === "add") {
-    requireArgs(args, ["add", "event"]);
-    const fields = Object.fromEntries(options.set.map((pair) => {
-      const at = pair.indexOf("=");
-      if (at < 1) throw new UsageError(`--set takes key=value, not "${pair}"`);
-      return [pair.slice(0, at), pair.slice(at + 1)];
-    }));
-    const entry = await recordEvent(context, args[1] ?? "", fields, options.item);
-    return { json: entry, human: `Recorded ${entry.event}.` };
-  }
-  if (args[0] === "list") {
-    const entries = await listEvents(context, options.event, options.item, options.all);
-    return { json: entries, human: entries.map((e) => `${e.at} ${e.event} ${JSON.stringify({ ...e, at: undefined, event: undefined, by: undefined })}`).join("\n") || "No entries." };
-  }
-  throw new UsageError(`cruze journal takes add or list, not "${args[0]}"`);
-}
-
-export async function runFeedback(context            , args          , options         )                         {
-  if (args[0] !== "export") throw new UsageError("usage: cruze feedback export [--out <file>] [--no-redact]");
-  const bundle = await exportFeedback(context, options.redact);
-  if (options.out !== undefined) {
-    await writeArgumentFile(options.out, `${JSON.stringify(bundle, null, 2)}\n`);
-    return { json: { out: options.out, entries: bundle.entries.length }, human: `Wrote ${bundle.entries.length} entries to ${options.out}.` };
-  }
-  return { json: bundle, human: `${bundle.entries.length} journal entries${bundle.redacted ? ", redacted" : ""}.` };
-}

package/dist/adapters/inbound/cli/commands/progress.js

@@ -1,55 +0,0 @@
-import { addFutureFeature, completeTask, dropFutureFeature, updateFeatureSummary, pruneRoadmap, recordDeviation, reopenTask } from "../../../../app/use_cases/record_progress.js";
-import { abandonWork } from "../../../../app/use_cases/abandon_work.js";
-import { UsageError, requireArgs, requireOption,                                                   } from "../cli_context.js";
-
-export async function runTask(context            , args          , options         )                         {
-  requireArgs(args, ["done|deviation|reopen", "task"]);
-  const change = options.change === undefined ? {} : { change: options.change };
-  if (args[0] === "done") {
-    const report = await completeTask(context, args[1] ?? "", { ...change, ...(options.commit === undefined ? {} : { commit: options.commit }) });
-    return { json: report, human: `${report.task} done in ${report.change} (${report.done}/${report.total}).` };
-  }
-  if (args[0] === "deviation") {
-    requireArgs(args, ["deviation", "task", "text"]);
-    const report = await recordDeviation(context, args[1] ?? "", args.slice(2).join(" "), change);
-    return { json: report, human: `Recorded a deviation on ${report.task} in ${report.change}.` };
-  }
-  if (args[0] === "reopen") {
-    requireArgs(args, ["reopen", "task", "reason"]);
-    const report = await reopenTask(context, args[1] ?? "", args.slice(2).join(" "), change);
-    return { json: report, human: `Reopened ${report.task} in ${report.change}.` };
-  }
-  throw new UsageError(`cruze task takes done, deviation or reopen, not "${args[0]}"`);
-}
-
-export async function runFeatures(context            , args          , options         )                         {
-  requireArgs(args, ["add|update|drop", "slug"]);
-  if (args[0] === "add") {
-    const goals = (options.goals ?? "").split(",").map((g) => g.trim()).filter((g) => g !== "");
-    const report = await addFutureFeature(context, args[1] ?? "", requireOption(options.summary, "--summary"), goals);
-    return { json: report, human: `Added ${report.feature} to the future list.` };
-  }
-  if (args[0] === "update") {
-    const report = await updateFeatureSummary(context, args[1] ?? "", requireOption(options.summary, "--summary"));
-    return { json: report, human: `Updated the summary of ${report.feature} on the ${report.list === "Future" ? "future" : "implemented"} list.` };
-  }
-  if (args[0] === "drop") {
-    const report = await dropFutureFeature(context, args[1] ?? "", requireOption(options.reason, "--reason"));
-    return { json: report, human: `Dropped ${report.feature} from the future list.` };
-  }
-  throw new UsageError(`cruze features takes add, update or drop, not "${args[0]}"`);
-}
-
-export async function runRoadmap(context            , args          )                         {
-  requireArgs(args, ["prune"]);
-  if (args[0] !== "prune") throw new UsageError(`cruze roadmap takes prune, not "${args[0]}"`);
-  const report = await pruneRoadmap(context);
-  return { json: report, human: report.removed.length === 0 ? "No landed items to clear." : `Cleared ${report.removed.join(", ")} from the roadmap status.` };
-}
-
-export async function runAbandon(context            , args          , options         )                         {
-  requireArgs(args, ["ref"]);
-  const report = await abandonWork(context, args[0] ?? "", requireOption(options.reason, "--reason"));
-  const back = report.futureList === undefined ? "" : ` ${report.futureList} is back on the future list.`;
-  return { json: report, human: `Abandoned ${report.ref}; archived to ${report.archivedTo}.${back}` };
-}

package/dist/adapters/inbound/cli/commands/realign.js

@@ -1,28 +0,0 @@
-import { realignDone } from "../../../../app/use_cases/realign_done.js";
-import { realignStatus } from "../../../../app/use_cases/realign_status.js";
-import { UsageError, requireArgs,                                                   } from "../cli_context.js";
-
-export async function runRealign(context            , args          , options         )                         {
-  requireArgs(args, ["status|done"]);
-  if (args[0] === "status") {
-    const report = await realignStatus(context, { full: options.full });
-    const lines = [`Code meets Cruze ${report.standards}; the installed skills are ${report.target}${report.full ? " (full audit)" : ""}.`];
-    for (const note of report.notes) {
-      const open = note.findings.filter((f) => !f.waived);
-      const how = note.detect !== undefined ? `${open.length} open finding(s) from ${note.detect}` : `for the auditor: ${note.ask ?? ""}`;
-      lines.push(`${note.version} ${note.id}: ${note.title} (${how})`);
-      for (const f of open) lines.push(`  ${f.path}${f.line === undefined ? "" : `:${f.line}`} ${f.message}`);
-    }
-    if (report.newWorkOnly.length > 0) lines.push(`New work only, nothing to move: ${report.newWorkOnly.join(", ")}`);
-    if (report.notes.length === 0) lines.push("Nothing to realign.");
-    return { json: report, human: lines.join("\n") };
-  }
-  if (args[0] === "done") {
-    const report = await realignDone(context, options.change === undefined ? {} : { change: options.change });
-    const lines = [report.from === report.to ? `The code already meets Cruze ${report.to}.` : `The code now meets Cruze ${report.to}, up from ${report.from}.`];
-    if (report.scheduled !== undefined) lines.push(`${report.scheduled} fixes the rest.`);
-    if (report.excepted.length > 0) lines.push(`Listed under check.exceptions until it lands: ${report.excepted.join(", ")}`);
-    return { json: report, human: lines.join("\n") };
-  }
-  throw new UsageError(`cruze realign takes status or done, not "${args[0]}"`);
-}

package/dist/adapters/inbound/cli/commands/show.js

@@ -1,96 +0,0 @@
-import { showElements, showIndex } from "../../../../app/use_cases/show_elements.js";
-import { showNotes } from "../../../../app/use_cases/show_notes.js";
-                                                                          
-import { showScope,                  } from "../../../../app/use_cases/show_scope.js";
-import { isId } from "../../../../domain/ids.js";
-                                                                                 
-                                                                             
-import { UsageError, requireArgs,                                                   } from "../cli_context.js";
-
-export async function runShow(context            , args          , options         )                         {
-  if (options.notes) {
-    if (args.length > 1 || options.index) throw new UsageError("--notes takes at most one target: project, a step, a feature slug or a context");
-    const report = await showNotes(context, args[0]);
-    return { json: report, human: "target" in report ? renderNotesFor(report).join("\n").trimEnd() : renderNotes(report.notes) };
-  }
-  if (options.index) {
-    if (args.length > 1) throw new UsageError("--index takes at most one context or capability");
-    const index = await showIndex(context, args[0]);
-    return { json: index, human: renderIndex(index) };
-  }
-  requireArgs(args, ["ref"]);
-  if (args.every(isId)) {
-    const report = await showElements(context, args);
-    return { json: report, human: blocks(report.elements).join("\n").trimEnd() };
-  }
-  if (args.length > 1) throw new UsageError("show takes one feature or change, or one or more element IDs");
-  const report = await showScope(context, args[0] ?? "");
-  return { json: report, human: render(report) };
-}
-
-/** The index as a list an agent scans for what exists, before fetching bodies with `cruze show <ID>`. */
-function renderIndex(index              )         {
-  const { architecture, specs } = index.words;
-  const lines = [`# Elements`, "", `docs/architecture.md holds ${architecture} words, and docs/specs/ ${specs}. Read an element's body with \`cruze show <ID>\`.`];
-  let source = "";
-  for (const entry of [...index.entries].sort((a, b) => Number(a.addedBy !== undefined) - Number(b.addedBy !== undefined))) {
-    const heading = entry.addedBy === undefined ? entry.source : "In flight, not yet merged";
-    if (heading !== source) lines.push("", `## ${heading}`, "");
-    source = heading;
-    const facts = [
-      entry.status,
-      entry.place,
-      entry.scenarios === undefined ? undefined : `${entry.scenarios} scenarios`,
-      entry.addedBy === undefined ? undefined : `added by ${entry.addedBy}`,
-      entry.changedBy.length === 0 ? undefined : `changed by ${entry.changedBy.join(", ")}`,
-    ].filter((f) => f !== undefined);
-    lines.push(`- ${entry.id}: ${entry.title}${facts.length === 0 ? "" : ` (${facts.join("; ")})`}`);
-  }
-  return lines.join("\n");
-}
-
-/** The scope as a document an agent reads in place of the living docs. */
-function render(report             )         {
-  const lines = [`# ${report.ref}${report.feature === undefined ? "" : ` (feature ${report.feature})`}`, ""];
-  lines.push("## Elements", "", ...blocks(report.elements), "## Scenarios", "", ...blocks(report.scenarios));
-  lines.push("## Cited, not shown", "");
-  lines.push(...(report.cited.length === 0 ? ["None."] : report.cited.map((c) => `- ${c.id}: ${c.title} (${c.source})`)), "");
-  if (report.feature === undefined) lines.push("## Settled decisions", "", ...(report.decisions.length === 0 ? ["None."] : report.decisions), "");
-  else {
-    lines.push("## Settled decisions of the feature", "", ...(report.decisions.length === 0 ? ["None."] : report.decisions), "");
-    lines.push("## Settled decisions of the change", "", ...(report.changeDecisions.length === 0 ? ["None."] : report.changeDecisions), "");
-  }
-  lines.push("## Dispositions", "");
-  lines.push(...(report.dispositions.length === 0 ? ["None."] : report.dispositions.map((d) => `- [${d.disposition}, ${d.review}] ${d.finding}: ${d.reason}`)), "");
-  if (report.references.length > 0) lines.push("## References", "", ...report.references.map((r) => `- \`${r.path}\`: ${r.use}`), "");
-  lines.push(...renderNotesFor(report.notes));
-  if (report.missing.length > 0) lines.push("## Missing", "", ...report.missing.map((id) => `- ${id} is defined nowhere`), "");
-  return lines.join("\n").trimEnd();
-}
-
-function blocks(elements                )           {
-  if (elements.length === 0) return ["None.", ""];
-  return elements.flatMap((element) => [`<!-- ${element.source} -->`, ...element.body.join("\n").trimEnd().split("\n"), ""]);
-}
-
-/** The notes about a piece of work and the parts of the user's input handed to it; nothing when there are none. */
-function renderNotesFor(found          )           {
-  if (found.notes.length === 0 && found.handoffs.length === 0) return [];
-  return [
-    "## Notes",
-    "",
-    ...found.notes.map((n) => `- \`${n.path}\`: ${n.title}${n.kind === undefined ? "" : ` (${n.kind})`}`),
-    ...found.handoffs.map((h) => `- ${h.part}, from ${h.source} (${h.status}, handed off in \`${h.note}\`)`),
-    "",
-  ];
-}
-
-function renderNotes(notes        )         {
-  if (notes.length === 0) return "No notes.";
-  return notes
-    .flatMap((n) => [
-      `- \`${n.path}\`: ${n.title} (${n.kind ?? "no kind"}; about ${n.about.length === 0 ? "nothing named" : n.about.join(", ")})`,
-      ...n.handoff.map((h) => `  - ${h.part} goes to ${h.goesTo} (${h.status})`),
-    ])
-    .join("\n");
-}