@printpractical/cruze 0.0.13 → 0.0.14

package/dist/domain/project/plan_parts.js

@@ -1,111 +0,0 @@
-import { findIds } from "../ids.js";
-import { findSection,                  } from "../markdown.js";
-import { tablesIn } from "../markdown_tables.js";
-
-/** The parts of feature.md and change.md that describe what gets built and how it is proved. */
-
-                        
-                     
-                   
-                    
-               
- 
-
-                       
-                 
-                
-                  
-                   
-               
- 
-
-                              
-                  
-               
-               
-               
-               
- 
-
-                            
-                 
-                     
-                   
-                    
-                      
-               
- 
-
-const TASK = /^- (T\d+): `([^`]+)`[^`]*? in ((?:`[^`]+`(?:, )?)+), proves (.+)$/;
-
-export function readScope(doc             )               {
-  const section = findSection(doc, "Scope");
-  if (section === null) return null;
-  const scope        = { delivers: [], builds: [], removes: [], line: section.heading.line };
-  for (let i = section.start; i < section.end; i++) {
-    const match = /^- (Delivers|Builds|Removes): (.*)$/.exec(doc.lines[i] ?? "");
-    if (match?.[1] === undefined || match[2] === undefined) continue;
-    const key = match[1].toLowerCase()                                     ;
-    scope[key] = findIds(match[2]);
-  }
-  return scope;
-}
-
-/** Task lines, and the lines under `## Tasks` that don't parse as tasks. */
-export function readTasks(doc             )                                         {
-  const section = findSection(doc, "Tasks");
-  const tasks         = [];
-  const malformed           = [];
-  if (section === null) return { tasks, malformed };
-  for (let i = section.start; i < section.end; i++) {
-    const line = doc.lines[i] ?? "";
-    if (!line.startsWith("- ")) continue;
-    const match = TASK.exec(line);
-    if (match?.[1] === undefined || match[2] === undefined || match[3] === undefined || match[4] === undefined) {
-      malformed.push(i);
-      continue;
-    }
-    const paths = [...match[3].matchAll(/`([^`]+)`/g)].map((m) => m[1] ?? "");
-    tasks.push({ number: match[1], owner: match[2], paths, proves: findIds(match[4]), line: i });
-  }
-  return { tasks, malformed };
-}
-
-/**
- * Whether a change has been planned. A standalone change is designed first, with an
- * empty test plan and no tasks; plan fills both.
- */
-export function isPlanned(doc             )          {
-  const { tasks, malformed } = readTasks(doc);
-  return readTestPlan(doc).length > 0 || tasks.length > 0 || malformed.length > 0;
-}
-
-export function readTestPlan(doc             )                {
-  const section = findSection(doc, "Test plan");
-  if (section === null) return [];
-  const table = tablesIn(doc.lines, doc.inFence, section.start, section.end)[0];
-  return (table?.rows ?? []).map(({ cells, line }) => ({
-    subject: cells[0] ?? "",
-    seam: cells[1] ?? "",
-    file: (cells[2] ?? "").replace(/`/g, ""),
-    kind: cells[3] ?? "",
-    line,
-  }));
-}
-
-export function readChangesTable(doc             )              {
-  const section = findSection(doc, "Changes");
-  if (section === null) return [];
-  const table = tablesIn(doc.lines, doc.inFence, section.start, section.end)[0];
-  if (table === undefined) return [];
-  const column = (name        )         => table.header.findIndex((cell) => cell.toLowerCase() === name);
-  const cell = (cells          , name        )         => cells[column(name)] ?? "";
-  return table.rows.map(({ cells, line }) => ({
-    change: cells[0] ?? "",
-    delivers: findIds(cell(cells, "delivers")),
-    builds: findIds(cell(cells, "builds")),
-    removes: findIds(cell(cells, "removes")),
-    dependsOn: cell(cells, "depends on").split(",").map((s) => s.trim()).filter((s) => s !== ""),
-    line,
-  }));
-}

package/dist/domain/project/progress.js

@@ -1,43 +0,0 @@
-import { MANAGED_CLOSE, MANAGED_OPEN,                  } from "../markdown.js";
-
-/** The managed `## Progress` block of a feature or change. */
-                           
-                  
-                                                                         
-                                    
-                       
-                  
-                                                 
-                               
- 
-
-export function readProgress(doc             )           {
-  const progress           = { tasks: new Map(), deviations: [], changes: new Map() };
-  const range = progressRange(doc);
-  if (range === null) return progress;
-  for (let i = range.start; i < range.end; i++) {
-    const line = doc.lines[i] ?? "";
-    let match = /^- Branch: (.+)$/.exec(line);
-    if (match?.[1] !== undefined) progress.branch = match[1].trim();
-    match = /^- \[([ x])\] (T\d+)(?: \(([0-9a-f]+)\))?/.exec(line);
-    if (match?.[2] !== undefined) progress.tasks.set(match[2], match[1] === "x" ? (match[3] ?? "") : null);
-    match = /^- Deviation (.+)$/.exec(line);
-    if (match?.[1] !== undefined) progress.deviations.push(match[1]);
-    match = /^- Landed: (.+)$/.exec(line);
-    if (match?.[1] !== undefined) progress.landed = match[1];
-    match = /^- (\d\d-[a-z0-9-]+): (.+)$/.exec(line);
-    if (match?.[1] !== undefined && match[2] !== undefined) progress.changes.set(match[1], match[2]);
-  }
-  return progress;
-}
-
-/** Lines [start, end) inside the managed block that holds `## Progress`, or null. */
-export function progressRange(doc             )                                                      {
-  const heading = doc.headings.find((h) => h.level === 2 && h.text === "Progress");
-  if (heading === undefined || !doc.inManaged[heading.line]) return null;
-  let open = heading.line;
-  while (open > 0 && doc.lines[open]?.trim() !== MANAGED_OPEN) open--;
-  let end = heading.line;
-  while (end < doc.lines.length && doc.lines[end]?.trim() !== MANAGED_CLOSE) end++;
-  return { open, start: heading.line + 1, end };
-}

package/dist/domain/project/project_view.js

@@ -1,72 +0,0 @@
-import { parseApprovals,                    } from "../approvals/records.js";
-import { parseConfig,                   } from "../config.js";
-import { journalPath, parseJournal,                   } from "../journal.js";
-import { PATHS,               } from "./layout.js";
-import { buildLivingModel,                  } from "./living_model.js";
-import { readDelta } from "./deltas.js";
-import { listWorkItems,               } from "./work_items.js";
-
-/** Everything the rules need, loaded once from a snapshot. */
-                              
-                     
-                      
-                    
-                              
-                                                                                     
-                                        
-                                                   
-                                        
-                                                          
-                       
-                                                          
-                          
-                                                           
-                                         
- 
-
-export function buildProjectView(snapshot          )              {
-  const items = listWorkItems(snapshot);
-  const approvals = new Map                       ();
-  const approvalProblems = new Map                ();
-  for (const folder of [".cruze", ...items.map((item) => item.folder)]) {
-    const path = approvalsPath(folder);
-    const { file, problem } = parseApprovals(snapshot.get(path));
-    approvals.set(folder, file);
-    if (problem !== undefined) approvalProblems.set(path, problem);
-  }
-  const retired = new Set(
-    items
-      .filter((item) => item.archived)
-      .flatMap((item) => readDelta(item.doc).entries.filter((e) => e.element.op === "REMOVED").map((e) => e.element.id)),
-  );
-  const journal                 = [];
-  const journalProblems = new Map                  ();
-  for (const folder of [".cruze", ...items.map((item) => item.folder)]) {
-    const path = journalPath(folder);
-    const { entries, badLines } = parseJournal(snapshot.get(path));
-    journal.push(...entries);
-    if (badLines.length > 0) journalProblems.set(path, badLines);
-  }
-  journal.sort((a, b) => a.at.localeCompare(b.at));
-  const configText = snapshot.get(PATHS.config);
-  return {
-    snapshot,
-    living: buildLivingModel(snapshot),
-    items,
-    config: configText === undefined ? null : parseConfig(configText),
-    approvals,
-    approvalProblems,
-    retired,
-    journal,
-    journalProblems,
-  };
-}
-
-export function approvalsPath(folder        )         {
-  return `${folder}/approvals.json`;
-}
-
-/** The folder that holds an artifact's approval: the work item's folder, or `.cruze` for project documents. */
-export function approvalFolder(view             , artifactPath        )         {
-  return view.items.find((item) => item.path === artifactPath)?.folder ?? ".cruze";
-}

package/dist/domain/project/roadmap.js

@@ -1,43 +0,0 @@
-import { readRows } from "../edits/managed_tables.js";
-import { parseMarkdown } from "../markdown.js";
-import { tablesIn } from "../markdown_tables.js";
-
-/** The items of `docs/roadmap.md`, as the cruze-formats skill defines them. */
-
-                              
-               
-               
-                
-                      
-                
-               
- 
-
-                                   
-               
-             
-                
- 
-
-/** Every item in the roadmap's phases, in the order they appear. */
-export function readRoadmapItems(text        )                {
-  const doc = parseMarkdown(text);
-  const items                = [];
-  for (const phase of doc.headings.filter((h) => h.level === 3 && /^Phase \d+: /.test(h.text))) {
-    const number = Number(/^Phase (\d+)/.exec(phase.text)?.[1] ?? 0);
-    const end = doc.headings.find((h) => h.line > phase.line && h.level <= 3)?.line ?? doc.lines.length;
-    for (const table of tablesIn(doc.lines, doc.inFence, phase.line + 1, end)) {
-      for (const { cells, line } of table.rows) {
-        const [slug = "", kind = "", goals = "", blocked = ""] = cells;
-        const blockedBy = blocked.split(",").map((s) => s.trim()).filter((s) => s !== "");
-        items.push({ slug, kind, goals, blockedBy, phase: number, line });
-      }
-    }
-  }
-  return items;
-}
-
-/** The managed `## Status` rows: each started item's folder ID and state. */
-export function readRoadmapStatus(text        )                     {
-  return readRows(text, "Status").map(([slug = "", id = "", state = ""]) => ({ slug, id, state }));
-}

package/dist/domain/project/scope_view.js

@@ -1,134 +0,0 @@
-import { elementLines,                            } from "../elements.js";
-import { findIds } from "../ids.js";
-import { findSection,                  } from "../markdown.js";
-import { readDelta } from "./deltas.js";
-import { readScope } from "./plan_parts.js";
-                                                     
-import { featureOf,                                  } from "./work_items.js";
-
-/**
- * The design a piece of work builds, cut out of the documents that hold it, so a step reads
- * the elements in its scope instead of the whole architecture and the whole feature.
- */
-
-                               
-             
-                
-               
-                                                       
-                 
-                 
- 
-
-                               
-             
-                
-                 
- 
-
-                            
-              
-                     
-                   
-                                                                                                           
-                           
-                                                                                               
-                            
-                                                                                   
-                        
-                                                                         
-                      
-                                                                                       
-                            
-                                                                              
-                    
- 
-
-                   
-                   
-               
-                   
- 
-
-export function scopeView(view             , item          )            {
-  const feature = featureOf(view.items, item);
-  const deltaItem = feature ?? item;
-  const locate = locator(view, deltaItem);
-  const wanted = item.kind === "change" || item.kind === "standalone" ? changeIds(item) : featureIds(deltaItem);
-  const missing           = [];
-  const show = (ids          )                 =>
-    ids.flatMap((id) => {
-      const found = locate(id);
-      if (found === undefined) {
-        missing.push(id);
-        return [];
-      }
-      const shown               = { id, title: found.element.title, source: `${found.path}:${found.element.start + 1}`, body: elementLines(found.doc, found.element) };
-      if (found.element.op !== undefined) shown.op = found.element.op;
-      return [shown];
-    });
-  const elements = show(wanted.elements);
-  const scenarios = withoutRepeatedScenarios(show(wanted.scenarios));
-  const shownIds = new Set([...elements, ...scenarios].map((e) => e.id));
-  const cited = [...new Set([...elements, ...scenarios].flatMap((e) => findIds(e.body.join("\n"))))]
-    .filter((id) => !shownIds.has(id))
-    .flatMap((id) => {
-      const found = locate(id);
-      return found === undefined ? [] : [{ id, title: found.element.title, source: `${found.path}:${found.element.start + 1}` }];
-    });
-  const decisions = decisionLines((feature ?? item).doc);
-  const changeDecisions = feature === undefined ? [] : decisionLines(item.doc);
-  const result            = { ref: item.ref, kind: item.kind, elements, scenarios, cited, decisions, changeDecisions, missing };
-  if (feature !== undefined) result.feature = feature.ref;
-  return result;
-}
-
-/**
- * A requirement shown beside its own scenarios keeps only its own text: its body would repeat
- * each of them, which made up a third of one change's output.
- */
-function withoutRepeatedScenarios(shown                )                 {
-  const ids = new Set(shown.map((e) => e.id));
-  return shown.map((element) => {
-    if (!element.id.startsWith("REQ-")) return element;
-    const first = element.body.findIndex((line, i) => i > 0 && /^#{2,6} /.test(line) && findIds(line).some((id) => ids.has(id)));
-    return first === -1 ? element : { ...element, body: element.body.slice(0, first) };
-  });
-}
-
-/** A change shows what its scope builds, removes and delivers. */
-function changeIds(change          )                                              {
-  const scope = readScope(change.doc);
-  return { elements: [...(scope?.builds ?? []), ...(scope?.removes ?? [])], scenarios: scope?.delivers ?? [] };
-}
-
-/** A feature shows its whole delta: every operation, with a requirement's scenarios inside its body. */
-function featureIds(feature          )                                              {
-  const entries = readDelta(feature.doc).entries;
-  return {
-    elements: entries.filter((e) => e.section === "architecture").map((e) => e.element.id),
-    scenarios: entries.filter((e) => e.section === "spec").map((e) => e.element.id),
-  };
-}
-
-/** Finds an element's body in the work's own delta first, since that is the text the work builds, then in the living docs. */
-function locator(view             , deltaItem          )                                      {
-  const delta = readDelta(deltaItem.doc);
-  const inDelta = new Map                 ();
-  for (const entry of delta.entries) {
-    inDelta.set(entry.element.id, entry.element);
-    for (const scenario of entry.scenarios) inDelta.set(scenario.id, scenario);
-  }
-  return (id) => {
-    const own = inDelta.get(id);
-    if (own !== undefined) return { doc: deltaItem.doc, path: deltaItem.path, element: own };
-    const living = view.living.elements.get(id);
-    return living === undefined ? undefined : { doc: living.doc, path: living.path, element: living.element };
-  };
-}
-
-function decisionLines(doc             )           {
-  const section = findSection(doc, "Settled decisions");
-  if (section === null) return [];
-  return doc.lines.slice(section.start, section.end).filter((line) => line.startsWith("- "));
-}

package/dist/domain/project/work_items.js

@@ -1,68 +0,0 @@
-import { parseMarkdown,                  } from "../markdown.js";
-import { PATHS, filesUnder,               } from "./layout.js";
-
-                                                               
-
-/** A feature, a change inside a feature, or a standalone change. */
-                           
-                     
-                                                                      
-              
-                                                            
-                     
-                 
-               
-                   
-                    
-                                                          
-                      
- 
-
-const FEATURE = /^\.cruze\/(features|archive)\/([^/]+)\/feature\.md$/;
-const FEATURE_CHANGE = /^\.cruze\/(features|archive)\/([^/]+)\/changes\/([^/]+)\/change\.md$/;
-const STANDALONE = /^\.cruze\/(changes|archive)\/([^/]+)\/change\.md$/;
-
-export function listWorkItems(snapshot          )             {
-  const paths = [...filesUnder(snapshot, PATHS.featuresDir), ...filesUnder(snapshot, PATHS.changesDir), ...filesUnder(snapshot, PATHS.archiveDir)];
-  return paths.flatMap((path) => {
-    const item = classify(path);
-    return item === null ? [] : [{ ...item, path, doc: parseMarkdown(snapshot.get(path) ?? "") }];
-  });
-}
-
-export function findWorkItem(items            , ref        )                       {
-  return items.find((item) => item.ref === ref || item.path === ref || item.folder === ref);
-}
-
-/** The feature a change belongs to. */
-export function featureOf(items            , change          )                       {
-  return change.featureRef === undefined ? undefined : items.find((item) => item.kind === "feature" && item.ref === change.featureRef);
-}
-
-export function changesOf(items            , feature          )             {
-  return items.filter((item) => item.featureRef === feature.ref).sort((a, b) => a.ref.localeCompare(b.ref));
-}
-
-function classify(path        )                                        {
-  const folder = path.slice(0, path.lastIndexOf("/"));
-  let match = FEATURE.exec(path);
-  if (match?.[2] !== undefined) {
-    return { kind: "feature", ref: match[2], folderName: match[2], folder, archived: match[1] === "archive" };
-  }
-  match = FEATURE_CHANGE.exec(path);
-  if (match?.[2] !== undefined && match[3] !== undefined) {
-    return {
-      kind: "change",
-      ref: `${match[2]}/${match[3]}`,
-      folderName: match[3],
-      folder,
-      archived: match[1] === "archive",
-      featureRef: match[2],
-    };
-  }
-  match = STANDALONE.exec(path);
-  if (match?.[2] !== undefined) {
-    return { kind: "standalone", ref: match[2], folderName: match[2], folder, archived: match[1] === "archive" };
-  }
-  return null;
-}

package/dist/domain/status/next_step.js

@@ -1,181 +0,0 @@
-import { evaluateApproval,                     } from "../approvals/evaluate.js";
-import { rebaseNeeded } from "../approvals/rebase.js";
-import { PATHS } from "../project/layout.js";
-import { isPlanned, readChangesTable } from "../project/plan_parts.js";
-import { readProgress } from "../project/progress.js";
-                                                              
-import { readRoadmapItems, readRoadmapStatus } from "../project/roadmap.js";
-import { changesOf, featureOf,               } from "../project/work_items.js";
-import { compareVersions } from "../versions/cruze_version.js";
-import { FIRST_RELEASE } from "../versions/rule_versions.js";
-import { pendingReason, pendingRethinks } from "./pending_rethink.js";
-import { awaitsRethink, isVerified } from "./verification.js";
-import { activeChange } from "./work_status.js";
-
-/** The Cruze step to run next, computed from the project's state and the current branch. */
-
-                                                                                                                                         
-
-                           
-             
-                                                                                      
-                  
-                 
- 
-
-                             
-                 
-                                                                                      
-                   
- 
-
-export function nextSteps(view             , branch               )             {
-  const project = projectStep(view);
-  if (project !== null) return { next: project, also: [] };
-  const active = activeChange(view, branch);
-  const inFlight = inRoadmapOrder(view, view.items.filter((item) => !item.archived && item.kind !== "change")).flatMap((item) => itemSteps(view, item, branch));
-  const roadmap = roadmapStep(view);
-  const realign = realignStep(view);
-  const candidates = [
-    ...(active === undefined ? [] : [changeStep(view, active, branch)]),
-    ...inFlight,
-    ...(roadmap === null ? [] : [roadmap]),
-    ...(realign === null ? [] : [realign]),
-  ];
-  const unique = candidates.filter((c, i) => candidates.findIndex((o) => o.step === c.step && o.target === c.target) === i);
-  const [next, ...also] = unique;
-  return { next: next ?? { step: "roadmap", reason: "every item on the roadmap has landed; close the release and plan the next" }, also };
-}
-
-/**
- * Work in flight in the roadmap's order, with items whose roadmap blockers haven't all landed
- * last: a feature designed early still waits for the prefactors the user put before it.
- */
-function inRoadmapOrder(view             , items            )             {
-  const text = view.snapshot.get(PATHS.roadmap);
-  if (text === undefined) return items;
-  const rows = readRoadmapStatus(text);
-  const state = new Map(rows.map((row) => [row.slug, row.state]));
-  const slugOf = new Map(rows.map((row) => [row.id, row.slug]));
-  const roadmap = readRoadmapItems(text);
-  const rank = (item          )                   => {
-    const at = roadmap.findIndex((r) => r.slug === slugOf.get(item.ref));
-    const blocked = at !== -1 && (roadmap[at]?.blockedBy ?? []).some((b) => state.get(b) !== "landed");
-    return [blocked ? 1 : 0, at === -1 ? roadmap.length : at];
-  };
-  return items
-    .map((item, i) => ({ item, key: [...rank(item), i] }))
-    .sort((a, b) => (a.key[0] ?? 0) - (b.key[0] ?? 0) || (a.key[1] ?? 0) - (b.key[1] ?? 0) || (a.key[2] ?? 0) - (b.key[2] ?? 0))
-    .map(({ item }) => item);
-}
-
-/** Realign comes when nothing else is due: the installed skills expect more than the code meets. */
-function realignStep(view             )                  {
-  const config = view.config?.config;
-  if (config?.cruze === undefined) return null;
-  const standards = config.standards ?? FIRST_RELEASE;
-  if (compareVersions(standards, config.cruze) >= 0) return null;
-  return { step: "realign", target: config.cruze, reason: `the code meets Cruze ${standards}'s expectations, and the installed skills are ${config.cruze}` };
-}
-
-/** The project documents come first: nothing else can proceed without them. */
-function projectStep(view             )                  {
-  const docs                                                                                      = [
-    {
-      path: PATHS.vision,
-      missing: { step: "envision", reason: "the project has no vision yet" },
-      unapproved: { step: "envision", reason: "finish the vision and approve it" },
-      changed: { step: "envision", reason: "the vision changed since its approval; review the change and approve it again" },
-    },
-    {
-      path: PATHS.architecture,
-      missing: { step: "architect", reason: "the project has no architecture yet" },
-      unapproved: { step: "architect", reason: "finish the architecture, review it and approve it" },
-      changed: { step: "rethink", target: "architecture", reason: "the architecture changed since its approval" },
-    },
-    {
-      path: PATHS.roadmap,
-      missing: { step: "architect", reason: "the project has no roadmap yet" },
-      unapproved: { step: "roadmap", reason: "approve the release ordering" },
-      changed: { step: "roadmap", reason: "the roadmap changed since its approval; approve the new ordering" },
-    },
-  ];
-  for (const doc of docs) {
-    if (!view.snapshot.has(doc.path)) return doc.missing;
-    const state = evaluateApproval(view, doc.path).state;
-    if (state === "unapproved") return doc.unapproved;
-    if (state !== "approved") return doc.changed;
-  }
-  return null;
-}
-
-function itemSteps(view             , item          , branch               )             {
-  if (item.kind === "standalone") return [changeStep(view, item, branch)];
-  const state = evaluateApproval(view, item.path);
-  if (readChangesTable(item.doc).length === 0) return [{ step: "architect", target: item.ref, reason: "the feature has no design or changes yet" }];
-  if (state.state === "unapproved") return [{ step: "architect", target: item.ref, reason: "review the feature's design and approve it" }];
-  if (state.state !== "approved") return [{ step: "rethink", target: item.ref, reason: staleReason(view, item, "the feature", state) }];
-  const pending = pendingRethinks(view.journal, item);
-  if (pending.length > 0) return [{ step: "rethink", target: item.ref, reason: pendingReason(item, pending) }];
-  const changes = changesOf(view.items, item);
-  const landed = new Set(changes.filter((c) => readProgress(c.doc).landed !== undefined).map((c) => c.folderName));
-  const steps             = [];
-  for (const row of readChangesTable(item.doc)) {
-    const change = changes.find((c) => c.folderName === row.change);
-    if (change !== undefined) {
-      if (!landed.has(row.change)) steps.push(changeStep(view, change, branch));
-    } else if (row.dependsOn.every((d) => landed.has(d))) {
-      steps.push({ step: "plan", target: `${item.ref}/${row.change}`, reason: "the next change of an approved feature, with its dependencies landed" });
-    }
-  }
-  return steps;
-}
-
-function changeStep(view             , change          , branch               )           {
-  const feature = featureOf(view.items, change);
-  const featureState = feature === undefined ? undefined : evaluateApproval(view, feature.path);
-  if (feature !== undefined && featureState !== undefined && featureState.state !== "approved") {
-    return { step: "rethink", target: feature.ref, reason: staleReason(view, feature, `the feature of ${change.ref}`, featureState) };
-  }
-  for (const part of [feature, change]) {
-    const pending = part === undefined ? [] : pendingRethinks(view.journal, part);
-    if (part !== undefined && pending.length > 0) return { step: "rethink", target: part.ref, reason: pendingReason(part, pending) };
-  }
-  const bound = readProgress(change.doc).branch;
-  const state = evaluateApproval(view, change.path);
-  if (!isPlanned(change.doc)) return { step: "plan", target: change.ref, reason: "the change is designed but has no test plan or tasks yet" };
-  if (state.state === "unapproved") return { step: "plan", target: change.ref, reason: "review the plan and approve it on the branch that will build it" };
-  if (state.state !== "approved") return { step: "rethink", target: change.ref, reason: staleReason(view, change, "the change", state) };
-  if (awaitsRethink(view.journal, change, feature)) return { step: "rethink", target: feature?.ref ?? change.ref, reason: `verify sent ${change.ref} back for a design change` };
-  if (bound !== undefined && bound !== branch) return { step: "switch-branch", target: bound, reason: `${change.ref} is built on branch ${bound}` };
-  const progress = readProgress(change.doc);
-  if ([...progress.tasks.values()].some((commit) => commit === null)) return { step: "build", target: change.ref, reason: "the change has open tasks" };
-  if (!isVerified(view.journal, change)) return { step: "verify", target: change.ref, reason: "every task is done; verify the change" };
-  return { step: "land", target: change.ref, reason: "the change is verified and accepted" };
-}
-
-/**
- * Why work went stale, and what the rethink will take: a rebase when its delta still changes an
- * element whose living text moved, or only a check of the diff and a re-stamp when nothing it cites
- * asks anything of its own text. One project expected a re-stamp and met rebase-required.
- */
-function staleReason(view             , item          , label        , state                )         {
-  if (state.state === "edited") return `${label} changed since its approval`;
-  const changed = state.changed.join(", ");
-  const rebase = rebaseNeeded(view, item);
-  const then = rebase.length > 0
-    ? `its delta changes ${rebase.join(", ")}, so rebase it, as cruze diff ${item.ref} shows`
-    : `read cruze diff ${item.ref}, and re-stamp it when the work still holds`;
-  return `something ${label} cites changed since its approval (${changed}); ${then}`;
-}
-
-/** The first roadmap item that hasn't started and whose blockers have all landed. */
-function roadmapStep(view             )                  {
-  const text = view.snapshot.get(PATHS.roadmap);
-  if (text === undefined) return null;
-  const status = new Map(readRoadmapStatus(text).map((row) => [row.slug, row.state]));
-  const item = readRoadmapItems(text).find((i) => !status.has(i.slug) && i.blockedBy.every((b) => status.get(b) === "landed"));
-  if (item === undefined) return null;
-  if (item.kind === "feature") return { step: "envision", target: item.slug, reason: "the next roadmap feature; skip to architect when its requirements are settled" };
-  return { step: "architect", target: item.slug, reason: "the next roadmap change; design it as a tweak" };
-}