@printpractical/cruze 0.0.13 → 0.0.15

package/dist/app/use_cases/project_status.js

@@ -1,82 +1,58 @@
-import { CruzeError } from "../../domain/cruze_error.js";
+import { approvalState,                    } from "../../domain/approvals.js";
 import { PATHS } from "../../domain/project/layout.js";
-import { readProgress } from "../../domain/project/progress.js";
-import { buildProjectView } from "../../domain/project/project_view.js";
-import { findWorkItem,               } from "../../domain/project/work_items.js";
-import { nextSteps,                 } from "../../domain/status/next_step.js";
-import { activeChange, buildGateReasons, projectStatus, touchedIds,                    } from "../../domain/status/work_status.js";
-import { appendJournal, loadView,                  } from "../project_context.js";
+                                                            
+import { nextStep,               } from "../../domain/next_step.js";
+                                                                      
+import { loadDocs,                  } from "../project_context.js";
 
-                                                     
-                        
+                                 
+               
+                                   
  
 
-export async function showStatus(deps             )                        {
-  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             )                                                  {
-  const branch = await deps.repository.currentBranch();
-  return { branch, ...nextSteps(await loadView(deps.files), branch) };
-}
-
-                             
+                                
+               
                 
+                                                                        
+                                                   
+                                      
+                     
                   
                     
-                      
  
 
-/**
- * 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             , override         )                      {
-  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 };
-}
-
-                          
+                               
+                              
+                            
                  
-               
-                   
  
 
-/** In-flight work on other branches that touches the same elements as this branch's change. */
-export async function findOverlaps(deps             , ref         )                                                   {
-  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            = [];
-  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 };
+/** Each document's approval, and each feature's progress, in release order. */
+export async function showStatus(deps             )                        {
+  const docs = await loadDocs(deps.files);
+  const state = (path        , doc                         )                            => (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)                => {
+    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) };
 }
 
-function landed(item          )          {
-  return item.archived || readProgress(item.doc).landed !== undefined;
+/** The step to run next, and why. */
+export async function suggestNext(deps             )                    {
+  return nextStep(await loadDocs(deps.files));
 }

package/dist/app/use_cases/run_review.js

@@ -1,20 +1,14 @@
 import { CruzeError } from "../../domain/cruze_error.js";
-import { resolveArtifact } from "../../domain/project/artifact_ref.js";
-import { isPlanned } from "../../domain/project/plan_parts.js";
-import { featureOf,               } from "../../domain/project/work_items.js";
                                                             
-import { loadView,                  } from "../project_context.js";
+import { loadDocs,                  } from "../project_context.js";
 
-export const ROLES = ["design-reviewer", "code-reviewer", "verifier", "researcher", "auditor", "surveyor"]         ;
+export const ROLES = ["code-reviewer", "researcher"]         ;
                                           
 
                                 
                
-                                                                                 
-                
-                 
                                            
-                    
+                
                                                       
                 
  
@@ -30,37 +24,31 @@ export const ROLES = ["design-reviewer", "code-reviewer", "verifier", "researche
 
 /**
  * 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                                       , request               )                        {
   if (!(ROLES                     ).includes(request.role)) throw new CruzeError("unknown-role", `the roles are ${ROLES.join(", ")}`);
   const role = request.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           = [];
   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             , role      )                  {
   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          )         {
-  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/dist/app/use_cases/validate_project.js

@@ -1,10 +1,12 @@
 import { hasErrors, validateProject } from "../../domain/validation/validate_project.js";
 import { warning,              } from "../../domain/validation/problem.js";
 import { PATHS } from "../../domain/project/layout.js";
+import { reviewSettingTemplate } from "../../domain/scaffold.js";
+import { reviewCommandProblems } from "../../domain/validation/review_rules.js";
 import { versionSkew } from "../../domain/versions/cruze_version.js";
                                                  
-import { loadView } from "../project_context.js";
                                                               
+import { loadDocs } from "../project_context.js";
 
                                  
                  
@@ -13,12 +15,13 @@ import { loadView } from "../project_context.js";
                       
  
 
-/** 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                                         )                          {
-  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/dist/domain/approvals.js

@@ -0,0 +1,51 @@
+import { designHash } from "./hashing.js";
+                                                 
+import { slugOfFeaturePath } from "./project/layout.js";
+
+/** One approval of one document: the hash of its design content when the user approved it. */
+                                 
+               
+               
+                     
+             
+ 
+
+                                                                 
+
+/** Reads `.cruze/approvals.json`; anything unreadable counts as no approvals, and validate reports it. */
+export function parseApprovals(text                    )                   {
+  if (text === undefined) return [];
+  try {
+    const parsed          = JSON.parse(text);
+    const list = (parsed                           ).approvals;
+    if (!Array.isArray(list)) return [];
+    return list.filter((r)                      => typeof r?.path === "string" && typeof r?.hash === "string" && typeof r?.approvedAt === "string" && typeof r?.by === "string");
+  } catch {
+    return [];
+  }
+}
+
+export function serializeApprovals(records                  )         {
+  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                  , record                )                   {
+  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        , doc             )         {
+  return designHash(doc, slugOfFeaturePath(path) === undefined ? [] : ["Decisions"]);
+}
+
+/** Whether the document still reads as it did when it was approved. */
+export function approvalState(records                           , path        , doc             )                {
+  const record = records.find((r) => r.path === path);
+  if (record === undefined) return "unapproved";
+  return record.hash === approvalHash(path, doc) ? "approved" : "edited";
+}

package/dist/domain/check/check_source.js

@@ -1,36 +1,29 @@
                                                        
 import { matchesAny } from "../glob.js";
 import { budgetedText } from "./budget_text.js";
-import { decisionCitationsInComments } from "./decision_comments.js";
 import { importsOf, resolveImport } from "./imports.js";
 import { countTypes } from "./type_count.js";
 
                                
                
                 
-                                                                                                                         
+                                                                            
                   
                                                                            
                                 
-                                                                                                                              
-                 
  
 
                              
                       
                                                              
                                        
-                                                                                              
-                        
-                                                                                    
-                                      
                                                                                         
                   
  
 
 /** Enforces the architecture's layer rules and the file budgets on source code. */
 export function checkSource(input            )                 {
-  const { config, sources, modulePaths } = input;
+  const { config, sources } = input;
   const all = [...sources.keys()];
   const targets = input.only ?? all;
   const layerOf = (path        )                    => config.layers.find((layer) => matchesAny(path, layer.paths));
@@ -44,7 +37,7 @@ export function checkSource(input            )                 {
       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            )                 {
     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        , text        )                 {
-  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        , modulePaths          )          {
-  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        )          {
   if (!path.endsWith(".rs")) return false;

package/dist/domain/check/imports.js

@@ -12,11 +12,11 @@ import { rustImportCandidates } from "./rust_imports.js";
 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        , text        )                 {
+/** Imports that point inside the project, among `files`. Imports of libraries and the standard library are left out. */
+export function importsOf(path        , text        , files                   )                 {
   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/dist/domain/check/rust_imports.js

@@ -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        , text        )                                                {
+/**
+ * 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        , text        , files                   )                                                {
   const root = crateRoot(path);
   if (root === null) return [];
   const own = moduleSegments(path, root);
+  const crates = libraryCrates(files);
   const results                                                = [];
   const pattern = /^\s*(?:pub(?:\([^)]*\))?\s+)?use\s+([^;]+);/gms;
   for (const match of text.matchAll(pattern)) {
@@ -12,11 +16,29 @@ export function rustImportCandidates(path        , text        )
     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                   )                      {
+  const crates = new Map                ();
+  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        )                {
   const index = path.lastIndexOf("src/");

package/dist/domain/config.js

@@ -5,10 +5,7 @@ import { parse as parseYaml } from "yaml";
              
                                                                                            
                  
-                                                                                         
-                     
                   
-                      
                    
                   
           
@@ -17,34 +14,12 @@ import { parse as parseYaml } from "yaml";
                                                         
     
                   
-                                                                                
-                                   
      
                                                                                           
                                                                                   
      
-                                                       
-                                                                                         
-                        
-                                                                                                                     
-                                                   
+                                 
  
-
-/** Which review findings the user decides: only the exceptions, or every one. */
-                                                
-
-                               
-                                                                                      
-                    
-                                                             
-                       
-                                                 
-                   
-                                                                                               
-                                                      
- 
-
-export const DEFAULT_CHANGE_LIMITS               = { minBuilds: 3, maxScenarios: 30, maxTasks: 25, exceptions: [] };
 
                         
                
@@ -62,17 +37,14 @@ export function parseConfig(text        )               {
   } catch (error) {
     return { config: null, problems: [`not valid YAML: ${error instanceof Error ? error.message : String(error)}`] };
   }
-  const problems           = [];
   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           = [];
+  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        )               {
     }
   }
 
-  const commands                         = {};
-  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               = {
-    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         , i        ) => {
-      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         , i        ) => {
-    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              = {
-    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             , path        , matches                                            )                    {
-  return config.layers.find((layer) => matches(path, layer.paths));
-}
-
 function asRecord(value         )                                 {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? (value                           ) : null;
 }