@printpractical/cruze 0.0.13 → 0.0.15

package/dist/domain/hashing.js

@@ -1,43 +1,29 @@
 import { createHash } from "node:crypto";
-import { elementLines, isStatusLine,              } from "./elements.js";
-                                                 
+import { findSection,                  } from "./markdown.js";
 
 /**
- * Hashes cover design content only. Managed blocks and status lines are
- * excluded, so bookkeeping by the CLI never makes a design look edited.
+ * Hashes cover design content only. A feature's `- Status:` line is bookkeeping, so marking a
+ * feature built never makes its approved design look edited.
  */
 
-export function sha256(text        )         {
-  return `sha256:${createHash("sha256").update(text).digest("hex")}`;
-}
+const STATUS_LINE = /^- Status: \S+\s*$/;
 
-/** Hash of a whole document's design content. */
-export function designHash(doc             )         {
-  const kept = doc.lines.filter((line, i) => !doc.inManaged[i] && (doc.inFence[i] || !isStatusLine(line)));
-  return sha256(normalize(kept));
+export function isStatusLine(line        )          {
+  return STATUS_LINE.test(line);
 }
 
-/**
- * Hash of one element, independent of where it sits: heading levels are made
- * relative to the element and a delta operation prefix is dropped, so an element
- * hashes the same in a delta and after it is merged into a living document.
- */
-export function elementHash(doc             , element         )         {
-  if (element.form === "row") return sha256(normalize(elementLines(doc, element)));
-  const kept           = [];
-  for (let i = element.start; i < element.end; i++) {
-    const line = doc.lines[i] ?? "";
-    if (doc.inManaged[i] || (!doc.inFence[i] && isStatusLine(line))) continue;
-    kept.push(doc.inFence[i] ? line : relativeHeading(line, element.level, i === element.start));
-  }
-  return sha256(normalize(kept));
+export function sha256(text        )         {
+  return `sha256:${createHash("sha256").update(text).digest("hex")}`;
 }
 
-function relativeHeading(line        , baseLevel        , isOwnHeading         )         {
-  const match = /^(#{1,6}) (.*)$/.exec(line);
-  if (match?.[1] === undefined || match[2] === undefined) return line;
-  const text = isOwnHeading ? match[2].replace(/^(ADDED|MODIFIED|REMOVED) /, "") : match[2];
-  return `${"#".repeat(match[1].length - baseLevel + 1)} ${text}`;
+/** Hash of a document's design content, leaving out the `##` sections named. */
+export function designHash(doc             , leftOut                    = [])         {
+  const skipped = leftOut.flatMap((title) => {
+    const section = findSection(doc, title);
+    return section === null ? [] : [[section.heading.line, section.end]         ];
+  });
+  const kept = doc.lines.filter((line, i) => !skipped.some(([start, end]) => i >= start && i < end) && (doc.inFence[i] || !isStatusLine(line)));
+  return sha256(normalize(kept));
 }
 
 function normalize(lines          )         {

package/dist/domain/ids.js

@@ -1,39 +1,25 @@
-/** Element IDs: `<KIND>-<name>` or `<KIND>-<scope>.<name>`, named and never reused. */
-
-export const KINDS = ["GOAL", "PRINCIPLE", "LATER", "CTX", "ENT", "UC", "PORT", "ADP", "FLOW", "MOD", "RULE", "VIEW", "XC", "REQ", "SCN", "ADR"]         ;
-                                          
-
-/** Kinds of the vision's row elements: goals, the principles every design follows, and what must stay possible later. */
-export const VISION_KINDS                  = ["GOAL", "PRINCIPLE", "LATER"];
-/** Kinds that describe code, and so carry a managed planned/built status. */
-export const CODE_KINDS                  = ["ENT", "UC", "PORT", "ADP", "FLOW", "MOD"];
-/** Kinds whose elements carry a managed status: code kinds and scenarios. */
-export const STATUS_KINDS                  = [...CODE_KINDS, "SCN"];
-/** Kinds that must name their context or capability as a scope. */
-export const SCOPED_KINDS                  = ["ENT", "UC", "PORT", "ADP", "FLOW", "REQ", "SCN"];
+/** Scenario IDs: `SCN-<feature>.<name>`, lowercase words joined by single hyphens, named and never reused. */
 
 const WORD = "[a-z0-9]+(?:-[a-z0-9]+)*";
-export const ID_PATTERN = `(?:${KINDS.join("|")})-${WORD}(?:\\.${WORD})?`;
-
-const EXACT = new RegExp(`^${ID_PATTERN}$`);
-const ANYWHERE = new RegExp(`(?<![A-Za-z0-9_-])${ID_PATTERN}(?![A-Za-z0-9_-])`, "g");
+export const SLUG = new RegExp(`^${WORD}$`);
+const SCENARIO = `SCN-${WORD}\\.${WORD}`;
+const EXACT = new RegExp(`^${SCENARIO}$`);
+const ANYWHERE = new RegExp(`(?<![A-Za-z0-9_-])${SCENARIO}(?![A-Za-z0-9_.-])`, "g");
 
-export function isId(text        )          {
+export function isScenarioId(text        )          {
   return EXACT.test(text);
 }
 
-export function kindOf(id        )       {
-  return id.slice(0, id.indexOf("-"))        ;
+export function isSlug(text        )          {
+  return SLUG.test(text);
 }
 
-/** The context or capability an ID belongs to, if it has one. */
-export function scopeOf(id        )                     {
-  const rest = id.slice(id.indexOf("-") + 1);
-  const dot = rest.indexOf(".");
-  return dot === -1 ? undefined : rest.slice(0, dot);
+/** The feature a scenario belongs to. */
+export function featureOfScenario(id        )         {
+  return id.slice(4, id.indexOf("."));
 }
 
-/** Every ID mentioned in the text, once each, in order of first mention. */
-export function findIds(text        )           {
+/** Every scenario ID mentioned in the text, once each, in order of first mention. */
+export function findScenarioIds(text        )           {
   return [...new Set(text.match(ANYWHERE) ?? [])];
 }

package/dist/domain/next_step.js

@@ -0,0 +1,41 @@
+import { approvalState } from "./approvals.js";
+import { PATHS } from "./project/layout.js";
+                                                             
+
+                                                           
+
+                           
+             
+                                                            
+                  
+                 
+ 
+
+/**
+ * The step to run next, from the documents alone. Work in progress comes first, in release order,
+ * then the first release feature not yet shaped whose needs are all built.
+ */
+export function nextStep(docs             )           {
+  if (docs.config === undefined) return { step: "init", reason: `${PATHS.config} is missing` };
+  if (docs.vision === undefined) return { step: "envision", reason: "the project has no vision yet" };
+  if (approvalState(docs.approvals, PATHS.vision, docs.vision) !== "approved") return { step: "envision", reason: "the vision isn't approved as it stands" };
+  if (docs.architecture === undefined) return { step: "envision", reason: "the project has no architecture map yet" };
+  if (approvalState(docs.approvals, PATHS.architecture, docs.architecture) !== "approved") return { step: "envision", reason: "the architecture map isn't approved as it stands" };
+
+  const order = [...docs.release.map((r) => r.slug), ...docs.features.map((f) => f.slug).filter((slug) => !docs.release.some((r) => r.slug === slug))];
+  for (const slug of order) {
+    const feature = docs.features.find((f) => f.slug === slug);
+    if (feature === undefined || feature.status === "built") continue;
+    const state = approvalState(docs.approvals, feature.path, feature.doc);
+    if (state === "unapproved") return { step: "shape", target: slug, reason: `${slug} is shaped but not approved` };
+    if (state === "edited") return { step: "shape", target: slug, reason: `${slug} changed since its approval; show the user what changed and approve it again` };
+    return { step: "build", target: slug, reason: `${slug} is approved and not built` };
+  }
+
+  const built = new Set(docs.features.filter((f) => f.status === "built").map((f) => f.slug));
+  const pending = docs.release.filter((r) => !built.has(r.slug));
+  const ready = pending.find((r) => !docs.features.some((f) => f.slug === r.slug) && r.needs.every((need) => built.has(need)));
+  if (ready !== undefined) return { step: "shape", target: ready.slug, reason: ready.needs.length === 0 ? `${ready.slug} is next in the release` : `${ready.slug} is next in the release, and everything it needs is built` };
+  if (pending.length > 0) return { step: "envision", reason: `no remaining release feature has all its needs built (${pending.map((r) => r.slug).join(", ")}); fix the Needs column` };
+  return { step: "envision", reason: docs.release.length === 0 ? "the vision's Release table lists no features" : "every release feature is built; plan the next release" };
+}

package/dist/domain/project/features.js

@@ -0,0 +1,71 @@
+import { isStatusLine } from "../hashing.js";
+import { findScenarioIds, isScenarioId } from "../ids.js";
+import { findSection, parseMarkdown,                  } from "../markdown.js";
+import { featurePath } from "./layout.js";
+
+/** A feature document, docs/features/<slug>.md: one slice of behaviour, its public API and its stack sketch. */
+                          
+               
+               
+               
+                   
+                                                                                                       
+                                    
+                                                                                         
+                        
+ 
+
+                                               
+export const FEATURE_STATUSES                           = ["shaped", "built"];
+
+                           
+             
+                
+                                     
+               
+ 
+
+export const FEATURE_SECTIONS = ["Intent", "Behaviour", "Public API", "Stack sketch", "Decisions"]         ;
+
+export function readFeature(slug        , text        )          {
+  const doc = parseMarkdown(text);
+  return { slug, path: featurePath(slug), text, doc, status: statusOf(doc), scenarios: scenariosOf(doc) };
+}
+
+/** The feature's `- Status:` line, the first one outside code. */
+export function statusLine(doc             )                                              {
+  const index = doc.lines.findIndex((line, i) => !doc.inFence[i] && isStatusLine(line));
+  if (index === -1) return undefined;
+  return { line: index, value: (doc.lines[index] ?? "").replace("- Status:", "").trim() };
+}
+
+function statusOf(doc             )                            {
+  const value = statusLine(doc)?.value;
+  return (FEATURE_STATUSES                     ).includes(value ?? "") ? (value                 ) : undefined;
+}
+
+/** Scenario headings under `## Behaviour`: any heading whose text starts with a scenario ID and a colon. */
+function scenariosOf(doc             )             {
+  const section = findSection(doc, "Behaviour");
+  if (section === null) return [];
+  return doc.headings
+    .filter((h) => h.line >= section.start && h.line < section.end)
+    .flatMap((h) => {
+      const match = /^(\S+): (.+)$/.exec(h.text);
+      if (match?.[1] === undefined || match[2] === undefined || !isScenarioId(match[1])) return [];
+      return [{ id: match[1], title: match[2], line: h.line }];
+    });
+}
+
+/** Scenario-like IDs under `## Behaviour` that aren't a proper scenario heading, for validate to report. */
+export function strayScenarioIds(feature         )                                      {
+  const section = findSection(feature.doc, "Behaviour");
+  if (section === null) return [];
+  const headed = new Set(feature.scenarios.map((s) => s.line));
+  const stray                                      = [];
+  for (let i = section.start; i < section.end; i++) {
+    if (headed.has(i) || feature.doc.inFence[i] || !/^#{1,6} /.test(feature.doc.lines[i] ?? "")) continue;
+    for (const id of findScenarioIds(feature.doc.lines[i] ?? "")) stray.push({ id, line: i });
+  }
+  return stray;
+}

package/dist/domain/project/layout.js

@@ -1,4 +1,4 @@
-/** Where Cruze documents live in a project, and the snapshot of them the domain works on. */
+/** Where Cruze documents live in a project. */
 
 /** Project files by path, relative to the project root, with forward slashes. */
                                                    
@@ -6,36 +6,20 @@
 export const PATHS = {
   readme: "README.md",
   vision: "docs/vision.md",
-  glossary: "docs/glossary.md",
   architecture: "docs/architecture.md",
-  roadmap: "docs/roadmap.md",
-  adrDir: "docs/adr",
-  specsDir: "docs/specs",
+  featuresDir: "docs/features",
   config: ".cruze/config.yaml",
-  featuresDir: ".cruze/features",
-  changesDir: ".cruze/changes",
-  archiveDir: ".cruze/archive",
-  notesDir: ".cruze/notes",
-  projectApprovals: ".cruze/approvals.json",
-  projectJournal: ".cruze/journal.jsonl",
+  approvals: ".cruze/approvals.json",
 }         ;
 
-/** Directories whose files make up the snapshot. */
-export const SNAPSHOT_ROOTS = ["docs", ".cruze"]         ;
-
-export function specPath(capability        )         {
-  return `${PATHS.specsDir}/${capability}.md`;
-}
-
-export function filesUnder(snapshot          , dir        )           {
-  const prefix = `${dir}/`;
-  return [...snapshot.keys()].filter((path) => path.startsWith(prefix)).sort();
+export function featurePath(slug        )         {
+  return `${PATHS.featuresDir}/${slug}.md`;
 }
 
-/** Paths directly matching `<dir>/<name><suffix>`, one level deep. */
-export function childFiles(snapshot          , dir        , suffix        )           {
-  return filesUnder(snapshot, dir).filter((path) => {
-    const rest = path.slice(dir.length + 1);
-    return !rest.includes("/") && rest.endsWith(suffix);
-  });
+/** The feature slug of a path directly under docs/features/, or undefined. */
+export function slugOfFeaturePath(path        )                     {
+  const prefix = `${PATHS.featuresDir}/`;
+  if (!path.startsWith(prefix) || !path.endsWith(".md")) return undefined;
+  const rest = path.slice(prefix.length, -3);
+  return rest.includes("/") ? undefined : rest;
 }

package/dist/domain/project/project_docs.js

@@ -0,0 +1,48 @@
+import { parseApprovals,                     } from "../approvals.js";
+import { parseConfig,                   } from "../config.js";
+import { parseMarkdown,                  } from "../markdown.js";
+import { readFeature,              } from "./features.js";
+import { PATHS, slugOfFeaturePath,               } from "./layout.js";
+import { readRelease,                     } from "./release.js";
+
+/** Every Cruze document of a project, parsed: what the use cases work on. */
+                              
+                     
+                                   
+                                  
+                                        
+                            
+                                                   
+                      
+                              
+ 
+
+export function buildProjectDocs(snapshot          )              {
+  const read = (path        )                          => {
+    const text = snapshot.get(path);
+    return text === undefined ? undefined : parseMarkdown(text);
+  };
+  const configText = snapshot.get(PATHS.config);
+  const vision = read(PATHS.vision);
+  const features = [...snapshot.keys()]
+    .flatMap((path) => {
+      const slug = slugOfFeaturePath(path);
+      return slug === undefined ? [] : [readFeature(slug, snapshot.get(path) ?? "")];
+    })
+    .sort((a, b) => a.slug.localeCompare(b.slug));
+  return {
+    snapshot,
+    config: configText === undefined ? undefined : parseConfig(configText),
+    vision,
+    architecture: read(PATHS.architecture),
+    release: vision === undefined ? [] : readRelease(vision),
+    features,
+    approvals: parseApprovals(snapshot.get(PATHS.approvals)),
+  };
+}
+
+/** The document a reference names: `vision`, `architecture`, a feature slug, or a path. */
+export function resolveDocument(docs             , ref        )                     {
+  const path = ref === "vision" ? PATHS.vision : ref === "architecture" ? PATHS.architecture : (docs.features.find((f) => f.slug === ref)?.path ?? ref);
+  return docs.snapshot.has(path) ? path : undefined;
+}

package/dist/domain/project/release.js

@@ -0,0 +1,30 @@
+import { findSection,                  } from "../markdown.js";
+import { tablesIn } from "../markdown_tables.js";
+
+/** One row of the vision's `## Release` table: a feature of the release, in build order, and the features it needs. */
+                                 
+               
+                  
+                  
+                                 
+               
+ 
+
+/** The release's features, from the first table under `## Release` with Feature and Needs columns. */
+export function readRelease(vision             )                   {
+  const section = findSection(vision, "Release");
+  if (section === null) return [];
+  const table = tablesIn(vision.lines, vision.inFence, section.start, section.end).find((t) => t.header.includes("Feature") && t.header.includes("Needs"));
+  if (table === undefined) return [];
+  const at = (name        )         => table.header.indexOf(name);
+  return table.rows.map(({ cells, line }) => ({
+    slug: unquote(cells[at("Feature")] ?? ""),
+    summary: at("Summary") === -1 ? "" : (cells[at("Summary")] ?? ""),
+    needs: (cells[at("Needs")] ?? "").split(",").map(unquote).filter((need) => need !== "" && !/^[-—–]+$/.test(need)),
+    line,
+  }));
+}
+
+function unquote(cell        )         {
+  return cell.trim().replace(/^`(.*)`$/, "$1").trim();
+}

package/dist/domain/scaffold.js

@@ -13,7 +13,6 @@ export const INIT_SCAFFOLD                           = [
   { path: "AGENTS.md", template: "init/AGENTS.md" },
   { path: ".cruze/config.yaml", template: "init/config.yaml" },
   { path: ".github/workflows/ci.yml", template: "init/ci.yml" },
-  { path: ".gitattributes", template: "init/gitattributes" },
 ];
 
 /**

package/dist/domain/skill_budget.js

@@ -7,11 +7,11 @@
 export const MAX_FILE_WORDS = 2100;
 
 /**
- * The words agents may read across the whole bundle. Every retro adds rules, and between 0.0.1 and
- * 0.0.10 the skills grew by half while nothing was removed. Lower this when text is cut. Raising it
- * is the maintainer's decision, with the reason in the commit that raises it.
+ * The words agents may read across the whole bundle. By 0.0.13 the skills had grown to 45,800 words
+ * as every fix added rules and nothing was removed; 0.0.14 cut them to this. Lower it when text is
+ * cut. Raising it is the maintainer's decision, with the reason in the commit that raises it.
  */
-export const BUNDLE_WORD_BUDGET = 45800;
+export const BUNDLE_WORD_BUDGET = 17725;
 
 /** Data the CLI reads or renders, rather than instructions an agent reads. */
 const NOT_INSTRUCTIONS = /(^|\/)(templates|notes)\//;

package/dist/domain/trace.js

@@ -1,44 +1,27 @@
-import { headingElements, statusOf } from "./elements.js";
-import { findIds } from "./ids.js";
-import { PATHS } from "./project/layout.js";
-                                                             
-import { readScope } from "./project/plan_parts.js";
-import { readDelta } from "./project/deltas.js";
-                                                        
+import { findScenarioIds } from "./ids.js";
+                                                     
 
                               
                                                                                  
                                                     
                     
-                                                                          
+                                                                
                                                              
  
 
-/**
- * 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             , tests                             , change           )              {
-  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                    , required                    , tests                             )              {
+  const known = new Set(features.flatMap((f) => f.scenarios.map((s) => s.id)));
   const carriers = new Map                  ();
   const 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             )           {
-  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/dist/domain/validation/document_rules.js

@@ -0,0 +1,65 @@
+import { featureOfScenario } from "../ids.js";
+import { findSection,                  } from "../markdown.js";
+import { FEATURE_SECTIONS, FEATURE_STATUSES, statusLine, strayScenarioIds,              } from "../project/features.js";
+import { PATHS } from "../project/layout.js";
+                                                              
+import { error,              } from "./problem.js";
+
+/** Each document's required sections, its scenarios, and leftover template guides. */
+
+const VISION_SECTIONS = ["Problem", "Users", "Release"];
+const ARCHITECTURE_SECTIONS = ["Overview", "Ports", "Adapters", "Runtime"];
+
+const GUIDE = /(?<!`)<(?!!--|\/|https?:|br\b)[A-Za-z][^<>\n]*>(?!`)/;
+const PLACEHOLDER = /\{\{[a-z_]+\}\}/;
+
+export function documentProblems(docs             )            {
+  const problems            = [];
+  if (docs.vision !== undefined) problems.push(...shapeOf(PATHS.vision, docs.vision, VISION_SECTIONS));
+  if (docs.architecture !== undefined) problems.push(...shapeOf(PATHS.architecture, docs.architecture, ARCHITECTURE_SECTIONS));
+  for (const feature of docs.features) {
+    problems.push(...shapeOf(feature.path, feature.doc, [...FEATURE_SECTIONS]), ...featureProblems(feature));
+  }
+  problems.push(...duplicateScenarios(docs.features));
+  return problems;
+}
+
+function shapeOf(path        , doc             , sections          )            {
+  const problems            = sections.filter((title) => findSection(doc, title) === null).map((title) => error(path, undefined, "missing-section", `needs a ## ${title} section`));
+  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         )            {
+  const problems            = [];
+  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           )            {
+  const seen = new Map                ();
+  const problems            = [];
+  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/dist/domain/validation/release_rules.js

@@ -0,0 +1,45 @@
+import { isSlug } from "../ids.js";
+import { PATHS } from "../project/layout.js";
+                                                              
+import { error, warning,              } from "./problem.js";
+
+/** The vision's Release table: feature slugs, what each needs, and no cycles. */
+export function releaseProblems(docs             )            {
+  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            = [];
+  const slugs = new Set        ();
+  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))]         ));
+  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                                                     )                       {
+  const edges = new Map(graph);
+  const done = new Set        ();
+  const visit = (node        , path          )                       => {
+    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/dist/domain/validation/review_rules.js

@@ -0,0 +1,21 @@
+import { parse as parseYaml } from "yaml";
+import { PATHS } from "../project/layout.js";
+                                                              
+import { warning,              } from "./problem.js";
+
+/**
+ * Warns when a feature is built but `review.command` is still the one `cruze init`
+ * wrote: the foundation never added the project's test commands, so the code
+ * reviewer can only read the code. `initSetting` is the review template init renders.
+ */
+export function reviewCommandProblems(docs             , initSetting        )            {
+  const command = docs.config?.config?.review.command;
+  if (command === undefined || !docs.features.some((feature) => feature.status === "built")) return [];
+  if (JSON.stringify(command) !== JSON.stringify(initCommand(initSetting))) return [];
+  return [warning(PATHS.config, undefined, "review-tests", "review.command is still the one cruze init wrote, so the code reviewer can't run the project's tests; add its test and lint commands as .agents/skills/cruze-formats/config.md shows")];
+}
+
+function initCommand(setting        )          {
+  const parsed          = parseYaml(setting);
+  return (parsed                                             )?.review?.command;
+}

package/dist/domain/validation/validate_project.js

@@ -1,36 +1,29 @@
+import { PATHS } from "../project/layout.js";
                                                               
-import { futureProblems } from "./future_rules.js";
-import { livingProblems } from "./living_rules.js";
+import { documentProblems } from "./document_rules.js";
 import { error, sortProblems,              } from "./problem.js";
-import { configProblems, readmeProblems, roadmapProblems, templateLeftovers } from "./project_rules.js";
-import { visionProblems } from "./vision_rules.js";
-import { workItemProblems } from "./work_item_rules.js";
+import { releaseProblems } from "./release_rules.js";
 
 /** Every rule in the cruze-formats skill, applied to the whole project. */
-export function validateProject(view             )            {
-  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           , path        )            {
-  return problems.filter((problem) => problem.path === path);
+export function validateProject(docs             )            {
+  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           )          {
   return problems.some((problem) => problem.severity === "error");
 }
+
+function approvalsFileProblems(text                    )            {
+  if (text === undefined) return [];
+  try {
+    const parsed          = JSON.parse(text);
+    if (!Array.isArray((parsed                           ).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")];
+  }
+}