@printpractical/cruze 0.0.13 → 0.0.15

package/dist/domain/status/pending_rethink.js

@@ -1,22 +0,0 @@
-                                                  
-                                                         
-
-/**
- * Findings decided `rethink` for a feature or change that no rethink of it has followed yet.
- * One project's realign recorded seven design findings on a feature as fixed "by a rethink before
- * its next change is planned"; nothing showed them, and they surfaced only in a commit message.
- */
-export function pendingRethinks(journal                , item          )                 {
-  const lastRethink = journal
-    .filter((e) => e.event === "rethink" && e["item"] === item.ref)
-    .map((e) => e.at)
-    .sort()
-    .at(-1);
-  return journal.filter((e) => e.event === "disposition" && e["disposition"] === "rethink" && e["item"] === item.ref && (lastRethink === undefined || e.at > lastRethink));
-}
-
-/** Why work waits on a rethink, naming the first finding. */
-export function pendingReason(item          , pending                )         {
-  const more = pending.length > 1 ? ` and ${pending.length - 1} more` : "";
-  return `${pending.length} finding(s) on ${item.ref} were decided for a rethink that hasn't happened yet: ${String(pending[0]?.["finding"] ?? "")}${more}`;
-}

package/dist/domain/status/verification.js

@@ -1,29 +0,0 @@
-                                                  
-                                                         
-
-/**
- * Whether the user accepted a change at verify. The latest verification recorded for the change
- * counts. A later approval keeps it only when the change's own design is unchanged, as when it is
- * re-approved because something upstream moved; a changed plan means verifying again. Land's
- * re-stamps don't count, since they follow the merge; an approval the agent gave does.
- */
-export function isVerified(journal                , change          )          {
-  const byTime = (a              , b              )         => a.at.localeCompare(b.at);
-  const verification = journal.filter((e) => e.event === "verification" && e["item"] === change.ref).sort(byTime).at(-1);
-  if (verification?.["result"] !== "accepted") return false;
-  const approvals = journal.filter((e) => e.event === "approve" && e["artifact"] === change.path && !String(e["basis"] ?? "").startsWith("land ")).sort(byTime);
-  const verifiedHash = approvals.filter((e) => e.at < verification.at).at(-1)?.["hash"];
-  return approvals.filter((e) => e.at > verification.at).every((e) => e["hash"] === verifiedHash);
-}
-
-/**
- * Whether verify sent the change back for a rethink that hasn't been recorded yet. Tasks the
- * agent reopens at verify would otherwise make the change look ready to build again.
- */
-export function awaitsRethink(journal                , change          , feature                      )          {
-  const verification = journal.filter((e) => e.event === "verification" && e["item"] === change.ref).sort((a, b) => a.at.localeCompare(b.at)).at(-1);
-  if (verification?.["result"] !== "sent-back" || verification["back_to"] !== "rethink") return false;
-  // An architecture-level rethink records no item, and counts too.
-  const refs = new Set([change.ref, feature?.ref, undefined]);
-  return !journal.some((e) => e.event === "rethink" && e.at > verification.at && refs.has(e["item"]                      ));
-}

package/dist/domain/status/work_status.js

@@ -1,125 +0,0 @@
-import { evaluateApproval,                     } from "../approvals/evaluate.js";
-import { PATHS } from "../project/layout.js";
-import { readDelta } from "../project/deltas.js";
-import { readChangesTable, readScope } from "../project/plan_parts.js";
-import { readProgress } from "../project/progress.js";
-                                                              
-import { changesOf, featureOf,               } from "../project/work_items.js";
-import { pendingReason, pendingRethinks } from "./pending_rethink.js";
-
-                               
-              
-               
-                           
-                  
-                    
-                     
-                                                                 
-                  
-                                                                                
-                            
- 
-
-                                
-              
-               
-                           
-                          
-                                                                                 
-                            
- 
-
-                                
-                              
-                            
-                             
-                                                        
-                  
- 
-
-export function projectStatus(view             , branch               )                {
-  const documents = [PATHS.vision, PATHS.architecture, PATHS.roadmap].filter((p) => view.snapshot.has(p)).map((p) => evaluateApproval(view, p));
-  const active = view.items.filter((item) => !item.archived);
-  const features = active
-    .filter((item) => item.kind === "feature")
-    .map((feature) => ({
-      ref: feature.ref,
-      path: feature.path,
-      approval: evaluateApproval(view, feature.path),
-      changes: changesOf(view.items, feature).map((change) => changeStatus(view, change)),
-      ...withPending(view, feature),
-    }));
-  const standalone = active.filter((item) => item.kind === "standalone").map((change) => changeStatus(view, change));
-  const status                = { documents, features, standalone };
-  const bound = activeChange(view, branch);
-  if (bound !== undefined) status.active = bound.ref;
-  return status;
-}
-
-export function activeChange(view             , branch               )                       {
-  if (branch === null) return undefined;
-  return view.items.find((item) => {
-    const progress = readProgress(item.doc);
-    return !item.archived && item.kind !== "feature" && progress.landed === undefined && progress.branch === branch;
-  });
-}
-
-function changeStatus(view             , change          )               {
-  const progress = readProgress(change.doc);
-  const status               = {
-    ref: change.ref,
-    path: change.path,
-    approval: evaluateApproval(view, change.path),
-    tasksDone: [...progress.tasks.values()].filter((commit) => commit !== null).length,
-    tasksTotal: progress.tasks.size,
-  };
-  if (progress.branch !== undefined) status.branch = progress.branch;
-  if (progress.landed !== undefined) status.landed = progress.landed;
-  return { ...status, ...withPending(view, change) };
-}
-
-function withPending(view             , item          )                                {
-  const pending = pendingRethinks(view.journal, item);
-  return pending.length === 0 ? {} : { rethinkPending: pending.map((e) => String(e["finding"] ?? "")) };
-}
-
-/** Why building may not start on this branch; empty when the build gate passes. */
-export function buildGateReasons(view             , branch               )           {
-  const change = activeChange(view, branch);
-  if (change === undefined) return [`no change is bound to branch ${branch ?? "(none)"}; approve a planned change on this branch first`];
-  const required = [change.path];
-  const feature = featureOf(view.items, change);
-  if (feature !== undefined) required.push(feature.path);
-  if (view.snapshot.has(PATHS.architecture)) required.push(PATHS.architecture);
-  const approvals = required.flatMap((path) => {
-    const status = evaluateApproval(view, path);
-    if (status.state === "approved") return [];
-    const detail = status.changed.length > 0 ? `: ${status.changed.join(", ")} changed` : status.unjournaled === true ? ": the approval has no journal entry" : "";
-    return [`${path} is ${status.state}${detail}`];
-  });
-  const rethinks = [feature, change].flatMap((part) => {
-    const pending = part === undefined ? [] : pendingRethinks(view.journal, part);
-    return part === undefined || pending.length === 0 ? [] : [`${pendingReason(part, pending)}; run rethink`];
-  });
-  return [...approvals, ...rethinks, ...unlandedDependencies(view, change, feature)];
-}
-
-/** The changes this change's row in its feature's Changes table depends on that haven't landed on this branch. */
-function unlandedDependencies(view             , change          , feature                      )           {
-  if (feature === undefined) return [];
-  const row = readChangesTable(feature.doc).find((r) => r.change === change.folderName);
-  const landed = new Set(changesOf(view.items, feature).filter((c) => readProgress(c.doc).landed !== undefined).map((c) => c.folderName));
-  return (row?.dependsOn ?? [])
-    .filter((dependency) => !landed.has(dependency))
-    .map((dependency) => `${change.ref} depends on ${dependency}, which hasn't landed here; land it, then merge main into this branch`);
-}
-
-/** The elements a change touches: its scope and its delta, not the elements it only cites, such as a test seam. */
-export function touchedIds(view             , change          )              {
-  const feature = featureOf(view.items, change);
-  const scope = readScope(change.doc);
-  const ids = new Set([...(scope?.delivers ?? []), ...(scope?.builds ?? []), ...(scope?.removes ?? [])]);
-  const deltaDoc = feature?.doc ?? change.doc;
-  for (const id of readDelta(deltaDoc).ids) ids.add(id);
-  return new Set([...ids].filter((id) => !id.startsWith("RULE-")));
-}

package/dist/domain/validation/decision_rules.js

@@ -1,76 +0,0 @@
-import { definedDecisions, findDecisionCitations, workItemSlugs,                       } from "../decision_citations.js";
-                                              
-import { findSection,                  } from "../markdown.js";
-import { readDelta } from "../project/deltas.js";
-import { PATHS } from "../project/layout.js";
-                                                              
-                                                         
-import { warning,              } from "./problem.js";
-
-const INSTEAD = "write what it decided into this text, or cite the ADR that records it";
-
-/**
- * The architecture cites only the decisions its own `## Decisions` defines. The other living docs
- * cite none by number, and no living doc cites a feature's or change's, which is archived when it finishes.
- */
-export function livingDecisionProblems(view             )            {
-  const slugs = slugsOf(view);
-  const project = projectDecisions(view);
-  const problems            = [];
-  for (const [path, doc] of view.living.docs) {
-    for (const citation of citationsIn(doc, slugs)) {
-      if (citation.qualifier !== undefined) {
-        problems.push(warning(path, citation.line, "decision-citation", `cites ${citation.text}, a decision of ${citation.qualifier}, which the living docs don't hold; ${INSTEAD}`));
-      } else if (path !== PATHS.architecture) {
-        problems.push(warning(path, citation.line, "decision-citation", `cites ${citation.text}, but only the architecture cites decisions by number, its own; ${INSTEAD}`));
-      } else {
-        const unknown = citation.numbers.filter((n) => !project.has(n));
-        if (unknown.length > 0) {
-          problems.push(warning(path, citation.line, "decision-citation", `cites ${unknown.map((n) => `D${n}`).join(", ")}, which "## Decisions" doesn't define; ${INSTEAD}`));
-        }
-      }
-    }
-  }
-  return problems;
-}
-
-/**
- * A delta's elements merge into the living docs, where the work's own decisions don't follow them.
- * They may cite a project decision the work doesn't renumber, or one the living element already cites.
- */
-export function deltaDecisionProblems(view             , item          )            {
-  const slugs = slugsOf(view);
-  const project = projectDecisions(view);
-  const local = definedDecisions(sectionLines(item.doc, "Settled decisions"));
-  const problems            = [];
-  for (const { element } of readDelta(item.doc).entries) {
-    const living = view.living.elements.get(element.id);
-    const carried = new Set(living === undefined ? [] : citationsIn(living.doc, slugs, living.element).flatMap((c) => (c.qualifier === undefined ? c.numbers : [])));
-    const allowed = (n        )          => project.has(n) && (!local.has(n) || carried.has(n));
-    for (const citation of citationsIn(item.doc, slugs, element)) {
-      if (citation.qualifier === undefined && citation.numbers.every(allowed)) continue;
-      problems.push(warning(item.path, citation.line, "decision-citation", `${element.id} cites ${citation.text}, which won't mean the same in the living docs once this delta merges; ${INSTEAD}`));
-    }
-  }
-  return problems;
-}
-
-function citationsIn(doc             , slugs             , element          )                     {
-  const from = element === undefined ? doc.bodyStart : element.start + 1;
-  const to = element === undefined ? doc.lines.length : element.end;
-  return findDecisionCitations(doc.lines, slugs, (line) => line < from || line >= to || doc.inFence[line] === true || doc.inManaged[line] === true);
-}
-
-function projectDecisions(view             )              {
-  const architecture = view.living.docs.get(PATHS.architecture);
-  return architecture === undefined ? new Set() : definedDecisions(sectionLines(architecture, "Decisions"));
-}
-
-function sectionLines(doc             , title        )           {
-  const range = findSection(doc, title);
-  return range === null ? [] : doc.lines.slice(range.start, range.end);
-}
-
-function slugsOf(view             )              {
-  return workItemSlugs(view.items.map((item) => item.folderName));
-}

package/dist/domain/validation/delta_rules.js

@@ -1,81 +0,0 @@
-import { ARCHITECTURE_KINDS } from "../architecture_sections.js";
-import { scopeOf } from "../ids.js";
-import { specPath } from "../project/layout.js";
-import { orphanDeltaElements, readDelta,            } from "../project/deltas.js";
-                                                              
-                                                         
-import { deltaDecisionProblems } from "./decision_rules.js";
-import { elementProblems } from "./element_rules.js";
-import { error,              } from "./problem.js";
-
-/** Merge records use this key for a spec file a delta created. */
-export function capabilityKey(capability        )         {
-  return `CAPABILITY-${capability}`;
-}
-
-/** Marks an element a landed change removed. */
-export const REMOVED_MARK = "removed";
-
-/** Rules for the spec and architecture deltas of a feature or standalone change. */
-export function deltaProblems(view             , item          )            {
-  const { path, doc } = item;
-  const delta = readDelta(doc);
-  const merged = view.approvals.get(item.folder)?.merged ?? {};
-  const problems            = [];
-
-  for (const orphan of orphanDeltaElements(doc)) {
-    problems.push(error(path, orphan.start, "delta-shape", `${orphan.id} must sit under an ADDED, MODIFIED or REMOVED requirement`));
-  }
-  for (const { element, section, scenarios } of delta.entries) {
-    const allowed = section === "spec" ? element.kind === "REQ" : ARCHITECTURE_KINDS.includes(element.kind);
-    if (!allowed) problems.push(error(path, element.start, "delta-shape", `${element.id} does not belong in the ${section} delta`));
-    problems.push(...elementProblems(path, doc, element));
-    for (const scenario of scenarios) {
-      problems.push(...elementProblems(path, doc, scenario));
-      if (scopeOf(scenario.id) !== scopeOf(element.id)) {
-        problems.push(error(path, scenario.start, "id-scope", `${scenario.id} must share its requirement's scope`));
-      }
-      problems.push(...opProblems(view, path, scenario.id, "ADDED", scenario.start, merged, element.op === "ADDED"));
-    }
-    problems.push(...opProblems(view, path, element.id, element.op ?? "ADDED", element.start, merged, false));
-    if (element.kind === "REQ" && element.op === "ADDED") problems.push(...capabilityProblems(view, item, delta, element.id, element.start));
-  }
-  for (const op of delta.capabilities) {
-    if (view.snapshot.has(specPath(op.capability)) && merged[capabilityKey(op.capability)] === undefined) {
-      problems.push(error(path, op.start, "capability-exists", `capability ${op.capability} already has ${specPath(op.capability)}`));
-    }
-  }
-  problems.push(...deltaDecisionProblems(view, item));
-  return problems;
-}
-
-function opProblems(
-  view             ,
-  path        ,
-  id        ,
-  op                                  ,
-  line        ,
-  merged                        ,
-  underAddedRequirement         ,
-)            {
-  const exists = view.living.elements.has(id);
-  const mergedHere = merged[id] !== undefined;
-  if (view.retired.has(id)) return [error(path, line, "retired-id", `${id} was removed earlier and can never be reused`)];
-  if (op === "ADDED" && exists && !mergedHere) {
-    // A scenario under a MODIFIED requirement may already exist; only a new requirement's scenarios must be new.
-    if (!id.startsWith("SCN-") || underAddedRequirement) return [error(path, line, "delta-op", `ADDED ${id} already exists in the living docs`)];
-  }
-  if ((op === "MODIFIED" || op === "REMOVED") && !exists && merged[id] !== REMOVED_MARK) {
-    return [error(path, line, "delta-op", `${op} ${id} does not exist in the living docs`)];
-  }
-  return [];
-}
-
-function capabilityProblems(view             , item          , delta       , id        , line        )            {
-  const capability = scopeOf(id);
-  if (capability === undefined) return [];
-  const hasFile = view.snapshot.has(specPath(capability));
-  const addsFile = delta.capabilities.some((op) => op.capability === capability);
-  if (hasFile || addsFile) return [];
-  return [error(item.path, line, "capability-missing", `${id} needs ${specPath(capability)}, or an "ADDED CAPABILITY ${capability}" operation`)];
-}

package/dist/domain/validation/element_rules.js

@@ -1,104 +0,0 @@
-import { factsOf,              } from "../elements.js";
-import { findIds, scopeOf, SCOPED_KINDS,           } from "../ids.js";
-                                                  
-import { error,              } from "./problem.js";
-
-/** Rules for a single element's body, shared by living documents and deltas. */
-
-const REQUIRED_FACTS                                  = {
-  CTX: ["Purpose"],
-  ENT: ["Kind", "Module", "File"],
-  UC: ["Input", "Output", "Errors", "Uses", "Module", "File"],
-  PORT: ["Direction", "Operations", "Module", "File"],
-  ADP: ["Technology", "Module", "File"],
-  FLOW: ["Elements"],
-  MOD: ["Path", "Layer"],
-};
-
-const ALLOWED_VALUES                                                      = {
-  Kind: { kinds: ["ENT"], values: ["aggregate", "entity", "value", "service", "policy", "event"] },
-  Direction: { kinds: ["PORT"], values: ["driven", "driving"] },
-  Layer: { kinds: ["MOD"], values: ["core", "domain", "application", "adapter", "composition"] },
-};
-
-export function elementProblems(path        , doc             , element         )            {
-  const problems            = [];
-  if (SCOPED_KINDS.includes(element.kind) && scopeOf(element.id) === undefined) {
-    problems.push(error(path, element.start, "id-scope", `${element.id} needs a scope: ${element.kind}-<scope>.<name>`));
-  }
-  if (element.op === "REMOVED") return [...problems, ...removedProblems(path, doc, element)];
-
-  const facts = factsOf(doc, element);
-  for (const key of REQUIRED_FACTS[element.kind] ?? []) {
-    if (!facts.has(key)) problems.push(error(path, element.start, "required-fact", `${element.id} is missing "- ${key}:"`));
-  }
-  if (element.kind === "ADP" && !facts.has("Implements") && !facts.has("Drives")) {
-    problems.push(error(path, element.start, "required-fact", `${element.id} needs "- Implements:" or "- Drives:"`));
-  }
-  for (const [key, rule] of Object.entries(ALLOWED_VALUES)) {
-    const value = facts.get(key)?.[0];
-    if (rule.kinds.includes(element.kind) && value !== undefined && !rule.values.includes(value)) {
-      problems.push(error(path, element.start, "fact-value", `${element.id} ${key} must be one of ${rule.values.join(", ")}`));
-    }
-  }
-  if (element.kind === "MOD") {
-    for (const glob of (facts.get("Path") ?? []).flatMap((value) => [...value.matchAll(/`([^`]+)`/g)].map((m) => m[1] ?? "")).filter((p) => /[*?[{]/.test(p))) {
-      problems.push(error(path, element.start, "module-path-glob", `${element.id} Path \`${glob}\` is a glob, which matches no file; name a directory ending in / or a single file, one per Path value`));
-    }
-  }
-  const module = facts.get("Module")?.[0];
-  if (module !== undefined && !findIds(module).some((id) => id.startsWith("MOD-"))) {
-    problems.push(error(path, element.start, "fact-value", `${element.id} Module must name a MOD element`));
-  }
-  if (element.kind === "FLOW" && !bodyText(doc, element).includes("sequenceDiagram")) {
-    problems.push(error(path, element.start, "flow-diagram", `${element.id} needs a Mermaid sequenceDiagram`));
-  }
-  if (element.kind === "REQ") problems.push(...requirementProblems(path, doc, element));
-  if (element.kind === "SCN") problems.push(...scenarioProblems(path, doc, element));
-  return problems;
-}
-
-function removedProblems(path        , doc             , element         )            {
-  const facts = factsOf(doc, element);
-  const problems            = [];
-  if (!facts.has("Reason")) problems.push(error(path, element.start, "removed-reason", `REMOVED ${element.id} needs "- Reason:"`));
-  if (element.kind === "REQ" && !facts.has("Migration")) {
-    problems.push(error(path, element.start, "removed-reason", `REMOVED ${element.id} needs "- Migration:"`));
-  }
-  return problems;
-}
-
-function requirementProblems(path        , doc             , element         )            {
-  const problems            = [];
-  const ownBody = ownLines(doc, element).join("\n");
-  if (!/\b(SHALL|MUST)\b/.test(ownBody)) problems.push(error(path, element.start, "req-keyword", `${element.id} must state SHALL or MUST`));
-  const hasScenario = doc.headings.some((h) => h.line > element.start && h.line < element.end && h.level === element.level + 1 && h.text.startsWith("SCN-"));
-  if (!hasScenario) problems.push(error(path, element.start, "req-scenario", `${element.id} needs at least one scenario`));
-  return problems;
-}
-
-function scenarioProblems(path        , doc             , element         )            {
-  const steps = ownLines(doc, element)
-    .map((line) => /^- (GIVEN|WHEN|THEN|AND) /.exec(line)?.[1])
-    .filter((step) => step !== undefined);
-  const order = steps.filter((step) => step !== "AND").join(" ");
-  if (!/^(GIVEN )*WHEN( THEN)+$/.test(order)) {
-    return [error(path, element.start, "scenario-steps", `${element.id} needs GIVEN steps (optional), one WHEN, then one or more THEN`)];
-  }
-  if (steps[0] === "AND") return [error(path, element.start, "scenario-steps", `${element.id} cannot start with AND`)];
-  return [];
-}
-
-/** The element's lines before its first nested heading, without the heading itself. */
-function ownLines(doc             , element         )           {
-  const lines           = [];
-  for (let i = element.start + 1; i < element.end; i++) {
-    if (!doc.inFence[i] && /^#{1,6} /.test(doc.lines[i] ?? "")) break;
-    lines.push(doc.lines[i] ?? "");
-  }
-  return lines;
-}
-
-function bodyText(doc             , element         )         {
-  return doc.lines.slice(element.start, element.end).join("\n");
-}

package/dist/domain/validation/future_rules.js

@@ -1,40 +0,0 @@
-import { factsOf, headingElements } from "../elements.js";
-import { readRows } from "../edits/managed_tables.js";
-import { findIds, kindOf } from "../ids.js";
-                                                  
-import { PATHS } from "../project/layout.js";
-import { readDelta } from "../project/deltas.js";
-                                                              
-import { readRoadmapItems } from "../project/roadmap.js";
-import { warning,              } from "./problem.js";
-
-/**
- * A `Future` fact keeps room for a need someone stated: a `LATER` capability of the vision, or a
- * feature on the feature map or the roadmap. One that names neither reserves room for a need nobody
- * stated, which the design reviewer treats as a finding; this makes it visible without a review.
- */
-export function futureProblems(view             )            {
-  const slugs = anchorSlugs(view);
-  const unanchored = (text        )          =>
-    !findIds(text).some((id) => kindOf(id) === "LATER") && ![...slugs].some((slug) => new RegExp(`(^|[^a-z0-9-])${slug}([^a-z0-9-]|$)`).test(text));
-  const check = (path        , doc             , from = 0, to = doc.lines.length)            =>
-    headingElements(doc, from, to).flatMap((element) =>
-      (factsOf(doc, element).get("Future") ?? [])
-        .filter(unanchored)
-        .map(() => warning(path, element.start, "future-unanchored", `${element.id} keeps room for a need its Future fact doesn't name; cite the LATER capability, or the feature on the map or roadmap, that it serves`)),
-    );
-  const living = view.living.docs.get(PATHS.architecture);
-  const deltas = view.items
-    .filter((item) => !item.archived && item.kind !== "change")
-    .flatMap((item) => readDelta(item.doc).entries.flatMap((entry) => check(item.path, item.doc, entry.element.start, entry.element.end)));
-  return [...(living === undefined ? [] : check(PATHS.architecture, living)), ...deltas];
-}
-
-/** Feature slugs a Future fact may name: the feature map's, implemented or future, and the roadmap's items. */
-function anchorSlugs(view             )              {
-  const vision = view.snapshot.get(PATHS.vision) ?? "";
-  const roadmap = view.snapshot.get(PATHS.roadmap);
-  const mapped = ["Implemented", "Future"].flatMap((heading) => readRows(vision, heading).map((row) => row[0] ?? ""));
-  const planned = roadmap === undefined ? [] : readRoadmapItems(roadmap).map((item) => item.slug);
-  return new Set([...mapped, ...planned].map((slug) => slug.trim()).filter((slug) => /^[a-z0-9-]+$/.test(slug)));
-}

package/dist/domain/validation/living_rules.js

@@ -1,99 +0,0 @@
-import { ARCHITECTURE_KINDS, sectionForKind } from "../architecture_sections.js";
-import { headingElements, statusOf,              } from "../elements.js";
-import { findIds, scopeOf, STATUS_KINDS } from "../ids.js";
-                                                  
-import { PATHS } from "../project/layout.js";
-                                                              
-import { livingDecisionProblems } from "./decision_rules.js";
-import { elementProblems } from "./element_rules.js";
-import { error, warning,              } from "./problem.js";
-
-/** Rules for the living docs: vision, architecture, specs, ADRs and the IDs they cite. */
-export function livingProblems(view             )            {
-  const problems            = [];
-  for (const { id, places } of view.living.duplicates) {
-    problems.push(error(places[0]?.split(":")[0] ?? "", undefined, "duplicate-id", `${id} is defined more than once: ${places.join(", ")}`));
-  }
-  for (const [path, doc] of view.living.docs) {
-    problems.push(...malformedIdHeadings(path, doc));
-    if (path === PATHS.architecture) problems.push(...architectureProblems(path, doc, everApproved(view, path)));
-    else if (path.startsWith(`${PATHS.specsDir}/`)) problems.push(...specProblems(path, doc));
-    else if (path.startsWith(`${PATHS.adrDir}/`)) problems.push(...adrProblems(path, doc));
-  }
-  for (const path of [...view.living.docs.keys(), PATHS.roadmap]) {
-    const text = view.snapshot.get(path);
-    if (text === undefined) continue;
-    for (const id of findIds(text)) {
-      if (!view.living.elements.has(id)) problems.push(error(path, lineOf(text, id), "unknown-id", `${id} is cited but not defined in the living docs`));
-    }
-  }
-  problems.push(...livingDecisionProblems(view));
-  return problems;
-}
-
-/** A heading shaped like `<KIND>-...: Title` whose ID breaks the grammar. */
-export function malformedIdHeadings(path        , doc             )            {
-  return doc.headings.flatMap((heading) => {
-    const match = /^(?:(?:ADDED|MODIFIED|REMOVED) )?([A-Z]{2,5}-\S*):\s/.exec(heading.text);
-    if (match?.[1] === undefined || findIds(match[1])[0] === match[1]) return [];
-    return [error(path, heading.line, "malformed-id", `"${match[1]}" is not a valid ID`)];
-  });
-}
-
-/** Statuses are stamped by the first approval, so their absence before it is expected. */
-function everApproved(view             , path        )          {
-  return [...view.approvals.values()].some((file) => file.approvals.some((record) => record.artifact === path));
-}
-
-function architectureProblems(path        , doc             , approved         )            {
-  const problems            = [];
-  for (const element of headingElements(doc)) {
-    const section = [...doc.headings].reverse().find((h) => h.level === 2 && h.line < element.start);
-    if (!ARCHITECTURE_KINDS.includes(element.kind)) {
-      problems.push(error(path, element.start, "misplaced-element", `${element.id} does not belong in the architecture`));
-    } else if (element.kind !== "VIEW" && section?.text !== sectionForKind(element.kind)) {
-      problems.push(error(path, element.start, "misplaced-element", `${element.id} belongs under "## ${sectionForKind(element.kind)}"`));
-    }
-    problems.push(...elementProblems(path, doc, element), ...(approved ? statusProblems(path, doc, element) : []));
-  }
-  return problems;
-}
-
-function specProblems(path        , doc             )            {
-  const capability = path.slice(path.lastIndexOf("/") + 1, -".md".length);
-  const problems            = [];
-  const elements = headingElements(doc);
-  for (const element of elements) {
-    const expectedLevel = element.kind === "REQ" ? 2 : element.kind === "SCN" ? 3 : 0;
-    if (expectedLevel === 0) problems.push(error(path, element.start, "misplaced-element", `${element.id} does not belong in a spec`));
-    else if (element.level !== expectedLevel) problems.push(error(path, element.start, "heading-level", `${element.id} must be a level ${expectedLevel} heading`));
-    if (scopeOf(element.id) !== undefined && scopeOf(element.id) !== capability) {
-      problems.push(error(path, element.start, "id-scope", `${element.id} must use the scope "${capability}", the capability of this file`));
-    }
-    problems.push(...elementProblems(path, doc, element), ...statusProblems(path, doc, element));
-  }
-  return problems;
-}
-
-function adrProblems(path        , doc             )            {
-  const text = doc.lines.join("\n");
-  return ["Status", "Date"]
-    .filter((key) => !new RegExp(`^- ${key}: `, "m").test(text))
-    .map((key) => error(path, undefined, "adr-fact", `the ADR is missing "- ${key}:"`));
-}
-
-function statusProblems(path        , doc             , element         )            {
-  const status = statusOf(doc, element);
-  if (STATUS_KINDS.includes(element.kind) && status === undefined) {
-    return [warning(path, element.start, "missing-status", `${element.id} has no status yet; approving the document adds it`)];
-  }
-  if (!STATUS_KINDS.includes(element.kind) && status !== undefined) {
-    return [error(path, element.start, "unexpected-status", `${element.id} is not a kind that carries a status`)];
-  }
-  return [];
-}
-
-export function lineOf(text        , needle        )                     {
-  const index = text.indexOf(needle);
-  return index === -1 ? undefined : text.slice(0, index).split("\n").length - 1;
-}