@printpractical/cruze 0.0.13 → 0.0.15

package/src/app/use_cases/project_status.ts

@@ -1,82 +1,58 @@
-import { CruzeError } from "../../domain/cruze_error.ts";
+import { approvalState, type ApprovalState } from "../../domain/approvals.ts";
 import { PATHS } from "../../domain/project/layout.ts";
-import { readProgress } from "../../domain/project/progress.ts";
-import { buildProjectView } from "../../domain/project/project_view.ts";
-import { findWorkItem, type WorkItem } from "../../domain/project/work_items.ts";
-import { nextSteps, type NextReport } from "../../domain/status/next_step.ts";
-import { activeChange, buildGateReasons, projectStatus, touchedIds, type ProjectStatus } from "../../domain/status/work_status.ts";
-import { appendJournal, loadView, type ProjectDeps } from "../project_context.ts";
+import type { MarkdownDoc } from "../../domain/markdown.ts";
+import { nextStep, type NextStep } from "../../domain/next_step.ts";
+import type { FeatureStatus } from "../../domain/project/features.ts";
+import { loadDocs, type ProjectDeps } from "../project_context.ts";
 
-export interface StatusReport extends ProjectStatus {
-  branch: string | null;
+export interface DocumentStatus {
+  path: string;
+  state: ApprovalState | "missing";
 }
 
-export async function showStatus(deps: ProjectDeps): Promise<StatusReport> {
-  const branch = await deps.repository.currentBranch();
-  return { branch, ...projectStatus(await loadView(deps.files), branch) };
-}
-
-/** The step to run next on this branch, and other work that could proceed. */
-export async function suggestNext(deps: ProjectDeps): Promise<NextReport & { branch: string | null }> {
-  const branch = await deps.repository.currentBranch();
-  return { branch, ...nextSteps(await loadView(deps.files), branch) };
-}
-
-export interface GateReport {
-  gate: "build";
-  passed: boolean;
-  reasons: string[];
-  overridden: boolean;
+export interface FeatureReport {
+  slug: string;
+  path?: string;
+  /** Missing when the release lists it but nobody has shaped it yet. */
+  status: FeatureStatus | "not-shaped" | "unknown";
+  approval: ApprovalState | "missing";
+  inRelease: boolean;
+  needs: string[];
+  scenarios: number;
 }
 
-/**
- * The build gate: the change bound to this branch, its feature and the architecture are
- * all approved and current. An override passes the gate and is journaled with its reason.
- */
-export async function checkBuildGate(deps: ProjectDeps, override?: string): Promise<GateReport> {
-  const view = await loadView(deps.files);
-  const branch = await deps.repository.currentBranch();
-  const reasons = buildGateReasons(view, branch);
-  if (reasons.length === 0) return { gate: "build", passed: true, reasons, overridden: false };
-  if (override === undefined) return { gate: "build", passed: false, reasons, overridden: false };
-  if (override.trim() === "") throw new CruzeError("override-reason", "an override needs a reason");
-  const folder = activeChange(view, branch)?.folder ?? ".cruze";
-  await appendJournal(deps, folder, "override", { gate: "build", reason: override, blocked_by: reasons });
-  return { gate: "build", passed: true, reasons, overridden: true };
+export interface StatusReport {
+  documents: DocumentStatus[];
+  features: FeatureReport[];
+  next: NextStep;
 }
 
-export interface Overlap {
-  branch: string;
-  item: string;
-  shared: string[];
-}
-
-/** In-flight work on other branches that touches the same elements as this branch's change. */
-export async function findOverlaps(deps: ProjectDeps, ref?: string): Promise<{ change: string; overlaps: Overlap[] }> {
-  const view = await loadView(deps.files);
-  const branch = await deps.repository.currentBranch();
-  const change = ref === undefined ? activeChange(view, branch) : view.items.find((item) => item.ref === ref);
-  if (change === undefined) throw new CruzeError("no-active-change", "no change is bound to this branch; name one with --change");
-  const mine = touchedIds(view, change);
-  const overlaps: Overlap[] = [];
-  for (const other of await deps.repository.otherBranches()) {
-    // Landed work is archived, so a branch's work in flight is under features/ and changes/ only.
-    const inFlight = [...(await deps.repository.filesOnBranch(other, PATHS.featuresDir)), ...(await deps.repository.filesOnBranch(other, PATHS.changesDir))];
-    const theirs = buildProjectView(new Map([...view.snapshot].filter(([p]) => p.startsWith("docs/")).concat(inFlight)));
-    // Work in flight on a branch is the change bound to it that hasn't landed, there or here.
-    const boundThere = theirs.items.filter((i) => {
-      const bound = readProgress(i.doc).branch;
-      const here = findWorkItem(view.items, i.ref);
-      return !landed(i) && (here === undefined || !landed(here)) && i.ref !== change.ref && bound !== undefined && (other === bound || other.endsWith(`/${bound}`));
-    });
-    for (const item of boundThere) {
-      const shared = [...touchedIds(theirs, item)].filter((id) => mine.has(id));
-      if (shared.length > 0) overlaps.push({ branch: other, item: item.ref, shared: shared.sort() });
-    }
-  }
-  return { change: change.ref, overlaps };
-}
-
-function landed(item: WorkItem): boolean {
-  return item.archived || readProgress(item.doc).landed !== undefined;
+/** Each document's approval, and each feature's progress, in release order. */
+export async function showStatus(deps: ProjectDeps): Promise<StatusReport> {
+  const docs = await loadDocs(deps.files);
+  const state = (path: string, doc: MarkdownDoc | undefined): ApprovalState | "missing" => (doc === undefined ? "missing" : approvalState(docs.approvals, path, doc));
+  const documents = [
+    { path: PATHS.vision, state: state(PATHS.vision, docs.vision) },
+    { path: PATHS.architecture, state: state(PATHS.architecture, docs.architecture) },
+  ];
+  const slugs = [...docs.release.map((r) => r.slug), ...docs.features.map((f) => f.slug).filter((s) => !docs.release.some((r) => r.slug === s))];
+  const features = slugs.map((slug): FeatureReport => {
+    const feature = docs.features.find((f) => f.slug === slug);
+    const row = docs.release.find((r) => r.slug === slug);
+    return {
+      slug,
+      ...(feature === undefined ? {} : { path: feature.path }),
+      status: feature === undefined ? "not-shaped" : (feature.status ?? "unknown"),
+      approval: feature === undefined ? "missing" : approvalState(docs.approvals, feature.path, feature.doc),
+      inRelease: row !== undefined,
+      needs: row?.needs ?? [],
+      scenarios: feature?.scenarios.length ?? 0,
+    };
+  });
+  return { documents, features, next: nextStep(docs) };
+}
+
+/** The step to run next, and why. */
+export async function suggestNext(deps: ProjectDeps): Promise<NextStep> {
+  return nextStep(await loadDocs(deps.files));
 }

package/src/app/use_cases/run_review.ts

@@ -1,20 +1,14 @@
 import { CruzeError } from "../../domain/cruze_error.ts";
-import { resolveArtifact } from "../../domain/project/artifact_ref.ts";
-import { isPlanned } from "../../domain/project/plan_parts.ts";
-import { featureOf, type WorkItem } from "../../domain/project/work_items.ts";
 import type { AgentRunner } from "../ports/agent_runner.ts";
-import { loadView, type ProjectDeps } from "../project_context.ts";
+import { loadDocs, type ProjectDeps } from "../project_context.ts";
 
-export const ROLES = ["design-reviewer", "code-reviewer", "verifier", "researcher", "auditor", "surveyor"] as const;
+export const ROLES = ["code-reviewer", "researcher"] as const;
 export type Role = (typeof ROLES)[number];
 
 export interface ReviewRequest {
   role: string;
-  /** The feature or change under review; omitted for project-scope documents. */
+  /** The feature under review, by slug. */
   item?: string;
-  round?: number;
-  /** The round-1 blockers, for round 2. */
-  blockers?: string;
   /** The commit the diff under review starts from. */
   base?: string;
 }
@@ -30,37 +24,31 @@ export type ReviewReport = { role: Role; item?: string; command?: string[] } & (
 
 /**
  * Runs a Cruze role in a fresh agent context: the role's prompt, what it reviews, and nothing
- * from the conversation that produced the work. Returns the role's report as written, or the
- * prompt to run in a helper when the configured agent isn't installed.
+ * from the conversation that produced the work.
  */
 export async function runReview(deps: ProjectDeps & { runner: AgentRunner }, request: ReviewRequest): Promise<ReviewReport> {
   if (!(ROLES as readonly string[]).includes(request.role)) throw new CruzeError("unknown-role", `the roles are ${ROLES.join(", ")}`);
   const role = request.role as Role;
-  const view = await loadView(deps.files);
+  const docs = await loadDocs(deps.files);
   const roleText = (await deps.files.readText(`.agents/skills/cruze-roles/${role}.md`)) ?? (await bundledRole(deps, role));
 
-  const context = [`Round: ${request.round ?? 1}`];
+  const context: string[] = [];
   if (request.item !== undefined) {
-    const { path, item } = resolveArtifact(view, request.item);
-    context.push(`Under review: ${item?.ref ?? path} (\`${path}\`)`);
-    const feature = item === undefined ? undefined : featureOf(view.items, item);
-    if (feature !== undefined) context.push(`Its feature: \`${feature.path}\``);
-    if (role === "design-reviewer" && item !== undefined) context.push(rubricLine(item));
-  } else {
-    context.push("Under review: the project documents the role lists for project scope");
+    const feature = docs.features.find((f) => f.slug === request.item);
+    if (feature === undefined) throw new CruzeError("not-found", `no feature ${request.item} in docs/features/`);
+    context.push(`Under review: the feature in \`${feature.path}\``);
   }
   if (request.base !== undefined) context.push(`The changes under review: run \`git diff ${request.base}\`.`);
-  if (request.blockers !== undefined) context.push(`Round-1 blockers to check:\n\n${request.blockers}`);
 
   const prompt = [
     roleText.trim(),
     "## This run",
     "You are running the role above in a fresh context, in the project's repository. Read every input it lists from the files, and run the commands it names. Edit no files. End with the report the role describes.",
-    context.map((line) => `- ${line}`).join("\n"),
+    ...(context.length === 0 ? [] : [context.map((line) => `- ${line}`).join("\n")]),
   ].join("\n\n");
 
   const subject = { role, ...(request.item === undefined ? {} : { item: request.item }) };
-  const command = view.config?.config?.review.command;
+  const command = docs.config?.config?.review.command;
   if (command === undefined) return { ...subject, status: "run-in-helper", instruction: helperInstruction(undefined), prompt };
   const run = await deps.runner.run(command, prompt);
   if (run.kind === "missing") return { ...subject, command, status: "run-in-helper", instruction: helperInstruction(command[0]), prompt };
@@ -84,10 +72,3 @@ async function bundledRole(deps: ProjectDeps, role: Role): Promise<string> {
   if (file === undefined) throw new CruzeError("role-missing", `the ${role} role is not installed; run cruze install`);
   return file.text;
 }
-
-/** A design reviewer reads one rubric: the plan rubric for a planned change, the design rubric otherwise. */
-function rubricLine(item: WorkItem): string {
-  return item.kind !== "feature" && isPlanned(item.doc)
-    ? "This is a change's plan: review it against `.agents/skills/cruze-roles/plan-rubric.md`."
-    : "This is a design: review it against `.agents/skills/cruze-roles/design-rubric.md`.";
-}

package/src/app/use_cases/validate_project.ts

@@ -1,10 +1,12 @@
 import { hasErrors, validateProject } from "../../domain/validation/validate_project.ts";
 import { warning, type Problem } from "../../domain/validation/problem.ts";
 import { PATHS } from "../../domain/project/layout.ts";
+import { reviewSettingTemplate } from "../../domain/scaffold.ts";
+import { reviewCommandProblems } from "../../domain/validation/review_rules.ts";
 import { versionSkew } from "../../domain/versions/cruze_version.ts";
 import type { Bundle } from "../ports/bundle.ts";
-import { loadView } from "../project_context.ts";
 import type { ProjectFiles } from "../ports/project_files.ts";
+import { loadDocs } from "../project_context.ts";
 
 export interface ValidateReport {
   valid: boolean;
@@ -13,12 +15,13 @@ export interface ValidateReport {
   problems: Problem[];
 }
 
-/** Checks every document in the project against the cruze-formats rules, and that its skills match this CLI. */
+/** Checks every document in the project against the cruze-formats rules, that its skills match this CLI, and that its reviewer can run the tests. */
 export async function validate(deps: { files: ProjectFiles; bundle: Bundle }): Promise<ValidateReport> {
-  const view = await loadView(deps.files);
-  const config = view.config?.config;
+  const docs = await loadDocs(deps.files);
+  const config = docs.config?.config;
   const skew = config === null || config === undefined ? undefined : versionSkew(deps.bundle.version, config.cruze);
-  const problems = [...validateProject(view), ...(skew === undefined ? [] : [warning(PATHS.config, undefined, "cruze-version", skew.message)])];
+  const review = reviewCommandProblems(docs, await deps.bundle.template(reviewSettingTemplate("claude")));
+  const problems = [...validateProject(docs), ...(skew === undefined ? [] : [warning(PATHS.config, undefined, "cruze-version", skew.message)]), ...review];
   return {
     valid: !hasErrors(problems),
     errors: problems.filter((p) => p.severity === "error").length,

package/src/domain/approvals.ts

@@ -0,0 +1,51 @@
+import { designHash } from "./hashing.ts";
+import type { MarkdownDoc } from "./markdown.ts";
+import { slugOfFeaturePath } from "./project/layout.ts";
+
+/** One approval of one document: the hash of its design content when the user approved it. */
+export interface ApprovalRecord {
+  path: string;
+  hash: string;
+  approvedAt: string;
+  by: string;
+}
+
+export type ApprovalState = "approved" | "edited" | "unapproved";
+
+/** Reads `.cruze/approvals.json`; anything unreadable counts as no approvals, and validate reports it. */
+export function parseApprovals(text: string | undefined): ApprovalRecord[] {
+  if (text === undefined) return [];
+  try {
+    const parsed: unknown = JSON.parse(text);
+    const list = (parsed as { approvals?: unknown }).approvals;
+    if (!Array.isArray(list)) return [];
+    return list.filter((r): r is ApprovalRecord => typeof r?.path === "string" && typeof r?.hash === "string" && typeof r?.approvedAt === "string" && typeof r?.by === "string");
+  } catch {
+    return [];
+  }
+}
+
+export function serializeApprovals(records: ApprovalRecord[]): string {
+  const sorted = [...records].sort((a, b) => a.path.localeCompare(b.path));
+  return `${JSON.stringify({ version: 2, approvals: sorted }, null, 2)}\n`;
+}
+
+/** The records with this one replacing any earlier approval of the same document. */
+export function withApproval(records: ApprovalRecord[], record: ApprovalRecord): ApprovalRecord[] {
+  return [...records.filter((r) => r.path !== record.path), record];
+}
+
+/**
+ * The hash an approval records. A feature's `## Decisions` is the agent's record of what it chose,
+ * which build and review add to, so it stays out: the user's approval covers the rest.
+ */
+export function approvalHash(path: string, doc: MarkdownDoc): string {
+  return designHash(doc, slugOfFeaturePath(path) === undefined ? [] : ["Decisions"]);
+}
+
+/** Whether the document still reads as it did when it was approved. */
+export function approvalState(records: readonly ApprovalRecord[], path: string, doc: MarkdownDoc): ApprovalState {
+  const record = records.find((r) => r.path === path);
+  if (record === undefined) return "unapproved";
+  return record.hash === approvalHash(path, doc) ? "approved" : "edited";
+}

package/src/domain/check/check_source.ts

@@ -1,36 +1,29 @@
 import type { CruzeConfig, Layer } from "../config.ts";
 import { matchesAny } from "../glob.ts";
 import { budgetedText } from "./budget_text.ts";
-import { decisionCitationsInComments } from "./decision_comments.ts";
 import { importsOf, resolveImport } from "./imports.ts";
 import { countTypes } from "./type_count.ts";
 
 export interface CheckFinding {
   path: string;
   line?: number;
-  rule: "layer" | "max-lines" | "max-types" | "outside-module-map" | "no-layer" | "test-placement" | "decision-citation";
+  rule: "layer" | "max-lines" | "max-types" | "no-layer" | "test-placement";
   message: string;
   /** Layer violations always fail; the rest fail in CI unless excepted. */
   severity: "error" | "warning";
-  /** Set when the rule is newer than the project's `standards:`: it reports, but can't fail CI until the project realigns. */
-  pending?: true;
 }
 
 export interface CheckInput {
   config: CruzeConfig;
   /** Every source file matched by config.source, by path. */
   sources: ReadonlyMap<string, string>;
-  /** Paths of the MOD elements in the architecture; files outside all of them are flagged. */
-  modulePaths: string[];
-  /** Test files outside config.source, by path: only their comments are checked. */
-  tests?: ReadonlyMap<string, string>;
   /** Check only these files, when given; imports still resolve against every source. */
   only?: string[];
 }
 
 /** Enforces the architecture's layer rules and the file budgets on source code. */
 export function checkSource(input: CheckInput): CheckFinding[] {
-  const { config, sources, modulePaths } = input;
+  const { config, sources } = input;
   const all = [...sources.keys()];
   const targets = input.only ?? all;
   const layerOf = (path: string): Layer | undefined => config.layers.find((layer) => matchesAny(path, layer.paths));
@@ -44,7 +37,7 @@ export function checkSource(input: CheckInput): CheckFinding[] {
       findings.push({ path, rule: "no-layer", severity: "warning", message: "the file is in no layer, so its imports are unchecked" });
     }
     if (layer !== undefined) {
-      for (const found of importsOf(path, text)) {
+      for (const found of importsOf(path, text, all)) {
         const target = resolveImport(found, all);
         const targetLayer = target === undefined ? undefined : layerOf(target);
         if (target === undefined || targetLayer === undefined || targetLayer.name === layer.name) continue;
@@ -67,32 +60,10 @@ export function checkSource(input: CheckInput): CheckFinding[] {
     if (!excepted && isRustTestFileInSource(path)) {
       findings.push({ path, rule: "test-placement", severity: "warning", message: "Rust tests that leave their inline module go in the crate's tests/ directory, not under src/" });
     }
-    if (modulePaths.length > 0 && !insideModuleMap(path, modulePaths)) {
-      findings.push({ path, rule: "outside-module-map", severity: "warning", message: "the file is outside every module in the architecture's module map" });
-    }
-    findings.push(...decisionFindings(path, text));
-  }
-  for (const [path, text] of input.tests ?? []) {
-    if (!sources.has(path) && (input.only === undefined || input.only.includes(path))) findings.push(...decisionFindings(path, text));
   }
   return findings;
 }
 
-function decisionFindings(path: string, text: string): CheckFinding[] {
-  return decisionCitationsInComments(path, text).map((citation) => ({
-    path,
-    line: citation.line + 1,
-    rule: "decision-citation",
-    severity: "warning",
-    message: `the comment cites ${citation.text}, a decision number a reader of the code can't follow; say what was decided, or cite the element or ADR that holds it`,
-  }));
-}
-
-/** Whether a module's Path covers the file: a directory path ending in `/` covers everything under it, any other names one file. */
-export function insideModuleMap(path: string, modulePaths: string[]): boolean {
-  return modulePaths.some((module) => (module.endsWith("/") ? path.startsWith(module) : path === module));
-}
-
 /** A Rust file of tests split out of a module: `tests.rs`, `*_tests.rs`, or anything under a `tests/` folder inside `src/`. */
 function isRustTestFileInSource(path: string): boolean {
   if (!path.endsWith(".rs")) return false;

package/src/domain/check/imports.ts

@@ -12,11 +12,11 @@ export interface SourceImport {
 const JS = /\.(?:[cm]?[jt]sx?)$/;
 const JS_EXTENSIONS = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", "/index.ts", "/index.js"];
 
-/** Imports that point inside the project. Imports of libraries and the standard library are left out. */
-export function importsOf(path: string, text: string): SourceImport[] {
+/** Imports that point inside the project, among `files`. Imports of libraries and the standard library are left out. */
+export function importsOf(path: string, text: string, files: readonly string[]): SourceImport[] {
   if (JS.test(path)) return jsImports(path, text);
   if (path.endsWith(".py")) return pythonImports(path, text);
-  if (path.endsWith(".rs")) return rustImportCandidates(path, text).map((i) => ({ ...i, bySuffix: false }));
+  if (path.endsWith(".rs")) return rustImportCandidates(path, text, files).map((i) => ({ ...i, bySuffix: false }));
   if (/\.(?:c|h|cc|cpp|cxx|hh|hpp|hxx)$/.test(path)) return matches(text, /^\s*#\s*include\s+"([^"]+)"/gm, (target) => [target], true);
   if (path.endsWith(".go")) return goImports(text);
   if (/\.(?:java|kt)$/.test(path)) return matches(text, /^import\s+(?:static\s+)?([\w.]+)(?:\.\*)?;?\s*$/gm, (t) => [`${t.replace(/\./g, "/")}.java`, `${t.replace(/\./g, "/")}.kt`], true);

package/src/domain/check/rust_imports.ts

@@ -1,10 +1,14 @@
-/** Resolves Rust `use` paths inside a crate to candidate source files. */
+/** Resolves Rust `use` paths, inside a crate and between a workspace's crates, to candidate source files. */
 
-/** Candidate files for each `use crate::…`, `use super::…` and `use self::…` path in a Rust file. */
-export function rustImportCandidates(path: string, text: string): Array<{ line: number; candidates: string[] }> {
+/**
+ * Candidate files for each `use crate::…`, `use super::…` and `use self::…` path in a Rust file,
+ * and for each `use other_crate::…` that names a library crate among `files`.
+ */
+export function rustImportCandidates(path: string, text: string, files: readonly string[]): Array<{ line: number; candidates: string[] }> {
   const root = crateRoot(path);
   if (root === null) return [];
   const own = moduleSegments(path, root);
+  const crates = libraryCrates(files);
   const results: Array<{ line: number; candidates: string[] }> = [];
   const pattern = /^\s*(?:pub(?:\([^)]*\))?\s+)?use\s+([^;]+);/gms;
   for (const match of text.matchAll(pattern)) {
@@ -12,11 +16,29 @@ export function rustImportCandidates(path: string, text: string): Array<{ line:
     for (const segments of expandUse((match[1] ?? "").replace(/\s+/g, ""))) {
       const absolute = absoluteSegments(segments, own);
       if (absolute !== null) results.push({ line, candidates: candidatesFor(root, absolute) });
+      else {
+        const [head, ...rest] = segments;
+        const other = head === undefined ? undefined : crates.get(head);
+        if (other !== undefined && other !== root) results.push({ line, candidates: candidatesFor(other, rest) });
+      }
     }
   }
   return results;
 }
 
+/**
+ * Each library crate in the project by the name code imports it as: the directory
+ * holding `src/lib.rs`, with hyphens as underscores, as Cargo names it by default.
+ */
+function libraryCrates(files: readonly string[]): Map<string, string> {
+  const crates = new Map<string, string>();
+  for (const file of files) {
+    const match = /^(?:.*\/)?([^/]+)\/src\/lib\.rs$/.exec(file);
+    if (match !== null) crates.set((match[1] ?? "").replace(/-/g, "_"), file.slice(0, -"lib.rs".length));
+  }
+  return crates;
+}
+
 /** The directory holding the crate root: everything up to and including `src/`. */
 function crateRoot(path: string): string | null {
   const index = path.lastIndexOf("src/");

package/src/domain/config.ts

@@ -2,13 +2,10 @@ import { parse as parseYaml } from "yaml";
 
 /** `.cruze/config.yaml`, as described in the cruze-formats skill. */
 export interface CruzeConfig {
-  version: 1;
+  version: 2;
   /** The Cruze version whose skills the project installed, recorded by `cruze install`. */
   cruze?: string;
-  /** The Cruze version whose expectations the code meets, moved forward by `realign`. */
-  standards?: string;
   project: string;
-  tracker: "markdown";
   source: string[];
   tests: string[];
   check: {
@@ -17,35 +14,13 @@ export interface CruzeConfig {
     exceptions: Array<{ path: string; reason: string }>;
   };
   layers: Layer[];
-  /** Named project commands, such as `test: cargo test`, shown in AGENTS.md. */
-  commands: Record<string, string>;
   /**
    * How `cruze review` starts an agent in a fresh context: the program and its arguments.
    * Without one, the calling agent runs the role's prompt in a helper of its own.
    */
-  review: { command?: string[]; decide: ReviewDecide };
-  /** The size band of a change, so each one is worth its own plan, review and verify. */
-  changes: ChangeLimits;
-  /** External documents the design must comply with, such as a protocol specification, each with what it governs. */
-  references: Array<{ path: string; use: string }>;
+  review: { command?: string[] };
 }
 
-/** Which review findings the user decides: only the exceptions, or every one. */
-export type ReviewDecide = "exceptions" | "all";
-
-export interface ChangeLimits {
-  /** A feature's change building fewer elements than this merges into a neighbour. */
-  minBuilds: number;
-  /** A change delivering more scenarios than this splits. */
-  maxScenarios: number;
-  /** A plan with more tasks than this splits. */
-  maxTasks: number;
-  /** Features and changes the user accepted outside the band, by ref, each with the reason. */
-  exceptions: Array<{ item: string; reason: string }>;
-}
-
-export const DEFAULT_CHANGE_LIMITS: ChangeLimits = { minBuilds: 3, maxScenarios: 30, maxTasks: 25, exceptions: [] };
-
 export interface Layer {
   name: string;
   paths: string[];
@@ -62,17 +37,14 @@ export function parseConfig(text: string): ConfigResult {
   } catch (error) {
     return { config: null, problems: [`not valid YAML: ${error instanceof Error ? error.message : String(error)}`] };
   }
-  const problems: string[] = [];
   const root = asRecord(raw);
   if (root === null) return { config: null, problems: ["the file must be a YAML mapping"] };
-
-  if (root["version"] !== 1) problems.push("version must be 1");
+  if (root["version"] === 1) return { config: null, problems: ["this config was created by an older Cruze, whose documents this release doesn't read; start the project's Cruze documents again with cruze init in a fresh checkout"] };
+  const problems: string[] = [];
+  if (root["version"] !== 2) problems.push("version must be 2");
   const cruze = root["cruze"];
-  if (cruze !== undefined && (typeof cruze !== "string" || cruze.trim() === "")) problems.push("cruze must be a version string, such as \"0.0.2\"");
-  const standards = root["standards"];
-  if (standards !== undefined && (typeof standards !== "string" || standards.trim() === "")) problems.push("standards must be a version string, such as \"0.0.2\"");
+  if (cruze !== undefined && (typeof cruze !== "string" || cruze.trim() === "")) problems.push("cruze must be a version string, such as \"0.0.14\"");
   if (typeof root["project"] !== "string" || root["project"] === "") problems.push("project must be a non-empty string");
-  if (root["tracker"] !== "markdown") problems.push("tracker must be markdown");
   const source = stringList(root["source"], "source", problems);
   const tests = stringList(root["tests"], "tests", problems);
 
@@ -104,71 +76,23 @@ export function parseConfig(text: string): ConfigResult {
     }
   }
 
-  const commands: Record<string, string> = {};
-  const rawCommands = root["commands"];
-  if (rawCommands !== undefined && rawCommands !== null) {
-    const record = asRecord(rawCommands);
-    if (record === null) problems.push("commands must be a mapping of names to commands");
-    for (const [name, command] of Object.entries(record ?? {})) {
-      if (typeof command === "string" && command.trim() !== "") commands[name] = command;
-      else problems.push(`commands.${name} must be a command string`);
-    }
-  }
   const review = asRecord(root["review"]) ?? {};
   const reviewCommand = review["command"] === undefined ? undefined : stringList(review["command"], "review.command", problems);
   if (reviewCommand?.length === 0) problems.push("review.command needs at least the program to run");
-  const decide = review["decide"] ?? "exceptions";
-  if (decide !== "exceptions" && decide !== "all") problems.push("review.decide must be exceptions or all");
-  const limits = asRecord(root["changes"]) ?? {};
-  const changes: ChangeLimits = {
-    minBuilds: positiveInt(limits["min_builds"], "changes.min_builds", problems) ?? DEFAULT_CHANGE_LIMITS.minBuilds,
-    maxScenarios: positiveInt(limits["max_scenarios"], "changes.max_scenarios", problems) ?? DEFAULT_CHANGE_LIMITS.maxScenarios,
-    maxTasks: positiveInt(limits["max_tasks"], "changes.max_tasks", problems) ?? DEFAULT_CHANGE_LIMITS.maxTasks,
-    exceptions: (Array.isArray(limits["exceptions"]) ? limits["exceptions"] : []).flatMap((entry: unknown, i: number) => {
-      const record = asRecord(entry);
-      if (typeof record?.["item"] !== "string" || typeof record["reason"] !== "string" || record["reason"].trim() === "") {
-        problems.push(`changes.exceptions[${i}] needs an item and a non-empty reason`);
-        return [];
-      }
-      return [{ item: record["item"], reason: record["reason"] }];
-    }),
-  };
-
-  const references = (Array.isArray(root["references"]) ? root["references"] : root["references"] === undefined ? [] : [null]).flatMap((entry: unknown, i: number) => {
-    const record = asRecord(entry);
-    if (typeof record?.["path"] !== "string" || record["path"].trim() === "" || typeof record["use"] !== "string" || record["use"].trim() === "") {
-      problems.push(`references[${i}] needs a path and a non-empty use`);
-      return [];
-    }
-    return [{ path: record["path"], use: record["use"] }];
-  });
 
   const config: CruzeConfig = {
-    version: 1,
+    version: 2,
     ...(typeof cruze === "string" && cruze.trim() !== "" ? { cruze } : {}),
-    ...(typeof standards === "string" && standards.trim() !== "" ? { standards } : {}),
     project: typeof root["project"] === "string" ? root["project"] : "",
-    tracker: "markdown",
     source,
     tests,
-    check: { maxLines: maxLines ?? 250, maxTypes: maxTypes ?? 5, exceptions },
+    check: { maxLines: maxLines ?? 600, maxTypes: maxTypes ?? 12, exceptions },
     layers,
-    commands,
-    review: {
-      ...(reviewCommand === undefined || reviewCommand.length === 0 ? {} : { command: reviewCommand }),
-      decide: decide === "all" ? "all" : "exceptions",
-    },
-    changes,
-    references,
+    review: reviewCommand === undefined || reviewCommand.length === 0 ? {} : { command: reviewCommand },
   };
   return { config, problems };
 }
 
-/** The first layer whose paths match the file, as the formats define. */
-export function layerOf(config: CruzeConfig, path: string, matches: (path: string, globs: string[]) => boolean): Layer | undefined {
-  return config.layers.find((layer) => matches(path, layer.paths));
-}
-
 function asRecord(value: unknown): Record<string, unknown> | null {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : null;
 }