halfcycle 0.6.0 → 0.7.1

package/dist/cli.js

@@ -510,6 +510,8 @@ var HOOK_REMEDY = `Run ${SIGN_IN_COMMAND} in the project folder to sign in.`;
 import { z as z2 } from "zod";
 var TASK_PLAN_FILE = "docs/build-records/task-plan.json";
 var TASK_LIST_FILE = "docs/build-records/build-tasks.json";
+var CRITERIA_RECORD_FILE = "docs/build-records/criteria-check.json";
+var AGENT_NAME_MAX = 32;
 var TASK_PLAN_TASKS_MAX = 500;
 var TASK_PLAN_ID_MAX = 64;
 var TASK_PLAN_BUILDS_NONE = "none";
@@ -518,6 +520,9 @@ var TASK_PLAN_SPECS_NONE = "none";
 var EXAMPLE_SPEC = "order-intake";
 var SPEC_NAME = /^[a-z0-9][a-z0-9-]{0,63}$/;
 var CITATION = /^([a-z0-9][a-z0-9-]{0,63}) AC((?:0|[1-9][0-9]*)[a-z]?)$/;
+function isCriterionCitation(text) {
+  return CITATION.test(text);
+}
 var TASK_PLAN_KINDS = ["build", "review", "spec", "walk", "check"];
 var TASK_PLAN_INTERFACE_KINDS = [
   "route",
@@ -531,6 +536,7 @@ var TASK_PLAN_INTERFACE_KINDS = [
 var CONTROL_CHARACTER = /[\u0000-\u001f\u007f-\u009f]/;
 var planText = z2.string().refine((text) => !CONTROL_CHARACTER.test(text), { message: "holds a control character" });
 var taskIdSchema = z2.string().min(1).max(TASK_PLAN_ID_MAX).refine((text) => !CONTROL_CHARACTER.test(text), { message: "holds a control character" });
+var agentNameText = z2.string().min(1).max(AGENT_NAME_MAX).refine((text) => !CONTROL_CHARACTER.test(text), { message: "holds a control character" });
 var taskPlanTaskSchema = z2.object({
   id: taskIdSchema,
   kind: z2.enum(TASK_PLAN_KINDS),
@@ -545,8 +551,25 @@ var taskPlanTaskSchema = z2.object({
   ships: z2.enum(["deploy", "release"]).optional(),
   builds: z2.union([z2.literal(TASK_PLAN_BUILDS_NONE), z2.array(planText)]).optional(),
   criteria: z2.union([z2.literal(TASK_PLAN_CRITERIA_NONE), z2.array(planText)]).optional(),
-  whyOutsidePlan: planText.optional()
+  whyOutsidePlan: planText.optional(),
+  agent: agentNameText.optional(),
+  cheapFirst: z2.literal(true).optional(),
+  criteriaCheck: z2.literal(true).optional()
 }).strict().superRefine((task, ctx) => {
+  if (task.criteriaCheck !== void 0 && (task.kind !== "check" || task.wholeProject !== void 0)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["criteriaCheck"],
+      message: "only a check task that is not a whole-project check is the check against the acceptance criteria"
+    });
+  }
+  if (task.agent !== void 0 && task.heldBy !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["agent"],
+      message: "a task a person holds names no crew member"
+    });
+  }
   if (task.reviews !== void 0 && task.kind !== "review") {
     ctx.addIssue({
       code: "custom",
@@ -582,6 +605,7 @@ var taskListFileSchema = z2.union([
   z2.object({ phase: planText, tasks: z2.array(taskListRowSchema) }).loose(),
   z2.array(z2.unknown())
 ]);
+var PHASE_PLAN_PROBLEMS_SHOWN = 3;
 var taskPlanLineText = {
   O1: (a, b, x) => `"${a}" and "${b}" could run at the same time and both change ${x}. Make one wait for the other: add "${a}" to the dependsOn of "${b}", or the other way round.`,
   O2: (a) => `"${a}" does not say what it touches. List the files and interfaces it changes.`,
@@ -595,6 +619,8 @@ var taskPlanLineText = {
   O6: (phase, asked) => `The plan is for "${phase}", not "${asked}".`,
   O7: (a, file, partIds) => `"${a}" does not say which parts of the system it builds. Add "builds" with the ids of the parts it builds, from ${file}: ${partIds.join(", ")}. If it builds none of them, write "builds": "${TASK_PLAN_BUILDS_NONE}".`,
   O8: (a, parts, file) => parts.length === 1 ? `"${a}" builds "${parts[0]}", which is not in plan: ${file} does not change it. Copy "builds" from that plan's changes (a release, publish or pin task names the part it ships, or "${TASK_PLAN_BUILDS_NONE}"), or say why in "whyOutsidePlan".` : `"${a}" builds ${parts.map((x) => `"${x}"`).join(", ")}, which are not in plan: ${file} changes none of them. Copy "builds" from that plan's changes (a release, publish or pin task names the part it ships, or "${TASK_PLAN_BUILDS_NONE}"), or say why in "whyOutsidePlan".`,
+  O8NoSuchPart: (a, parts, file, partIds) => parts.length === 1 ? `"${a}" builds "${parts[0]}", which is not a part of the system: ${file} has no part with that id. Use an id from ${file}: ${partIds.join(", ")}.` : `"${a}" builds ${parts.map((x) => `"${x}"`).join(", ")}, which are not parts of the system: ${file} has no part with those ids. Use ids from ${file}: ${partIds.join(", ")}.`,
+  O8Unusable: (file, why) => `${file} is there but could not be used, so no task was checked for building a part outside this phase's plan: ${why}. Fix it, then run this again.`,
   C1Form: (a, x, first) => `"${a}" names "${x}", which is not a criterion. Write it as <spec name> AC<number>, for example "${first} AC1".`,
   C1Number: (a, x, folder, slug, n) => `"${a}" names "${x}", but ${folder}/${slug}.md has no AC${n}.`,
   C2: (a, x) => `"${a}" names "${x}", which was retired. Remove it, or name the criterion that replaced it.`,
@@ -604,7 +630,7 @@ var taskPlanLineText = {
   C6None: (folder) => `The plan does not say which feature designs this phase has. Add "specs" with the name of each file in ${folder}/ this phase builds, without ".md". If it has none, write "specs": "${TASK_PLAN_SPECS_NONE}".`,
   C6Malformed: (x, folder) => `The plan's specs name "${x}", which is not a spec name. Use the name of a file in ${folder}/, without ".md".`,
   C6Missing: (slug, folder) => `The plan's specs name "${slug}", but there is no ${folder}/${slug}.md.`,
-  B1: (s, t, x) => `"${s}" and "${t}" both own ${x}. A file belongs to one spec: keep it in the Owns of the spec that mainly changes it, and let the other spec's tasks list it in what they touch.`,
+  B1: (s, t, x, more) => `"${s}" and "${t}" both own ${x}${more === 0 ? "" : more === 1 ? " and 1 more path" : ` and ${more} more paths`}. A file belongs to one spec: keep it in the Owns of the spec that mainly changes it, and let the other spec's tasks list it in what they touch.`,
   B2: (s, x) => `"${s}" lists "${x}" under Owns, which is not a path inside this project. Use a path from the project's top folder; end a folder with /.`,
   N2: (a, files) => `"${a}" changes files that none of its specs own: ${files.join(", ")}. If that is intended there is nothing to do; otherwise add them to a spec's Owns.`,
   N3: (s) => `"${s}" has no Boundary section, so what it owns was not checked.`,
@@ -615,6 +641,19 @@ var taskPlanLineText = {
   K4: (a, b) => `"${a}" is a hand check but waits for "${b}", so it would run late. A hand check waits only for the work it checks.`,
   K5: (a) => `"${a}" releases to users and no walk comes before it. Add a walk that waits for every deploy before it, and make "${a}" wait for that walk.`,
   K6: (a, b, c) => `"${b}" is the walk before "${a}" but does not wait for the deploy "${c}". Make "${b}" wait for "${c}".`,
+  V1: () => 'The plan has no check of the finished phase against its acceptance criteria. Add a task of kind "check" with "criteriaCheck": true, held by a crew member who builds none of this phase, that waits for every build task.',
+  V2: (w, c) => `"${w}" is a walk, and it does not wait for the check of the phase against its acceptance criteria. Add "${c}" to its dependsOn.`,
+  V3Unordered: (c, b) => `"${c}" checks the finished phase, but "${b}" could still be running while it does. Add "${b}" to the dependsOn of "${c}", or, if "${b}" fixes what "${c}" found, name it in ${CRITERIA_RECORD_FILE} and make it wait for "${c}".`,
+  V3Ships: (b, c) => `"${b}" ships to users and waits for "${c}", the check of the finished phase. A deploy or a release comes before that check, so the check sees what is live: add "${b}" to the dependsOn of "${c}" and stop "${b}" waiting for "${c}".`,
+  V3Unchecked: (b, c) => `"${b}" waits for "${c}", the check of the finished phase, and no later check waits for "${b}", so no check sees what it builds. Add "${b}" to the dependsOn of "${c}" and stop "${b}" waiting for "${c}", or add a check of the phase that waits for "${b}".`,
+  V4: (x) => `"${x}" does not say which crew member holds it. Add "agent" with that member's callsign.`,
+  V5: (c, m, b) => `"${c}" checks the finished phase, but ${m} also holds "${b}", which builds part of it. Give "${c}" to a crew member who holds no build task in this phase.`,
+  V6Walk: (c, n, ids, w) => `${CRITERIA_RECORD_FILE} says "${c}" turned ${n} criteria into fix tasks: ${ids.join(", ")}. "${w}" must wait for a new check that waits for each of them: add a task of kind "check" with "criteriaCheck": true that waits for ${ids.join(", ")}, and add it to the dependsOn of "${w}".`,
+  V6Missing: (x) => `${CRITERIA_RECORD_FILE} names "${x}" as a fix task, and the plan has no build task "${x}". Add it, citing the criterion it fixes.`,
+  E1: (crit) => `${crit} is an edge case, and no task writes its test before it is built. Add a build task, held by a crew member who builds none of ${crit}, that writes the test and names ${crit} in its criteria, and make each task that builds ${crit} wait for it.`,
+  E2: (t, crit, m, b) => `"${t}" writes the test for ${crit}, an edge case, but ${m} also holds "${b}", which builds it. Give "${t}" to a crew member who builds none of ${crit}.`,
+  J1: (a) => `"${a}" says "cheapFirst", but it is not a build task. Remove "cheapFirst".`,
+  J2: (a, m) => `"${a}" says "cheapFirst", but ${m} is not on the standard tier. Only a standard-tier task can start on the cheaper tier. Remove "cheapFirst" or give "${a}" to a standard-tier crew member.`,
   P: () => "The plan is clear: no two tasks that could run at once change the same thing, and every check is in place."
 };
 function isMalformedPlanPath(path) {
@@ -683,6 +722,31 @@ function firstSharedItem(a, b) {
   }
   return null;
 }
+function sharedPaths(a, b) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (item) => {
+    if (seen.has(item.key))
+      return;
+    seen.add(item.key);
+    out.push(item.shown);
+  };
+  for (const file of a.files) {
+    if (b.fileKeys.has(file.key))
+      add(file);
+    if (file.key.endsWith("/")) {
+      for (const other of b.files) {
+        if (other.key.startsWith(file.key))
+          add(other);
+      }
+    }
+    for (const folder of b.folders) {
+      if (file.key.startsWith(folder.key))
+        add(file);
+    }
+  }
+  return out;
+}
 function waitsFor(tasks) {
   const n = tasks.length;
   const positionsOf = /* @__PURE__ */ new Map();
@@ -820,10 +884,10 @@ function firstDifference(plan, list2) {
   const listIds = new Set(list2.map((task) => task.id));
   for (const task of plan)
     if (!listIds.has(task.id))
-      return `"${task.id}"`;
+      return `"${task.id}" is in the plan but not in the task list`;
   for (const task of list2)
     if (!planIds.has(task.id))
-      return `"${task.id}"`;
+      return `"${task.id}" is in the task list but not in the plan`;
   const listDeps = /* @__PURE__ */ new Map();
   for (const task of list2) {
     const deps = listDeps.get(task.id) ?? /* @__PURE__ */ new Set();
@@ -840,15 +904,17 @@ function firstDifference(plan, list2) {
   }
   for (const task of plan) {
     const theirs = listDeps.get(task.id);
-    for (const dep of task.dependsOn)
+    for (const dep of task.dependsOn) {
       if (!theirs.has(dep))
-        return `"${task.id}" \u2192 "${dep}"`;
+        return `in the plan "${task.id}" waits for "${dep}", and in the task list it does not`;
+    }
   }
   for (const task of list2) {
     const ours = planDeps.get(task.id);
-    for (const dep of task.dependsOn)
+    for (const dep of task.dependsOn) {
       if (!ours.has(dep))
-        return `"${task.id}" \u2192 "${dep}"`;
+        return `in the task list "${task.id}" waits for "${dep}", and in the plan it does not`;
+    }
   }
   return null;
 }
@@ -898,8 +964,8 @@ var CRITERIA_HEADING = /^##\s+Acceptance criteria/;
 var SECTION_HEADING = /^##\s/;
 var ANY_HEADING = /^#{1,6}\s/;
 var CHECKLIST_ITEM = /^- \[[ x]\] /;
-var EXPLICIT_NUMBER = /^\*\*AC((?:0|[1-9][0-9]*)[a-z]?)(?: —|\.|:)/;
-var RETIRED_LEAD = /^\*\*AC(?:0|[1-9][0-9]*)[a-z]? — retired \d{4}-\d{2}-\d{2}/;
+var EXPLICIT_NUMBER = /^\*\*AC((?:0|[1-9][0-9]*)[a-z]?)( \(edge case\))?(?: —|\.|:)/;
+var RETIRED_LEAD = /^\*\*AC(?:0|[1-9][0-9]*)[a-z]?(?: \(edge case\))? — retired \d{4}-\d{2}-\d{2}/;
 function readSpecCriteria(markdown) {
   const lines = markdown.split(/\r?\n/);
   const start = lines.findIndex((line) => CRITERIA_HEADING.test(line));
@@ -933,14 +999,19 @@ function readSpecCriteria(markdown) {
     const explicit = EXPLICIT_NUMBER.exec(item);
     return {
       number: explicit ? explicit[1] : String(i + 1),
-      retired: RETIRED_LEAD.test(item)
+      retired: RETIRED_LEAD.test(item),
+      kind: explicit?.[2] !== void 0 ? "edge" : "normal"
     };
   });
 }
-function liveNumbers(criteria) {
+function liveCriterionNumbers(criteria) {
   const live = new Set(criteria.filter((c) => !c.retired).map((c) => c.number));
   return distinct(criteria.map((c) => c.number)).filter((n) => live.has(n));
 }
+function liveEdgeCriterionNumbers(criteria) {
+  const edge = new Set(criteria.filter((c) => !c.retired && c.kind === "edge").map((c) => c.number));
+  return liveCriterionNumbers(criteria).filter((n) => edge.has(n));
+}
 function specLines(plan, specFiles) {
   const folder = specFiles.folder;
   if (plan.specs === TASK_PLAN_SPECS_NONE)
@@ -968,7 +1039,7 @@ function specLines(plan, specFiles) {
     const criteria = criteriaOf.get(slug) ?? null;
     if (criteria === null)
       continue;
-    for (const n of liveNumbers(criteria)) {
+    for (const n of liveCriterionNumbers(criteria)) {
       if (!covered.has(`${slug} AC${n}`))
         lines.push(refusal("C3", taskPlanLineText.C3(slug, n)));
     }
@@ -1007,7 +1078,7 @@ function citationLine(taskId, citation, plan, specFiles, criteriaOf) {
     return refusal("C2", taskPlanLineText.C2(taskId, citation));
   return null;
 }
-function shownOwnsText(text) {
+function shownFileText(text) {
   return text.replace(/[\u0000-\u001f\u007f-\u009f]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
 }
 function ownedPathsBySpec(plan, specFiles) {
@@ -1046,9 +1117,9 @@ function ownershipLines(plan, specFiles) {
       continue;
     for (const item of boundary.owns) {
       if (item.kind === "bad") {
-        lines.push(refusal("B2", taskPlanLineText.B2(slug, shownOwnsText(item.text))));
+        lines.push(refusal("B2", taskPlanLineText.B2(slug, shownFileText(item.text))));
       } else if (isMalformedOwnsPath(item.path)) {
-        lines.push(refusal("B2", taskPlanLineText.B2(slug, shownOwnsText(item.path))));
+        lines.push(refusal("B2", taskPlanLineText.B2(slug, shownFileText(item.path))));
       }
     }
   }
@@ -1065,9 +1136,10 @@ function ownershipLines(plan, specFiles) {
   });
   for (let i = 0; i < owned.length; i += 1) {
     for (let j = i + 1; j < owned.length; j += 1) {
-      const shared = firstSharedItem(owned[i].items, owned[j].items);
-      if (shared !== null)
-        lines.push(refusal("B1", taskPlanLineText.B1(owned[i].slug, owned[j].slug, shared)));
+      const shared = sharedPaths(owned[i].items, owned[j].items);
+      if (shared.length > 0) {
+        lines.push(refusal("B1", taskPlanLineText.B1(owned[i].slug, owned[j].slug, shared[0], shared.length - 1)));
+      }
     }
   }
   return lines;
@@ -1232,6 +1304,173 @@ function placementLines(tasks, before) {
   });
   return lines;
 }
+function isCriteriaCheck(task) {
+  return task.kind === "check" && task.criteriaCheck === true;
+}
+function lacksCriteriaCheck(tasks) {
+  return tasks.some((task) => task.kind === "build") && !tasks.some(isCriteriaCheck);
+}
+function mustNameHolder(task) {
+  return mustNameParts(task) || isCriteriaCheck(task);
+}
+function criteriaCheckLines(tasks, before, record2) {
+  const lines = [];
+  const waits = (x, y) => hasBit(before[x], y);
+  const positions = (keep) => {
+    const out = [];
+    tasks.forEach((task, i) => {
+      if (keep(task))
+        out.push(i);
+    });
+    return out;
+  };
+  const builds = positions((task) => task.kind === "build");
+  const checks = positions(isCriteriaCheck);
+  const walks = positions((task) => task.kind === "walk");
+  const releases = positions((task) => task.ships === "release");
+  const exempt = (w) => releases.some((r) => waits(r, w));
+  if (lacksCriteriaCheck(tasks)) {
+    lines.push(refusal("V1", taskPlanLineText.V1()));
+  } else {
+    const last = [...checks].reverse().find((c) => !checks.some((other) => other !== c && waits(other, c)));
+    const named2 = last ?? checks[checks.length - 1];
+    for (const w of walks) {
+      if (exempt(w) || checks.some((c) => waits(w, c)) || named2 === void 0)
+        continue;
+      lines.push(refusal("V2", taskPlanLineText.V2(tasks[w].id, tasks[named2].id)));
+    }
+    const fixes = new Set(record2?.fixTasks ?? []);
+    for (const c of checks) {
+      const cid = tasks[c].id;
+      for (const b of builds) {
+        const bid = tasks[b].id;
+        const checkWaits = waits(c, b);
+        const taskWaits = waits(b, c);
+        if (!checkWaits && !taskWaits) {
+          lines.push(refusal("V3", taskPlanLineText.V3Unordered(cid, bid)));
+        } else if (taskWaits && !fixes.has(bid)) {
+          if (tasks[b].ships !== void 0) {
+            lines.push(refusal("V3", taskPlanLineText.V3Ships(bid, cid)));
+          } else if (!checks.some((other) => other !== c && waits(other, b))) {
+            lines.push(refusal("V3", taskPlanLineText.V3Unchecked(bid, cid)));
+          }
+        }
+      }
+    }
+    for (const c of checks) {
+      const holder = tasks[c].agent;
+      if (holder === void 0)
+        continue;
+      const b = builds.find((p) => tasks[p].agent === holder);
+      if (b !== void 0)
+        lines.push(refusal("V5", taskPlanLineText.V5(tasks[c].id, holder, tasks[b].id)));
+    }
+  }
+  if (record2 !== void 0) {
+    const buildOf = /* @__PURE__ */ new Map();
+    for (const b of builds)
+      if (!buildOf.has(tasks[b].id))
+        buildOf.set(tasks[b].id, b);
+    const ids = distinct(record2.fixTasks);
+    for (const id of ids) {
+      if (!buildOf.has(id))
+        lines.push(refusal("V6", taskPlanLineText.V6Missing(id)));
+    }
+    if (record2.fixTasks.length > 0) {
+      const heldBehindFixes = (c) => tasks[c].id !== record2.check && ids.every((id) => {
+        const f = buildOf.get(id);
+        return f !== void 0 && waits(c, f);
+      });
+      for (const w of walks) {
+        if (exempt(w) || checks.some((c) => waits(w, c) && heldBehindFixes(c)))
+          continue;
+        lines.push(refusal("V6", taskPlanLineText.V6Walk(record2.check, record2.fixTasks.length, ids, tasks[w].id)));
+      }
+    }
+  }
+  return lines;
+}
+function edgeCriteriaAt(plan, specFiles, before) {
+  const criteriaOf = specCriteriaBySlug(specFiles);
+  const out = [];
+  for (const slug of planSpecNamesToRead(plan)) {
+    const criteria = criteriaOf.get(slug) ?? null;
+    if (criteria === null)
+      continue;
+    for (const n of liveEdgeCriterionNumbers(criteria)) {
+      const criterion = `${slug} AC${n}`;
+      const builders = [];
+      plan.tasks.forEach((task, i) => {
+        if (task.kind === "build" && Array.isArray(task.criteria) && task.criteria.includes(criterion)) {
+          builders.push(i);
+        }
+      });
+      const testTask = builders.length < 2 ? void 0 : builders.find((t) => builders.every((b) => b === t || hasBit(before[b], t)));
+      out.push({ criterion, slug, builders, testTask: testTask ?? null });
+    }
+  }
+  return out;
+}
+function edgeCriterionTests(plan, specFiles) {
+  const { before } = waitsFor(plan.tasks);
+  return edgeCriteriaAt(plan, specFiles, before).map((edge) => ({
+    criterion: edge.criterion,
+    slug: edge.slug,
+    builders: edge.builders.map((i) => plan.tasks[i].id),
+    testTask: edge.testTask === null ? null : plan.tasks[edge.testTask].id
+  }));
+}
+function edgeCaseLines(plan, specFiles, before) {
+  const tasks = plan.tasks;
+  const lines = [];
+  for (const edge of edgeCriteriaAt(plan, specFiles, before)) {
+    if (edge.builders.length === 0)
+      continue;
+    if (edge.testTask === null) {
+      lines.push(refusal("E1", taskPlanLineText.E1(edge.criterion)));
+      continue;
+    }
+    const t = edge.testTask;
+    const holder = tasks[t].agent;
+    if (holder === void 0)
+      continue;
+    const b = edge.builders.find((p) => p !== t && tasks[p].agent === holder);
+    if (b !== void 0) {
+      lines.push(refusal("E2", taskPlanLineText.E2(tasks[t].id, edge.criterion, holder, tasks[b].id)));
+    }
+  }
+  return lines;
+}
+function phasePlanUnusableWhy(unusable, asked) {
+  switch (unusable.kind) {
+    case "unreadable":
+      return "it could not be opened";
+    case "not-json":
+      return shownFileText(`it is not valid JSON (${unusable.error})`);
+    case "other-phase":
+      return shownFileText(`it is the plan for "${unusable.phase}", not "${asked}"`);
+    case "problems": {
+      const shown2 = unusable.problems.slice(0, PHASE_PLAN_PROBLEMS_SHOWN).map((problem) => `${problem.path === "" ? "the plan" : problem.path} ${problem.message}`);
+      const more = unusable.problems.length - shown2.length;
+      if (shown2.length === 0)
+        return "it does not pass the plan's own check";
+      return shownFileText(more > 0 ? `${shown2.join("; ")}; and ${more} more` : shown2.join("; "));
+    }
+  }
+}
+function cheapFirstLine(task, crew) {
+  if (task.cheapFirst !== true)
+    return null;
+  if (task.kind !== "build")
+    return refusal("J1", taskPlanLineText.J1(task.id));
+  if (crew === void 0 || task.agent === void 0)
+    return null;
+  const holder = task.agent;
+  const member = crew.find((m) => m.callsign === holder);
+  if (member !== void 0 && member.tier === "standard")
+    return null;
+  return refusal("J2", taskPlanLineText.J2(task.id, holder));
+}
 function checkTaskPlan(plan, request) {
   if (plan.phase !== request.phase) {
     return { lines: [refusal("O6", taskPlanLineText.O6(plan.phase, request.phase))], refused: true };
@@ -1241,6 +1480,10 @@ function checkTaskPlan(plan, request) {
   const system = request.system;
   const criteriaOf = specCriteriaBySlug(request.specFiles);
   const phasePlan = request.phasePlan;
+  const noCriteriaCheck = lacksCriteriaCheck(tasks);
+  if (phasePlan !== void 0 && "unusable" in phasePlan) {
+    lines.push(refusal("O8", taskPlanLineText.O8Unusable(phasePlan.file, phasePlanUnusableWhy(phasePlan.unusable, request.phase))));
+  }
   const ids = new Set(tasks.map((task) => task.id));
   const seen = /* @__PURE__ */ new Set();
   const reportedTwice = /* @__PURE__ */ new Set();
@@ -1281,9 +1524,16 @@ function checkTaskPlan(plan, request) {
     if (system !== void 0 && system.partIds.length > 0 && mustNameParts(task) && namesNoPart(task)) {
       lines.push(refusal("O7", taskPlanLineText.O7(task.id, system.file, system.partIds)));
     }
-    if (phasePlan !== void 0) {
+    if (phasePlan !== void 0 && "partIds" in phasePlan) {
       for (const found of partsNotInPlan([task], phasePlan.partIds)) {
-        lines.push(refusal("O8", taskPlanLineText.O8(found.id, found.parts, phasePlan.file)));
+        const known = new Set(system?.partIds ?? found.parts);
+        const noSuchPart = found.parts.filter((part) => !known.has(part));
+        const outside = found.parts.filter((part) => known.has(part));
+        if (system !== void 0 && noSuchPart.length > 0) {
+          lines.push(refusal("O8", taskPlanLineText.O8NoSuchPart(found.id, noSuchPart, system.file, system.partIds)));
+        }
+        if (outside.length > 0)
+          lines.push(refusal("O8", taskPlanLineText.O8(found.id, outside, phasePlan.file)));
       }
     }
     if (mustNameParts(task) && namesNoCriterion(task)) {
@@ -1296,6 +1546,12 @@ function checkTaskPlan(plan, request) {
           lines.push(line);
       }
     }
+    if (!noCriteriaCheck && mustNameHolder(task) && task.agent === void 0) {
+      lines.push(refusal("V4", taskPlanLineText.V4(task.id)));
+    }
+    const cheap = cheapFirstLine(task, request.crew);
+    if (cheap !== null)
+      lines.push(cheap);
   }
   lines.push(...specLines(plan, request.specFiles));
   const { before, cycles } = waitsFor(tasks);
@@ -1331,12 +1587,160 @@ function checkTaskPlan(plan, request) {
   }
   lines.push(...ownershipNotes(plan, request.specFiles));
   lines.push(...placementLines(tasks, before));
+  lines.push(...criteriaCheckLines(tasks, before, request.criteriaRecord));
+  lines.push(...edgeCaseLines(plan, request.specFiles, before));
   const refused3 = lines.some((line) => line.refuses);
   if (!refused3)
     lines.push({ code: "P", text: taskPlanLineText.P(), refuses: false });
   return { lines, refused: refused3 };
 }
 
+// ../core/dist/criteria-record.js
+var criteriaRecordLineText = {
+  M1: (file, p, q) => `${file} is for "${p}", but the plan is for "${q}". Write the record for this phase.`,
+  M2: (file, x) => `${file} is from "${x}", which is not a check of the phase against its criteria in the plan. Name the check task that made it.`,
+  M3: (file, m, c, k) => `${file} is by ${m}, but "${c}" is held by ${k}. The record names the crew member who holds the check.`,
+  M4: (crit) => `${crit} has no row. Check it, and add it as met with what shows it, or as a fix with the gap and the fix task.`,
+  M5: (file, x, folder) => `${file} has a row for "${x}", which is not a live criterion of this phase's features in ${folder}. Remove it, or correct it.`,
+  M6: (crit) => `${crit} has more than one row. Keep one.`,
+  M7: (crit, x) => `${crit} is fixed by "${x}", but the plan has no build task "${x}" that names ${crit} in its criteria. Add the task, or name it there.`,
+  M8Unmarked: (crit, folder, slug) => `${crit} is not marked an edge case in ${folder}/${slug}.md, so its row does not carry "edge".`,
+  M8Marked: (crit, folder, slug) => `${crit} is marked an edge case in ${folder}/${slug}.md, so its row carries "edge": true.`,
+  M9Evidence: (crit, t) => `${crit} is an edge case, so it is met only by the test written in "${t}", run on a task that builds it. Give its evidence as a test with "writtenIn": "${t}" and the task that built it.`,
+  M9NoTestTask: (crit) => `${crit} is an edge case, and the plan has no task that writes its test, so it cannot be counted as met. Run check-tasks and add that task.`,
+  P: (met, fix) => `The record covers every criterion of this phase's features: ${met} met, ${fix} to fix.`
+};
+function criteriaRecordMismatch(record2, plan) {
+  if (record2.subject.phase !== plan.phase)
+    return "phase";
+  if (!plan.tasks.some((task) => task.id === record2.check && isCriteriaCheck(task)))
+    return "check";
+  return null;
+}
+function liveCriteria(specFiles) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of specFiles.entries) {
+    if (entry.criteria === null || seen.has(entry.slug))
+      continue;
+    seen.add(entry.slug);
+    for (const n of liveCriterionNumbers(entry.criteria))
+      out.push(`${entry.slug} AC${n}`);
+  }
+  return out;
+}
+function liveEdgeCriteria(specFiles) {
+  const out = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of specFiles.entries) {
+    if (entry.criteria === null || seen.has(entry.slug))
+      continue;
+    seen.add(entry.slug);
+    for (const n of liveEdgeCriterionNumbers(entry.criteria))
+      out.add(`${entry.slug} AC${n}`);
+  }
+  return out;
+}
+function slugOf(criterion) {
+  return criterion.slice(0, criterion.lastIndexOf(" AC"));
+}
+function refusal2(code, text) {
+  return { code, text, refuses: true };
+}
+function edgeRowLines(row, isEdge, testTask, plan, folder) {
+  const crit = row.criterion;
+  const lines = [];
+  const marked = row.edge === true;
+  if (marked && !isEdge)
+    lines.push(refusal2("M8", criteriaRecordLineText.M8Unmarked(crit, folder, slugOf(crit))));
+  if (!marked && isEdge)
+    lines.push(refusal2("M8", criteriaRecordLineText.M8Marked(crit, folder, slugOf(crit))));
+  if (!isEdge || row.status !== "met")
+    return lines;
+  if (testTask === null) {
+    lines.push(refusal2("M9", criteriaRecordLineText.M9NoTestTask(crit)));
+    return lines;
+  }
+  const evidence = row.evidence;
+  const builtBy = (id) => id !== testTask && plan.tasks.some((task) => task.id === id && task.kind === "build" && Array.isArray(task.criteria) && task.criteria.includes(crit));
+  const held = evidence.kind === "test" && evidence.writtenIn === testTask && builtBy(evidence.task);
+  if (!held)
+    lines.push(refusal2("M9", criteriaRecordLineText.M9Evidence(crit, testTask)));
+  return lines;
+}
+function checkCriteriaRecord(record2, plan, request) {
+  const { file, specFiles } = request;
+  let met = 0;
+  let fix = 0;
+  for (const row of record2.rows) {
+    if (row.status === "met")
+      met += 1;
+    else
+      fix += 1;
+  }
+  const answer = (lines2) => {
+    const refused3 = lines2.some((line) => line.refuses);
+    return {
+      lines: refused3 ? lines2 : [{ code: "P", text: criteriaRecordLineText.P(met, fix), refuses: false }],
+      refused: refused3,
+      met,
+      fix
+    };
+  };
+  const mismatch = criteriaRecordMismatch(record2, plan);
+  if (mismatch === "phase") {
+    return answer([refusal2("M1", criteriaRecordLineText.M1(file, record2.subject.phase, plan.phase))]);
+  }
+  const lines = [];
+  if (mismatch === "check") {
+    lines.push(refusal2("M2", criteriaRecordLineText.M2(file, record2.check)));
+  } else {
+    const holder = plan.tasks.find((task) => task.id === record2.check)?.agent;
+    if (holder !== void 0 && holder !== record2.by) {
+      lines.push(refusal2("M3", criteriaRecordLineText.M3(file, record2.by, record2.check, holder)));
+    }
+  }
+  const live = liveCriteria(specFiles);
+  const liveSet = new Set(live);
+  const edges = liveEdgeCriteria(specFiles);
+  const testTaskOf = /* @__PURE__ */ new Map();
+  for (const edge of edgeCriterionTests(plan, specFiles)) {
+    if (!testTaskOf.has(edge.criterion))
+      testTaskOf.set(edge.criterion, edge.testTask);
+  }
+  const named2 = /* @__PURE__ */ new Set();
+  const told = /* @__PURE__ */ new Set();
+  for (const row of record2.rows) {
+    const crit = row.criterion;
+    if (!liveSet.has(crit)) {
+      if (!told.has(crit))
+        lines.push(refusal2("M5", criteriaRecordLineText.M5(file, crit, specFiles.folder)));
+      told.add(crit);
+      named2.add(crit);
+      continue;
+    }
+    if (named2.has(crit)) {
+      if (!told.has(crit))
+        lines.push(refusal2("M6", criteriaRecordLineText.M6(crit)));
+      told.add(crit);
+    }
+    named2.add(crit);
+    lines.push(...edgeRowLines(row, edges.has(crit), testTaskOf.get(crit) ?? null, plan, specFiles.folder));
+  }
+  for (const row of record2.rows) {
+    if (row.status !== "fix" || !liveSet.has(row.criterion))
+      continue;
+    const fixes = plan.tasks.some((task) => task.id === row.task && task.kind === "build" && Array.isArray(task.criteria) && task.criteria.includes(row.criterion));
+    if (!fixes)
+      lines.push(refusal2("M7", criteriaRecordLineText.M7(row.criterion, row.task)));
+  }
+  for (const crit of live) {
+    if (!named2.has(crit))
+      lines.push(refusal2("M4", criteriaRecordLineText.M4(crit)));
+  }
+  return answer(lines);
+}
+
 // ../core/dist/spec-boundary.js
 var SPEC_BOUNDARY_OWNS_LABEL = "**Owns.**";
 var SPEC_BOUNDARY_LABELS = [
@@ -1345,6 +1749,7 @@ var SPEC_BOUNDARY_LABELS = [
   "**Allowed dependencies.**",
   "**Revalidation triggers.**"
 ];
+var REPEATED_OWNS_TEXT = "a second **Owns.** label: only the first list is read, so keep every path under one **Owns.** label";
 var BOUNDARY_HEADING = /^## Boundary[ \t]*$/;
 var SECTION_HEADING2 = /^## /;
 var FENCE = /^ {0,3}(`{3,}|~{3,})/;
@@ -1416,9 +1821,13 @@ function readSpecBoundary(markdown) {
     const trimmed = line.trimEnd();
     if (SPEC_BOUNDARY_LABELS.includes(trimmed)) {
       closeList();
-      if (trimmed === SPEC_BOUNDARY_OWNS_LABEL && !ownsSeen) {
-        ownsSeen = true;
-        listOpen = true;
+      if (trimmed === SPEC_BOUNDARY_OWNS_LABEL) {
+        if (ownsSeen) {
+          owns.push({ kind: "bad", text: REPEATED_OWNS_TEXT });
+        } else {
+          ownsSeen = true;
+          listOpen = true;
+        }
       }
       continue;
     }
@@ -1823,8 +2232,8 @@ import { z as z5 } from "zod";
 // ../events/dist/human-agent.js
 import { z as z4 } from "zod";
 var HUMAN_AGENT = "Human";
-var AGENT_NAME_MAX = 32;
-var agentNameSchema = z4.string().min(1).max(AGENT_NAME_MAX);
+var AGENT_NAME_MAX2 = AGENT_NAME_MAX;
+var agentNameSchema = z4.string().min(1).max(AGENT_NAME_MAX2);
 
 // ../events/dist/state.js
 var utcIso8601 = z5.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/, "must be a UTC ISO-8601 timestamp ending in Z");
@@ -2323,7 +2732,7 @@ function isMissingKey(raw, path) {
   }
   return isRecord(parent) && !(String(path[path.length - 1]) in parent);
 }
-function shapeProblemsOf(schema, raw, undeclared) {
+function shapeProblemsOf(schema, raw, undeclared, required = {}) {
   const parsed = schema.safeParse(raw);
   if (parsed.success)
     return [];
@@ -2334,7 +2743,11 @@ function shapeProblemsOf(schema, raw, undeclared) {
         problems.push({ path: dotted([...issue.path, key]), message: undeclared });
       }
     } else if (isMissingKey(raw, issue.path)) {
-      problems.push({ path: dotted(issue.path), message: "is required" });
+      const path = dotted(issue.path);
+      if (Object.hasOwn(required, path))
+        problems.push({ path, message: required[path] });
+      else
+        problems.push({ path: dotted(issue.path), message: "is required" });
     } else {
       problems.push({ path: dotted(issue.path), message: issue.message });
     }
@@ -2417,8 +2830,11 @@ var systemDescriptionProblemSchema = z7.object({
   path: z7.string(),
   message: z7.string()
 }).strict();
+var CONNECTIONS_REQUIRED = "is required; an empty list, [], is fine when no part connects to another";
 function shapeProblems(raw) {
-  return shapeProblemsOf(systemDescriptionSchema, raw, "is not a field a description has");
+  return shapeProblemsOf(systemDescriptionSchema, raw, "is not a field a description has", {
+    connections: CONNECTIONS_REQUIRED
+  });
 }
 function quoted(value) {
   return typeof value === "string" ? shown(value) : "another part";
@@ -3889,9 +4305,54 @@ var workCallRecordSchema = z15.object({
   message: "says how to undo it exactly when it can be undone",
   path: ["how"]
 });
+var WORK_CRITERIA_ROWS_MAX = 500;
+var workCriterionSchema = agentWorkText.refine((t) => isCriterionCitation(t), {
+  message: "must name a criterion as its spec name, a space, then AC and its number, such as order-intake AC1"
+});
+var workCriteriaTestEvidenceSchema = z15.object({
+  kind: z15.literal("test"),
+  task: buildTaskIdSchema,
+  label: agentWorkText,
+  writtenIn: buildTaskIdSchema.optional()
+}).strict();
+var workCriteriaPathEvidenceSchema = z15.object({
+  kind: z15.literal("path"),
+  path: agentWorkText
+}).strict();
+var workCriteriaWalkEvidenceSchema = z15.object({
+  kind: z15.literal("walk"),
+  leg: agentWorkText
+}).strict();
+var workCriteriaEvidenceSchema = z15.discriminatedUnion("kind", [
+  workCriteriaTestEvidenceSchema,
+  workCriteriaPathEvidenceSchema,
+  workCriteriaWalkEvidenceSchema
+]);
+var workCriteriaMetRowSchema = z15.object({
+  criterion: workCriterionSchema,
+  edge: z15.literal(true).optional(),
+  status: z15.literal("met"),
+  evidence: workCriteriaEvidenceSchema
+}).strict();
+var workCriteriaFixRowSchema = z15.object({
+  criterion: workCriterionSchema,
+  edge: z15.literal(true).optional(),
+  status: z15.literal("fix"),
+  gap: agentWorkText,
+  task: buildTaskIdSchema
+}).strict();
+var workCriteriaRowSchema = z15.discriminatedUnion("status", [workCriteriaMetRowSchema, workCriteriaFixRowSchema]);
+var workCriteriaRecordSchema = z15.object({
+  record: z15.literal("criteria"),
+  subject: workPhaseSubjectSchema,
+  check: buildTaskIdSchema,
+  by: agentNameSchema,
+  rows: z15.array(workCriteriaRowSchema).min(1, { message: "must carry at least one criterion" }).max(WORK_CRITERIA_ROWS_MAX, { message: `can carry at most ${WORK_CRITERIA_ROWS_MAX} criteria` })
+}).strict();
 var workRecordSchema = z15.discriminatedUnion("record", [
   workReviewRecordSchema,
   workOutcomesRecordSchema,
+  workCriteriaRecordSchema,
   workClaimsRecordSchema,
   workDiagnosisRecordSchema,
   workCallRecordSchema
@@ -3938,7 +4399,8 @@ var WORK_REFUSAL_STATUS = Object.freeze({
   held: 409,
   "attempt-limit": 409,
   "same-attempt": 409,
-  "call-not-recorded": 409
+  "call-not-recorded": 409,
+  "other-version": 409
 });
 var WORK_REFUSALS = Object.freeze(Object.keys(WORK_REFUSAL_STATUS));
 var workRefusalSchema = z15.enum(WORK_REFUSALS);
@@ -5803,58 +6265,78 @@ var ownerWaitChatResultSchema = z32.discriminatedUnion("outcome", [
 
 // ../events/dist/pacing.js
 import { z as z33 } from "zod";
-var CLAUDE_PLANS = Object.freeze([
-  Object.freeze({ id: "pro", words: "Pro", startingAgents: 2 }),
-  Object.freeze({ id: "max-5x", words: "Max (5\xD7)", startingAgents: 4 }),
-  Object.freeze({ id: "max-20x", words: "Max (20\xD7)", startingAgents: 8 }),
-  Object.freeze({ id: "team", words: "Team", startingAgents: 3 }),
-  Object.freeze({ id: "enterprise", words: "Enterprise", startingAgents: 3 }),
-  Object.freeze({ id: "api-key", words: "I pay for what I use, with an API key", startingAgents: 8 }),
-  Object.freeze({ id: "not-sure", words: "Not sure", startingAgents: 2 })
-]);
-var CLAUDE_PLAN_IDS = Object.freeze(CLAUDE_PLANS.map((plan) => plan.id));
-var claudePlanSchema = z33.enum(CLAUDE_PLAN_IDS);
-var CLAUDE_PLAN_UNKNOWN = "not-sure";
-function claudePlanOf(id) {
-  return CLAUDE_PLANS.find((plan) => plan.id === id) ?? CLAUDE_PLANS.find((plan) => plan.id === CLAUDE_PLAN_UNKNOWN) ?? CLAUDE_PLANS[0];
-}
-function claudePlanKnown(id) {
-  return id !== null && id !== CLAUDE_PLAN_UNKNOWN;
-}
-var CLAUDE_PLAN_SET_IN = ["setup", "console"];
-var claudePlanSetInSchema = z33.enum(CLAUDE_PLAN_SET_IN);
-var KEEP_FREE_PERCENTS = [0, 20];
-var keepFreePercentSchema = z33.union([z33.literal(KEEP_FREE_PERCENTS[0]), z33.literal(KEEP_FREE_PERCENTS[1])]);
+var KEEP_FREE_MAX = 90;
+var keepFreePercentSchema = z33.number().int().min(0).max(KEEP_FREE_MAX);
+var KEEP_FREE_DEFAULT = 20;
 var PACE_AGENTS_MAX = 20;
-var PACE_WINDOW_KINDS = ["five-hour", "seven-day"];
-var paceWindowKindSchema = z33.enum(PACE_WINDOW_KINDS);
-var PACE_WINDOW_WORDS = Object.freeze({
-  "five-hour": "5-hour window",
-  "seven-day": "weekly window"
+var FIVE_HOUR_WINDOW_MINUTES = 300;
+var SEVEN_DAY_WINDOW_MINUTES = 10080;
+var PACE_WINDOW_MINUTES_MAX = 525600;
+var MINUTE_KEY = /^([1-9][0-9]{0,6})-minute$/;
+function isPaceWindowKind(value) {
+  if (value === "five-hour" || value === "seven-day")
+    return true;
+  if (typeof value !== "string")
+    return false;
+  const match = MINUTE_KEY.exec(value);
+  if (match === null)
+    return false;
+  const minutes = Number(match[1]);
+  return minutes <= PACE_WINDOW_MINUTES_MAX && minutes !== FIVE_HOUR_WINDOW_MINUTES && minutes !== SEVEN_DAY_WINDOW_MINUTES;
+}
+var paceWindowKindSchema = z33.custom((value) => isPaceWindowKind(value), {
+  message: "not a usage window key"
 });
+function paceWindowMinutesOf(kind) {
+  if (kind === "five-hour")
+    return FIVE_HOUR_WINDOW_MINUTES;
+  if (kind === "seven-day")
+    return SEVEN_DAY_WINDOW_MINUTES;
+  return Number(MINUTE_KEY.exec(kind)?.[1] ?? 0);
+}
+function paceWindowWordsOf(kind) {
+  const minutes = paceWindowMinutesOf(kind);
+  if (minutes === FIVE_HOUR_WINDOW_MINUTES)
+    return "5-hour window";
+  if (minutes === SEVEN_DAY_WINDOW_MINUTES)
+    return "weekly window";
+  if (minutes % 1440 === 0)
+    return `${String(minutes / 1440)}-day window`;
+  if (minutes % 60 === 0)
+    return `${String(minutes / 60)}-hour window`;
+  return `${String(minutes)}-minute window`;
+}
+function paceShareWordsOf(keepFreePercent) {
+  return keepFreePercent === 20 ? "a fifth" : `${String(keepFreePercent)}%`;
+}
 var PACE_STATES = ["full", "slowing", "holding"];
 var paceStateSchema = z33.enum(PACE_STATES);
-var claudePlanRequestSchema = z33.object({ claudePlan: claudePlanSchema }).strict();
-var keepFreeRequestSchema = z33.object({ keepFreePercent: keepFreePercentSchema }).strict();
-var pacingSettingsSchema = z33.object({
-  claudePlan: claudePlanSchema.nullable(),
-  claudePlanSetIn: claudePlanSetInSchema.nullable(),
-  keepFreePercent: keepFreePercentSchema
-}).strict().refine((s) => s.claudePlan === null === (s.claudePlanSetIn === null), {
-  message: "a plan says where it was given, and only a plan does",
-  path: ["claudePlanSetIn"]
-});
+var PACE_SHARE_GIVEN_IN = ["chat", "agent", "relayed"];
+var paceShareGivenInSchema = z33.enum(PACE_SHARE_GIVEN_IN);
+var paceShareRequestSchema = z33.object({ keepFreePercent: keepFreePercentSchema, givenIn: paceShareGivenInSchema }).strict();
+var paceShareResultSchema = z33.discriminatedUnion("outcome", [
+  z33.object({
+    outcome: z33.literal("recorded"),
+    keepFreePercent: keepFreePercentSchema,
+    moreAllowance: z33.boolean().optional()
+  }).strict(),
+  z33.object({ outcome: z33.literal("needs-the-person"), keepFreePercent: keepFreePercentSchema }).strict(),
+  z33.object({ outcome: z33.literal("not-owner") }).strict(),
+  z33.object({ outcome: z33.literal("no-owner") }).strict(),
+  z33.object({ outcome: z33.literal("unavailable") }).strict()
+]);
 var pacingBasisTaskSchema = z33.object({
   id: buildTaskIdSchema,
   dependsOn: z33.array(buildTaskIdSchema).max(BUILD_SNAPSHOT_TASK_LIMIT),
   budgetMinutes: z33.number().int().min(1).max(BUILD_TASK_BUDGET_MAX_MINUTES).optional(),
-  human: z33.boolean()
+  human: z33.boolean(),
+  kind: buildTaskKindSchema.optional()
 }).strict();
 var pacingBasisSchema = z33.object({
   outcome: z33.literal("basis"),
-  claudePlan: claudePlanSchema.nullable(),
+  claudePlan: z33.string().nullable().optional(),
   keepFreePercent: keepFreePercentSchema,
-  settingsUrl: z33.string().min(1),
+  settingsUrl: z33.string().optional(),
   phase: phaseNameSchema.nullable(),
   tasks: z33.array(pacingBasisTaskSchema).max(BUILD_SNAPSHOT_TASK_LIMIT),
   medianTaskMinutes: z33.number().nonnegative().nullable(),
@@ -5864,12 +6346,21 @@ var paceSuggestionSchema = z33.object({
   number: z33.number().int().min(1).max(PACE_AGENTS_MAX),
   minutes: z33.number().int().nonnegative().nullable(),
   pauses: z33.number().int().nonnegative(),
-  claudePlan: claudePlanSchema.nullable(),
   keepFreePercent: keepFreePercentSchema,
-  settingsUrl: z33.string().min(1).nullable(),
-  knownWindow: paceWindowKindSchema.nullable()
+  knownWindow: paceWindowKindSchema.nullable(),
+  expectedTokens: z33.number().int().nonnegative().optional(),
+  limitTokens: z33.number().int().positive().optional(),
+  multiple: z33.number().positive().nullable().optional(),
+  firstGuess: z33.boolean().optional(),
+  limitSetBy: z33.enum(["default", "person", "other"]).optional()
 }).strict();
 var PACE_NOT_PACED_REASONS = ["not-configured", "unreadable"];
+var limitHeldSchema = z33.object({
+  used: z33.number().int().nonnegative(),
+  limit: z33.number().int().positive(),
+  raiseBy: z33.number().int().nonnegative(),
+  working: z33.number().int().nonnegative()
+}).strict();
 var paceRunResultSchema = z33.discriminatedUnion("outcome", [
   z33.object({
     outcome: z33.literal("paced"),
@@ -5878,83 +6369,93 @@ var paceRunResultSchema = z33.discriminatedUnion("outcome", [
     allowedNow: z33.number().int().nonnegative(),
     windowKind: paceWindowKindSchema.optional(),
     until: utcIso8601.optional(),
-    suggestion: paceSuggestionSchema.optional()
+    keepFreePercent: keepFreePercentSchema.optional(),
+    suggestion: paceSuggestionSchema.optional(),
+    limit: z33.literal("reached").optional(),
+    limitHeld: limitHeldSchema.optional()
   }).strict(),
   z33.object({ outcome: z33.literal("not-paced"), reason: z33.enum(PACE_NOT_PACED_REASONS) }).strict()
 ]);
+function tokenCountWordsOf(n) {
+  if (n < 1e3)
+    return String(Math.max(0, Math.round(n)));
+  const rounded = Number(n.toPrecision(2));
+  const [unit, word] = rounded >= 1e9 ? [1e9, "billion"] : rounded >= 1e6 ? [1e6, "million"] : [1e3, "thousand"];
+  return `${String(Number((rounded / unit).toPrecision(2)))} ${word}`;
+}
 function paceAgentsOf(n) {
   return n === 1 ? "1 agent" : `${String(n)} agents`;
 }
 var DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+var MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var SIX_DAYS_MS = 6 * 24 * 60 * 60 * 1e3;
 function paceClockOf(at, now) {
   const hours = at.getHours();
   const clock = `${String(hours % 12 === 0 ? 12 : hours % 12)}:${String(at.getMinutes()).padStart(2, "0")} ${hours < 12 ? "am" : "pm"}`;
   const sameDay = at.getFullYear() === now.getFullYear() && at.getMonth() === now.getMonth() && at.getDate() === now.getDate();
-  return sameDay ? clock : `${DAY_NAMES[at.getDay()] ?? ""} ${clock}`;
-}
-var CLAUDE_PLAN_QUESTION = [
-  "Which Claude plan do you use? Halfcycle paces builds so they leave part of your allowance for your own work.",
-  CLAUDE_PLANS.map((plan, i) => `${String(i + 1)}) ${plan.words}`).join("  "),
-  `Type a number, or press Enter for "${claudePlanOf(CLAUDE_PLAN_UNKNOWN).words}":`
-].join("\n");
-function claudePlanFromAnswer(answer) {
-  const trimmed = answer.trim();
-  if (trimmed === "")
-    return CLAUDE_PLAN_UNKNOWN;
-  if (!/^[1-9][0-9]*$/.test(trimmed))
-    return null;
-  return CLAUDE_PLANS[Number(trimmed) - 1]?.id ?? null;
-}
-function claudePlanRememberedText(plan, settingsUrl) {
-  return `Using the plan you gave before: ${claudePlanOf(plan).words}. You can change it on your settings page, not by typing in chat: ${settingsUrl}`;
+  if (sameDay)
+    return clock;
+  const day = DAY_NAMES[at.getDay()] ?? "";
+  if (at.getTime() - now.getTime() > SIX_DAYS_MS) {
+    return `${day} ${String(at.getDate())} ${MONTH_NAMES[at.getMonth()] ?? ""} ${clock}`;
+  }
+  return `${day} ${clock}`;
 }
 function paceP1Of(n, minutes) {
   const first = `Halfcycle suggests running ${paceAgentsOf(n)} at once.`;
   return minutes === null ? first : `${first} The work should take about ${timeDurationLabelOf(minutes * 60)}.`;
 }
 var PACE_NO_BUILD_PLAN = "Halfcycle has no build plan for this phase yet, so it cannot say how long the work will take.";
-function paceP2Of(plan) {
-  return `This is a cautious start for your ${claudePlanOf(plan).words} plan. It leaves room for your own work.`;
-}
-function paceP3Of(window) {
-  return `This keeps about a fifth of each ${PACE_WINDOW_WORDS[window]} free for your own work.`;
-}
-function paceP4Of(n, settingsUrl) {
-  const first = `Halfcycle does not know which Claude plan you use, so it starts with ${String(n)}.`;
-  return settingsUrl === null ? first : `${first} You can say which on your settings page, not by typing in chat: ${settingsUrl}`;
+var PACE_P2 = "This is a careful start, so your allowance lasts. It leaves room for your own work.";
+function paceP3Of(keepFreePercent) {
+  return `This keeps about ${paceShareWordsOf(keepFreePercent)} of each usage window free for your own work.`;
 }
+var PACE_P4 = 'Say "faster" for one more agent at once, or "run 5 agents" for a number. More agents use your allowance faster.';
 var PACE_P5 = "This build may use all of your allowance. It will not slow down to leave room for you.";
 function paceP6Of(k) {
   return `It will probably pause ${k === 1 ? "once" : `${String(k)} times`} while your usage window resets.`;
 }
-function paceP7Of(settingsUrl) {
-  const first = "Say a different number to change it.";
-  return settingsUrl === null ? first : `${first} To let builds use all of your allowance, change it on your settings page, not by typing in chat: ${settingsUrl}`;
-}
-function paceStartLinesOf(s) {
+var PACE_P7 = 'Or say how much of your allowance to keep free, like "keep 30% free", or how much this build may use, like "use up to 70%".';
+var PACE_P8 = 'For these to work, run "npx halfcycle" once more in this project.';
+function paceStartLinesOf(s, promptScriptBehind2 = false) {
   const lines = [paceP1Of(s.number, s.minutes)];
   if (s.minutes === null)
     lines.push(PACE_NO_BUILD_PLAN);
-  if (s.keepFreePercent !== 0) {
-    if (s.knownWindow !== null)
-      lines.push(paceP3Of(s.knownWindow));
-    else if (s.claudePlan !== null && claudePlanKnown(s.claudePlan))
-      lines.push(paceP2Of(s.claudePlan));
-  }
-  if (!claudePlanKnown(s.claudePlan))
-    lines.push(paceP4Of(s.number, s.settingsUrl));
   if (s.keepFreePercent === 0)
     lines.push(PACE_P5);
+  else
+    lines.push(s.knownWindow !== null ? paceP3Of(s.keepFreePercent) : PACE_P2);
+  if (s.limitTokens !== void 0 && s.expectedTokens !== void 0) {
+    lines.push(limitL1Of(s.expectedTokens, s.limitTokens, s.multiple ?? null, s.limitSetBy ?? "default"));
+    if (s.firstGuess === true)
+      lines.push(LIMIT_L1B);
+  } else
+    lines.push(LIMIT_L1C);
   if (s.pauses > 0)
     lines.push(paceP6Of(s.pauses));
-  lines.push(paceP7Of(s.settingsUrl));
+  lines.push(PACE_P4, PACE_P7, LIMIT_L2);
+  if (promptScriptBehind2)
+    lines.push(PACE_P8);
   return lines;
 }
-function paceS1Of(window, k, until, now) {
-  return `Halfcycle is slowing this build so you keep about a fifth of this ${PACE_WINDOW_WORDS[window]} for your own work. It will run at most ${paceAgentsOf(k)} at once until ${paceClockOf(until, now)}.`;
+function paceS1Of(window, k, until, now, keepFreePercent) {
+  return `Halfcycle is slowing this build so you keep about ${paceShareWordsOf(keepFreePercent)} of this ${paceWindowWordsOf(window)} for your own work. It will run at most ${paceAgentsOf(k)} at once until ${paceClockOf(until, now)}.`;
 }
-function paceS2Of(window, k, until, now) {
-  const head = `Halfcycle has paused new work in this build until ${paceClockOf(until, now)}, when your ${PACE_WINDOW_WORDS[window]} resets, so you keep about a fifth of it for your own work.`;
+function paceS2Of(window, k, until, now, keepFreePercent) {
+  const head = `Halfcycle has paused new work in this build until ${paceClockOf(until, now)}, when your ${paceWindowWordsOf(window)} resets, so you keep about ${paceShareWordsOf(keepFreePercent)} of it for your own work.`;
   if (k === 0)
     return head;
   return k === 1 ? `${head} The 1 agent already working will finish its task.` : `${head} The ${String(k)} agents already working will finish their tasks.`;
@@ -5963,6 +6464,97 @@ function paceAllowedNowOf(k) {
   return k === 0 ? "Start no more agents now." : `Up to ${String(k)} more ${k === 1 ? "agent" : "agents"} can start now.`;
 }
 var PACE_AGENTS_TOO_MANY = `Run at most ${String(PACE_AGENTS_MAX)} agents at once.`;
+var LIMIT_HISTORY_MAX = 20;
+var LIMIT_PARTS = ["half", "three-quarters", "nine-tenths", "limit"];
+var limitPartSchema = z33.enum(LIMIT_PARTS);
+var LIMIT_SET_BY = ["default", "person", "other"];
+var limitSetBySchema = z33.enum(LIMIT_SET_BY);
+var LIMIT_TYPED_BY = ["person", "not-attended", "cannot-tell"];
+var limitTypedBySchema = z33.enum(LIMIT_TYPED_BY);
+var limitHistoryEntrySchema = z33.object({
+  at: utcIso8601,
+  kind: z33.enum(["raised", "set", "stopped"]),
+  limit: z33.number().int().positive(),
+  by: limitTypedBySchema,
+  relayed: z33.literal(true).optional()
+}).strict();
+var PHASE_LIMIT_FILENAME = "limit.json";
+var phaseLimitFileSchema = z33.object({
+  phase: phaseNameSchema,
+  expected: z33.number().int().nonnegative(),
+  expectedMinutes: z33.number().nonnegative().nullable(),
+  limit: z33.number().int().positive(),
+  multiple: z33.number().positive().nullable(),
+  setBy: limitSetBySchema,
+  firstGuess: z33.boolean(),
+  shown: z33.array(limitPartSchema).max(LIMIT_PARTS.length),
+  awaiting: z33.boolean(),
+  history: z33.array(limitHistoryEntrySchema).max(LIMIT_HISTORY_MAX)
+}).strict();
+function phaseLimitFileOf(raw, phase) {
+  const parsed = phaseLimitFileSchema.safeParse(raw);
+  if (!parsed.success)
+    return null;
+  return phase === null || parsed.data.phase === phase ? parsed.data : null;
+}
+var phaseUsageFileSchema = z33.object({
+  phase: phaseNameSchema,
+  openedAt: utcIso8601,
+  tokens: z33.number().int().nonnegative(),
+  at: utcIso8601
+}).strict();
+function multipleTextOf(multiple) {
+  return String(Math.round(multiple * 100) / 100);
+}
+function multipleWordsOf(multiple) {
+  return multiple === 2 ? "twice" : `${multipleTextOf(multiple)} times`;
+}
+function paceWhenOf(at) {
+  const hours = at.getHours();
+  const clock = `${String(hours % 12 === 0 ? 12 : hours % 12)}:${String(at.getMinutes()).padStart(2, "0")} ${hours < 12 ? "am" : "pm"}`;
+  return `${String(at.getDate())} ${MONTH_NAMES[at.getMonth()] ?? ""}, ${clock}`;
+}
+function limitL1Of(expected, limit, multiple, setBy) {
+  const head = `This phase is expected to use about ${tokenCountWordsOf(expected)} tokens.`;
+  const l = tokenCountWordsOf(limit);
+  if (multiple !== null && setBy !== "other") {
+    return `${head} Halfcycle will stop new work and ask you at ${multipleWordsOf(multiple)} that, ${l} tokens.`;
+  }
+  if (setBy === "person")
+    return `${head} You set the limit at ${l} tokens; Halfcycle will stop new work and ask you there.`;
+  return `${head} The limit is ${l} tokens; Halfcycle will stop new work and ask there.`;
+}
+var LIMIT_L1B = "That is a first guess: this project has not finished enough work for Halfcycle to go on.";
+var LIMIT_L1C = "Halfcycle cannot say how much the work will use, so it has set no usage limit yet.";
+var LIMIT_L2 = 'To change the limit, say "limit it to 1.5 times" or "limit it to 300 million".';
+function limitReachedLineOf(used, limit, working, raiseBy) {
+  const head = `This phase has reached its usage limit: ${tokenCountWordsOf(used)} of ${tokenCountWordsOf(limit)} tokens. No new work will start.`;
+  const finish = working === 0 ? "" : working === 1 ? " The 1 agent already working will finish its task." : ` The ${String(working)} agents already working will finish their tasks.`;
+  return `${head}${finish} Say "keep going" to raise the limit by about ${tokenCountWordsOf(raiseBy)} tokens and carry on, or "stop" to leave the phase paused here. Nothing is lost either way.`;
+}
+var LIMIT_C1_NONE = "No usage limit was set: this phase had no build plan.";
+function limitCloseLineOf(file) {
+  const l = tokenCountWordsOf(file.limit);
+  const t = tokenCountWordsOf(file.expected);
+  if (file.setBy === "default")
+    return `Usage limit: ${l} tokens, from an expected ${t}.`;
+  if (file.setBy === "person")
+    return `Usage limit: ${l} tokens, set by you. Expected: ${t}.`;
+  return `Usage limit: ${l} tokens. Expected: ${t}.`;
+}
+function limitHistoryLineOf(entry) {
+  if (entry.relayed === true)
+    return null;
+  const when = paceWhenOf(new Date(entry.at));
+  const you = entry.by === "person";
+  if (entry.kind === "stopped") {
+    return you ? `On ${when} you stopped the phase at its limit. Nothing was lost.` : `On ${when} the phase was stopped at its limit. Nothing was lost.`;
+  }
+  const l = tokenCountWordsOf(entry.limit);
+  if (!you)
+    return `On ${when} the limit was set to ${l} tokens.`;
+  return entry.kind === "raised" ? `On ${when} you said "keep going": the limit went up to ${l} tokens.` : `On ${when} you set the limit to ${l} tokens.`;
+}
 
 // ../events/dist/autonomy.js
 import { z as z34 } from "zod";
@@ -6186,6 +6778,107 @@ function recordedClaimLine(claim) {
 }
 var NO_UNCHECKED_CLAIMS_LINE = "No agent said a check passes that Halfcycle never ran.";
 
+// ../events/dist/relayed-choices.js
+import { z as z35 } from "zod";
+var RELAYED_CHOICES_FILENAME = "relayed.json";
+var RELAYED_SAID_MAX = 80;
+var relayedChoiceSchema = z35.object({
+  at: utcIso8601,
+  said: z35.string().min(1).max(RELAYED_SAID_MAX)
+}).strict();
+var relayedChoicesFileSchema = z35.object({
+  phase: phaseNameSchema,
+  entries: z35.array(relayedChoiceSchema)
+}).strict();
+function relayedChoiceLineOf(entry) {
+  return `On ${paceWhenOf(new Date(entry.at))} "${entry.said}" reached Halfcycle through Codex, which cannot show who typed it. Halfcycle could not confirm that you typed it, and it let this phase use more of your allowance.`;
+}
+
+// ../events/dist/tier-figures.js
+import { z as z36 } from "zod";
+var TIER_ORDER = ["fast", "standard", "deep"];
+function tierRankOf(tier) {
+  return TIER_ORDER.indexOf(tier);
+}
+function tierAboveOf(tier) {
+  return TIER_ORDER[Math.min(tierRankOf(tier) + 1, TIER_ORDER.length - 1)];
+}
+function hasCheaperRole(member) {
+  return member.role === "builder" && member.tier === "standard";
+}
+function cheaperRoleNameOf(callsign) {
+  return `${callsign.toLowerCase()}fast`;
+}
+function routeCheaperClaudeLineOf(holder, task, model) {
+  return `Start ${holder} on ${task} on the cheaper tier: give the Agent tool the model "${model}". Tell the reviewer the builder tier is fast.`;
+}
+function routeCheaperCodexLineOf(holder, task) {
+  return `Start ${holder} on ${task} on the cheaper tier: use the agent type "${cheaperRoleNameOf(holder)}". Tell the reviewer the builder tier is fast.`;
+}
+function routeStartLineOf(holder, task, tier) {
+  return `Start ${holder} on ${task}. Tell the reviewer the builder tier is ${tier}.`;
+}
+function routeStartUnknownLineOf(holder, task) {
+  return `Start ${holder} on ${task}.`;
+}
+function routeNoSuchTaskLineOf(task) {
+  return `"${task}" is not a task in the plan. Check the task id, then run this again.`;
+}
+var routingRecordSchema = z36.object({
+  phase: z36.string().min(1).max(200),
+  cheapStarted: z36.array(z36.string().min(1).max(200)).max(2e3)
+}).strict();
+var PHASE_MODEL_NAME_MAX = 64;
+var phaseModelsFileSchema = z36.object({
+  phase: z36.string().min(1).max(200),
+  openedAt: z36.string().min(1).max(64),
+  tasks: z36.record(z36.string().min(1).max(200), z36.record(z36.string().min(1).max(PHASE_MODEL_NAME_MAX), z36.number().int().min(0)))
+}).strict();
+function inAttemptOrder(attempts) {
+  return [...attempts].sort((a, b) => a.attempt - b.attempt);
+}
+function tierFiguresOf(work) {
+  const finishedCheaper = [];
+  const movedUp = [];
+  const hadCheaperAttempt = [];
+  for (const task of work.tasks) {
+    const attempts = inAttemptOrder(task.attempts);
+    if (attempts.length === 0)
+      continue;
+    if (task.standing === "passed" && attempts.every((a) => a.builderTier === "fast"))
+      finishedCheaper.push(task.task);
+    if (attempts.length >= 2 && tierRankOf(attempts[attempts.length - 1].builderTier) > tierRankOf(attempts[0].builderTier)) {
+      movedUp.push(task.task);
+    }
+    if (attempts.some((a) => a.builderTier === "fast"))
+      hadCheaperAttempt.push(task.task);
+  }
+  return { finishedCheaper, movedUp, hadCheaperAttempt };
+}
+function tasksWordOf(n) {
+  return n === 1 ? "1 task" : `${String(n)} tasks`;
+}
+function tierCountsLineOf(figures) {
+  if (figures.hadCheaperAttempt.length === 0)
+    return "No task started on the cheaper tier in this phase.";
+  return `The reviews recorded ${tasksWordOf(figures.finishedCheaper.length)} finishing on the cheaper tier and ${String(figures.movedUp.length)} moving up to a stronger one.`;
+}
+var NO_EXPECTED_LINE = "No expected time or usage was recorded for this phase.";
+function expectedActualLineOf(expected, actual) {
+  const took = `The phase took ${timeDurationLabelOf(actual.seconds)} and ${tokenCountWordsOf(actual.tokens)} tokens.`;
+  if (expected.minutes === null)
+    return `Expected about ${tokenCountWordsOf(expected.tokens)} tokens. ${took}`;
+  return `Expected ${timeDurationLabelOf(expected.minutes * 60)} and about ${tokenCountWordsOf(expected.tokens)} tokens. ${took}`;
+}
+function joinedOf(names) {
+  if (names.length <= 1)
+    return names.join("");
+  return `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+}
+function seenModelsLineOf(task, models) {
+  return `Seen in your coding agent's own records: ${task} ran on ${joinedOf(models)}.`;
+}
+
 // dist/engagement-credential.js
 import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { platform as platform2 } from "node:os";
@@ -7864,8 +8557,9 @@ function crewProfileBody(role, group, tier) {
   return `${lines.join("\n")}
 `;
 }
-function crewProfileDescription(member) {
-  return `${member.callsign}, ${CREW_ROLE_WORDS[member.role]} (${member.discipline}), a member of this project's build crew.`;
+function crewProfileDescription(member, cheaper = false) {
+  const attempt = cheaper ? " (cheaper attempt)" : "";
+  return `${member.callsign}, ${CREW_ROLE_WORDS[member.role]} (${member.discipline})${attempt}, a member of this project's build crew.`;
 }
 function plainYamlValue(value) {
   if (/[\r\n]|: | #|^[-?:,[\]{}#&*!|>'"%@`\s]|\s$/.test(value)) {
@@ -7886,17 +8580,19 @@ function claudeCrewProfile(member) {
     crewProfileBody(member.role, member.group, member.tier)
   ].join("\n");
 }
-function codexCrewProfile(member) {
-  const { model, effort } = AGENT_PROFILES.codex.tierModels[member.tier];
+function codexCrewProfile(member, cheaper = false) {
+  const tier = cheaper ? "fast" : member.tier;
+  const { model, effort } = AGENT_PROFILES.codex.tierModels[tier];
   if (effort === void 0)
-    throw new Error(`[halfcycle] Codex's ${member.tier} tier names no reasoning effort.`);
-  const body = crewProfileBody(member.role, member.group, member.tier);
+    throw new Error(`[halfcycle] Codex's ${tier} tier names no reasoning effort.`);
+  const body = crewProfileBody(member.role, member.group, tier);
   if (/[\\"]|[\u0000-\u0009\u000b-\u001f\u007f]/.test(body)) {
     throw new Error("[halfcycle] a crew profile body holds a character a Codex role cannot carry as written.");
   }
+  const name = cheaper ? cheaperRoleNameOf(member.callsign) : member.callsign.toLowerCase();
   return [
-    `name = ${tomlBasicString(member.callsign.toLowerCase())}`,
-    `description = ${tomlBasicString(crewProfileDescription(member))}`,
+    `name = ${tomlBasicString(name)}`,
+    `description = ${tomlBasicString(crewProfileDescription(member, cheaper))}`,
     `model = ${tomlBasicString(model)}`,
     `model_reasoning_effort = ${tomlBasicString(effort)}`,
     `developer_instructions = """`,
@@ -7907,7 +8603,10 @@ function codexCrewProfile(member) {
 function renderCrewProfiles(roster = CREW_ROSTER) {
   return [
     ...roster.map((member) => ({ rel: crewProfileRel("claude-code", member.callsign), text: claudeCrewProfile(member) })),
-    ...roster.filter((member) => member.group !== "reviewer").map((member) => ({ rel: crewProfileRel("codex", member.callsign), text: codexCrewProfile(member) }))
+    ...roster.filter((member) => member.group !== "reviewer").flatMap((member) => [
+      { rel: crewProfileRel("codex", member.callsign), text: codexCrewProfile(member) },
+      ...hasCheaperRole(member) ? [{ rel: crewProfileRel("codex", `${member.callsign}FAST`), text: codexCrewProfile(member, true) }] : []
+    ])
   ];
 }
 var __filename = fileURLToPath(import.meta.url);
@@ -8779,14 +9478,19 @@ ${GENERATED_USER_PROMPT_SCOPE_HEADER} the Halfcycle installer, now also for the
 # <phase>/<part>", "question <phase>/<part>: <words>", "carry <phase>/<part>:
 # <words>", "drop <phase>/<part>: <words>", "reject <phase>/<task>: <words>",
 # "autonomy on" or "autonomy off". Also lets the person who is typing let one
-# step Halfcycle paused run once, by typing "allow" as the whole prompt.
+# step Halfcycle paused run once, by typing "allow" as the whole prompt, and change
+# how a build is paced, by typing "faster", "run 5 agents", "keep 30% free" or
+# "use up to 70%" as the whole prompt, and answer a phase's usage limit by
+# typing "keep going", "stop", "limit it to 1.5 times" or "limit it to 300
+# million" as the whole prompt.
 #
 # AN ORDINARY PROMPT STARTS NOTHING. This script reads the hook input once and
 # looks only at the start of the prompt's value. Unless the prompt begins, after
 # any whitespace (typed, or escaped in the input), with "approve ", "send back ",
 # "accept ", "question ", "carry ", "drop ", "reject " or "autonomy ", in any case,
-# or is "allow" and nothing else but whitespace, it exits 0 with no output, and
-# Node never starts. A quote inside any other field arrives
+# or is "allow", one of the five pacing phrases or one of the usage-limit phrases
+# and nothing else but whitespace,
+# it exits 0 with no output, and Node never starts. A quote inside any other field arrives
 # escaped, so no other field (the folder the session is in, for one) can read as
 # the start of the prompt.
 #
@@ -8812,7 +9516,7 @@ IFS= read -r -d '' HC_INPUT || true
 # \\u escape, or as the UTF-8 bytes of a Unicode space. Compared byte for byte.
 HC_LEAD='[[:space:]]|\\\\[nrtf]|\\\\u(000[9a-d]|0020|00a0|1680|200[0-9a]|202[89f]|205f|3000|feff)'
 HC_LEAD="$HC_LEAD|"$'\\xc2\\xa0|\\xe1\\x9a\\x80|\\xe2\\x80[\\x80-\\x8a\\xa8\\xa9\\xaf]|\\xe2\\x81\\x9f|\\xe3\\x80\\x80|\\xef\\xbb\\xbf'
-if ! printf '%s' "$HC_INPUT" | LC_ALL=C grep -Eiq "\\"prompt\\"[[:space:]]*:[[:space:]]*\\"($HC_LEAD)*((approve|send back|accept|question|carry|drop|reject|autonomy) |allow($HC_LEAD)*\\")"; then
+if ! printf '%s' "$HC_INPUT" | LC_ALL=C grep -Eiq "\\"prompt\\"[[:space:]]*:[[:space:]]*\\"($HC_LEAD)*((approve|send back|accept|question|carry|drop|reject|autonomy|decline) |allow($HC_LEAD)*\\"|(faster|go faster|run [0-9]{1,3} agents?|keep [0-9]{1,3}% free|use up to [0-9]{1,3}%|keep going|stop|stop here|limit it to [0-9]{1,9}(\\.[0-9]{1,2})? (times|million|billion|million tokens|billion tokens))($HC_LEAD)*\\")"; then
   exit 0
 fi
 
@@ -10236,14 +10940,14 @@ async function bindLoopback(env = process.env, engagementId) {
     else
       pending = callback;
   }, engagementId));
-  const bindProblem = await new Promise((resolve8) => {
+  const bindProblem = await new Promise((resolve9) => {
     const onError = (err) => {
-      resolve8(`${err.code ?? "bind failed"} on ${LOOPBACK_REDIRECT_HOST}:${wanted.port}`);
+      resolve9(`${err.code ?? "bind failed"} on ${LOOPBACK_REDIRECT_HOST}:${wanted.port}`);
     };
     server.once("error", onError);
     server.listen({ host: LOOPBACK_REDIRECT_HOST, port: wanted.port }, () => {
       server.removeListener("error", onError);
-      resolve8(null);
+      resolve9(null);
     });
   });
   if (bindProblem !== null) {
@@ -10259,9 +10963,9 @@ async function bindLoopback(env = process.env, engagementId) {
     bound: true,
     target: { port: address.port, state },
     boundAddress: address.address,
-    waitForCallback: ({ timeoutMs, onStillWaiting, stillWaitingMs = DEFAULT_STILL_WAITING_MS }) => new Promise((resolve8) => {
+    waitForCallback: ({ timeoutMs, onStillWaiting, stillWaitingMs = DEFAULT_STILL_WAITING_MS }) => new Promise((resolve9) => {
       if (pending !== null) {
-        resolve8(pending);
+        resolve9(pending);
         return;
       }
       const startedAt = Date.now();
@@ -10272,7 +10976,7 @@ async function bindLoopback(env = process.env, engagementId) {
         clearTimeout(timer);
         deliver = null;
         abandon = null;
-        resolve8(value);
+        resolve9(value);
       };
       const timer = setTimeout(() => finish(null), Math.max(0, timeoutMs));
       deliver = finish;
@@ -10286,9 +10990,9 @@ async function bindLoopback(env = process.env, engagementId) {
   };
 }
 function closeServer(server) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     server.closeAllConnections();
-    server.close(() => resolve8());
+    server.close(() => resolve9());
   });
 }
 
@@ -10311,7 +11015,7 @@ function defaultWrite(text) {
   process.stdout.write(text);
 }
 function defaultSleep(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 function browserOpenCommand(os, url) {
   if (os === "darwin")
@@ -10358,12 +11062,12 @@ async function openBrowser(url, env = process.env, os = platform3(), spawnImpl =
     };
   }
   const { command, args: args2, windowsVerbatimArguments } = browserOpenCommand(os, url);
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     let child;
     try {
       child = spawnImpl(command, args2, { stdio: "ignore", env, windowsVerbatimArguments });
     } catch {
-      resolve8({ opened: false, reason: `${command} could not be run` });
+      resolve9({ opened: false, reason: `${command} could not be run` });
       return;
     }
     let settled = false;
@@ -10372,7 +11076,7 @@ async function openBrowser(url, env = process.env, os = platform3(), spawnImpl =
         return;
       settled = true;
       clearTimeout(timer);
-      resolve8(attempt);
+      resolve9(attempt);
     };
     const timer = setTimeout(() => {
       child.unref();
@@ -10415,8 +11119,8 @@ async function startDeviceAuth(serviceUrl) {
   }
   const body = await res.json().catch(() => null);
   if (res.status !== 201) {
-    const refusal2 = tryRefusal(body);
-    throw new SignInRefused(refusal2?.status ?? String(res.status), refusal2?.message ?? `Sign-in could not be started: ${url} answered ${res.status}.`);
+    const refusal3 = tryRefusal(body);
+    throw new SignInRefused(refusal3?.status ?? String(res.status), refusal3?.message ?? `Sign-in could not be started: ${url} answered ${res.status}.`);
   }
   const parsed = deviceAuthStartResponseSchema.safeParse(body);
   if (!parsed.success) {
@@ -10517,17 +11221,17 @@ async function pollBesideLoopback(serviceUrl, started, wake, deps) {
       continue;
     }
     if (sleep === void 0) {
-      await new Promise((resolve8) => {
-        const timer = setTimeout(resolve8, started.pollIntervalMs);
+      await new Promise((resolve9) => {
+        const timer = setTimeout(resolve9, started.pollIntervalMs);
         interrupt = () => {
           clearTimeout(timer);
-          resolve8();
+          resolve9();
         };
       });
     } else {
-      await new Promise((resolve8) => {
-        interrupt = resolve8;
-        void sleep(started.pollIntervalMs).then(resolve8);
+      await new Promise((resolve9) => {
+        interrupt = resolve9;
+        void sleep(started.pollIntervalMs).then(resolve9);
       });
     }
     interrupt = null;
@@ -10715,9 +11419,9 @@ async function requestEngagementValues(method, url, requestBody, credential, sha
   }
   if (!res.ok) {
     const detail = await res.text().catch(() => "");
-    const refusal2 = res.status === 404 ? void 0 : planeRefusal(detail);
-    if (refusal2) {
-      throw new CreateEngagementRefused(res.status, refusal2.message, refusal2.error, refusal2.reason, `[halfcycle] ${shape.action} failed: ${url} returned ${res.status}. ${refusal2.message} ${shape.nothingHappened}.`);
+    const refusal3 = res.status === 404 ? void 0 : planeRefusal(detail);
+    if (refusal3) {
+      throw new CreateEngagementRefused(res.status, refusal3.message, refusal3.error, refusal3.reason, `[halfcycle] ${shape.action} failed: ${url} returned ${res.status}. ${refusal3.message} ${shape.nothingHappened}.`);
     }
     const wrongOrigin = res.status === 404 ? `That address answered, but it does not serve ${shape.route} \u2014 so it is not the Halfcycle service. ` : "";
     throw new Error(`[halfcycle] ${shape.action} failed: ${url} returned ${res.status}. ${wrongOrigin}${detail ? `Response: ${detail.slice(0, 300)}. ` : ""}${shape.nothingHappened}. ` + CONTROL_ORIGIN_HINT);
@@ -11149,9 +11853,9 @@ function wrongAccountVisibility(act) {
 async function askLine(question2) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   try {
-    return await new Promise((resolve8) => {
-      rl.once("close", () => resolve8(""));
-      rl.question(question2).then(resolve8, () => resolve8(""));
+    return await new Promise((resolve9) => {
+      rl.once("close", () => resolve9(""));
+      rl.question(question2).then(resolve9, () => resolve9(""));
     });
   } finally {
     rl.close();
@@ -11418,10 +12122,10 @@ var SYSTEM_FOLDERS = [
   "C:\\Program Files",
   "C:\\Program Files (x86)"
 ];
-function refuseSystemFolder(targetRepo, platform6 = process.platform) {
+function refuseSystemFolder(targetRepo, platform5 = process.platform) {
   const key = (folder) => {
     const real = realOrLiteral(folder);
-    return platform6 === "win32" ? real.toLowerCase() : real;
+    return platform5 === "win32" ? real.toLowerCase() : real;
   };
   const target = key(targetRepo);
   if (SYSTEM_FOLDERS.some((folder) => key(folder) === target)) {
@@ -11571,9 +12275,9 @@ var WORDS = {
   planFailed: "halfcycle: setting up this folder would stop on a file that could not be read. Nothing has been written; fix that file, then run the preview again."
 };
 function runPreview(targetRepo, options) {
-  const refusal2 = previewRefusal(targetRepo, options);
-  if (refusal2 !== void 0)
-    return { refusal: refusal2 };
+  const refusal3 = previewRefusal(targetRepo, options);
+  if (refusal3 !== void 0)
+    return { refusal: refusal3 };
   let plan;
   try {
     plan = planInstall({ targetRepo, env: options.env, home: options.home });
@@ -11999,105 +12703,6 @@ function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// dist/claude-plan.js
-import { chmodSync as chmodSync3, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "node:fs";
-import { platform as platform4 } from "node:os";
-import { dirname as dirname5, join as join11 } from "node:path";
-var CLAUDE_PLAN_FILENAME = "claude-plan.json";
-var PLAN_QUESTION_TRIES = 3;
-var SEND_TIMEOUT_MS = 5e3;
-var SETTINGS_PAGE_SEGMENT = "settings";
-function claudePlanPath(home) {
-  return join11(halfcycleHome(home), CLAUDE_PLAN_FILENAME);
-}
-function readRememberedClaudePlan(home) {
-  try {
-    const parsed = claudePlanRequestSchema.safeParse(JSON.parse(readFileSync11(claudePlanPath(home), "utf-8")));
-    return parsed.success ? parsed.data.claudePlan : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function rememberClaudePlan(plan, home) {
-  const path = claudePlanPath(home);
-  try {
-    mkdirSync6(dirname5(path), { recursive: true, mode: 448 });
-    writeFileSync6(path, `${JSON.stringify(claudePlanRequestSchema.parse({ claudePlan: plan }))}
-`, { mode: 384 });
-    if (platform4() !== "win32")
-      chmodSync3(path, 384);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function settingsPageUrl(consoleUrl) {
-  if (consoleUrl === void 0 || consoleUrl.trim() === "")
-    return void 0;
-  return `${consoleUrl.replace(/\/+$/, "")}/${SETTINGS_PAGE_SEGMENT}`;
-}
-async function sendClaudePlan(serviceUrl, engagementId, credential, plan, fetchImpl = fetch) {
-  const url = `${serviceUrl.replace(/\/+$/, "")}/engagements/${encodeURIComponent(engagementId)}/claude-plan`;
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), SEND_TIMEOUT_MS);
-  try {
-    const res = await fetchImpl(url, {
-      method: "PUT",
-      headers: { authorization: `Bearer ${credential}`, "content-type": "application/json" },
-      body: JSON.stringify(claudePlanRequestSchema.parse({ claudePlan: plan })),
-      signal: controller.signal
-    });
-    return res.ok;
-  } catch {
-    return false;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-function accountCredential(serviceUrl, env, home) {
-  const fromEnv = env["HALFCYCLE_TOKEN"]?.trim();
-  if (fromEnv)
-    return fromEnv;
-  return readStoredCredential(serviceUrl, home)?.credential;
-}
-async function setupClaudePlan(input, deps) {
-  try {
-    if (!input.ownsProject)
-      return { kind: "not-owner" };
-    if (!deps.interactive())
-      return { kind: "no-person" };
-    const env = deps.env ?? process.env;
-    const send2 = async (plan2) => {
-      const credential = accountCredential(input.serviceUrl, env, deps.home);
-      if (credential === void 0)
-        return false;
-      return sendClaudePlan(input.serviceUrl, input.engagementId, credential, plan2, deps.fetchImpl);
-    };
-    const remembered = readRememberedClaudePlan(deps.home);
-    if (remembered !== void 0) {
-      const sent = await send2(remembered);
-      const settingsUrl = settingsPageUrl(input.consoleUrl);
-      if (sent && settingsUrl !== void 0) {
-        deps.write(`[halfcycle] ${claudePlanRememberedText(remembered, settingsUrl)}
-`);
-      }
-      return { kind: "remembered", plan: remembered, sent };
-    }
-    if (deps.assumeYes === true)
-      return { kind: "no-person" };
-    let plan = null;
-    for (let tries = 0; tries < PLAN_QUESTION_TRIES && plan === null; tries++) {
-      plan = claudePlanFromAnswer(await deps.ask(`${CLAUDE_PLAN_QUESTION} `));
-    }
-    if (plan === null)
-      return { kind: "no-answer" };
-    rememberClaudePlan(plan, deps.home);
-    return { kind: "answered", plan, sent: await send2(plan) };
-  } catch {
-    return { kind: "failed" };
-  }
-}
-
 // dist/probe-mcp.js
 var PROBE_TIMEOUT_MS = 5e3;
 async function probeMcpOrigin(mcpUrl, token) {
@@ -12153,12 +12758,12 @@ async function probeMcpOrigin(mcpUrl, token) {
 // dist/claude-version-probe.js
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { existsSync as existsSync8, realpathSync as realpathSync4 } from "node:fs";
-import { delimiter as delimiter2, join as join12 } from "node:path";
+import { delimiter as delimiter2, join as join11 } from "node:path";
 function execVersionCommand(command, timeoutMs, deps) {
-  const platform6 = deps.platform ?? process.platform;
+  const platform5 = deps.platform ?? process.platform;
   const exec = deps.exec ?? execFileSync3;
   try {
-    return platform6 === "win32" ? exec("cmd.exe", ["/d", "/s", "/c", `"${command} --version"`], {
+    return platform5 === "win32" ? exec("cmd.exe", ["/d", "/s", "/c", `"${command} --version"`], {
       encoding: "utf-8",
       timeout: timeoutMs,
       stdio: ["ignore", "pipe", "ignore"],
@@ -12195,7 +12800,7 @@ var INSTALL_METHOD_RULES = [
 ];
 function probeClaudeCodeInstallMethod(deps = {}) {
   const env = deps.env ?? process.env;
-  const platform6 = deps.platform ?? process.platform;
+  const platform5 = deps.platform ?? process.platform;
   const exists = deps.exists ?? existsSync8;
   const realpath = deps.realpath ?? ((file) => {
     try {
@@ -12204,11 +12809,11 @@ function probeClaudeCodeInstallMethod(deps = {}) {
       return file;
     }
   });
-  const names = platform6 === "win32" ? ["claude.exe", "claude.cmd"] : ["claude"];
+  const names = platform5 === "win32" ? ["claude.exe", "claude.cmd"] : ["claude"];
   const dirs = (env["PATH"] ?? "").split(delimiter2).filter((dir) => dir !== "");
   for (const dir of dirs) {
     for (const name of names) {
-      const file = join12(dir, name);
+      const file = join11(dir, name);
       if (!exists(file))
         continue;
       const real = realpath(file);
@@ -12243,8 +12848,8 @@ function codexInstallLine(codex) {
 }
 
 // dist/build-record/write.js
-import { existsSync as existsSync9, mkdirSync as mkdirSync7, rmSync as rmSync4 } from "node:fs";
-import { basename as basename2, join as join13, resolve as resolve3, relative as relative2, isAbsolute as isAbsolute3 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, rmSync as rmSync4 } from "node:fs";
+import { basename as basename2, join as join12, resolve as resolve3, relative as relative2, isAbsolute as isAbsolute3 } from "node:path";
 
 // dist/build-record/render-v2.js
 var HIDDEN = /[\p{Cc}\p{Zl}\p{Zp}\p{Default_Ignorable_Code_Point}]/u;
@@ -12830,7 +13435,7 @@ function renderBuildRecordV2Markdown(record2) {
 }
 
 // dist/build-record/pair-io.js
-import { closeSync, openSync, readFileSync as readFileSync12, renameSync as renameSync2, rmSync as rmSync3, writeSync } from "node:fs";
+import { closeSync, openSync, readFileSync as readFileSync11, renameSync as renameSync2, rmSync as rmSync3, writeSync } from "node:fs";
 function createExclusiveOnDisk(path, data) {
   const bytes = typeof data === "string" ? Buffer.from(data, "utf-8") : data;
   const fd = openSync(path, "wx");
@@ -12861,7 +13466,7 @@ function isEexist(err) {
 }
 function readIfPresent(path) {
   try {
-    return readFileSync12(path, "utf-8");
+    return readFileSync11(path, "utf-8");
   } catch {
     return null;
   }
@@ -12893,7 +13498,7 @@ function replaceOne(io, tmp, finalPath, text) {
 }
 
 // dist/build-record/write.js
-var BUILD_RECORD_DIR = join13("docs", "build-records");
+var BUILD_RECORD_DIR = join12("docs", "build-records");
 function assertInsideOutDir(outDir, candidate, identity) {
   const rel = relative2(outDir, resolve3(candidate));
   const isPlainFilename = rel !== "" && rel !== ".." && !isAbsolute3(rel) && rel === basename2(rel);
@@ -12931,8 +13536,8 @@ function writeRecordPair(repoRoot, phase, rawRecord, record2, io = NODE_RECORD_P
   }
   const outDir = resolve3(repoRoot, BUILD_RECORD_DIR);
   const segment = renderPhaseSegment(phase);
-  const jsonPath = join13(outDir, `${segment}.json`);
-  const mdPath = join13(outDir, `${segment}.md`);
+  const jsonPath = join12(outDir, `${segment}.json`);
+  const mdPath = join12(outDir, `${segment}.md`);
   const jsonTmp = `${jsonPath}.tmp`;
   const mdTmp = `${mdPath}.tmp`;
   for (const candidate of [jsonPath, mdPath, jsonTmp, mdTmp]) {
@@ -12940,7 +13545,7 @@ function writeRecordPair(repoRoot, phase, rawRecord, record2, io = NODE_RECORD_P
   }
   const jsonText = serialiseServedRecord(rawRecord);
   const mdText = renderBuildRecordV2Markdown(record2);
-  mkdirSync7(outDir, { recursive: true });
+  mkdirSync6(outDir, { recursive: true });
   if (createPairExclusive(io, jsonPath, jsonText, mdPath, mdText) === "created") {
     return { kind: "created", jsonPath, mdPath };
   }
@@ -12978,14 +13583,16 @@ import { join as join20 } from "node:path";
 
 // dist/close-phase.js
 import { execFile, execFileSync as execFileSync5 } from "node:child_process";
+import { readFileSync as readFileSync16 } from "node:fs";
+import { join as join19 } from "node:path";
 
 // dist/plan.js
-import { existsSync as existsSync11, readFileSync as readFileSync16 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync15 } from "node:fs";
+import { join as join18 } from "node:path";
 
 // dist/draw/write.js
-import { closeSync as closeSync2, lstatSync as lstatSync2, mkdirSync as mkdirSync8, openSync as openSync2, readFileSync as readFileSync13, readSync, realpathSync as realpathSync5, rmSync as rmSync5 } from "node:fs";
-import { dirname as dirname6, isAbsolute as isAbsolute4, join as join14, relative as relative3, resolve as resolve4, sep } from "node:path";
+import { closeSync as closeSync2, lstatSync as lstatSync2, mkdirSync as mkdirSync7, openSync as openSync2, readFileSync as readFileSync12, readSync, realpathSync as realpathSync5, rmSync as rmSync5 } from "node:fs";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join13, relative as relative3, resolve as resolve4, sep } from "node:path";
 var DOCS_DIR = "docs";
 var DIAGRAMS_DIR = "diagrams";
 var DIAGRAM_DIR_REL = `${DOCS_DIR}/${DIAGRAMS_DIR}`;
@@ -13041,9 +13648,9 @@ function embedImageLink(base, doc) {
 }
 function diagramPaths(repoRoot, base) {
   const root = resolve4(repoRoot);
-  const dir = join14(root, DOCS_DIR, DIAGRAMS_DIR);
+  const dir = join13(root, DOCS_DIR, DIAGRAMS_DIR);
   const names = fileNames(base);
-  const file = Object.fromEntries(DIAGRAM_FILES.map((which) => [which, join14(dir, names[which])]));
+  const file = Object.fromEntries(DIAGRAM_FILES.map((which) => [which, join13(dir, names[which])]));
   return { repoRoot: root, dir, file };
 }
 function diagramRel(base, which) {
@@ -13078,7 +13685,7 @@ function checkDiagramPlace(paths) {
   }
   let ancestor = paths.dir;
   while (lstatOrNull2(ancestor) === null) {
-    const parent = dirname6(ancestor);
+    const parent = dirname5(ancestor);
     if (parent === ancestor)
       break;
     ancestor = parent;
@@ -13138,7 +13745,7 @@ function readExistingSet(paths) {
     if (!stat.isFile())
       return { ok: false, inTheWay: which, temp: false };
     try {
-      found[which] = readFileSync13(paths.file[which]);
+      found[which] = readFileSync12(paths.file[which]);
     } catch {
       return { ok: false, inTheWay: which, temp: false };
     }
@@ -13241,7 +13848,7 @@ function writeDiagramSet(repoRoot, base, set, io = NODE_RECORD_PAIR_IO) {
   if (changed.length === 0)
     return { kind: "up-to-date" };
   try {
-    mkdirSync8(paths.dir, { recursive: true });
+    mkdirSync7(paths.dir, { recursive: true });
   } catch {
     return { kind: "failed", file: changed[0], removed: [] };
   }
@@ -13316,10 +13923,10 @@ function isMissingRoute(method, status, body) {
 }
 
 // dist/change.js
-import { join as join17 } from "node:path";
+import { join as join16 } from "node:path";
 
 // dist/cli-contract.js
-var CLI_VERBS = ["install", "check-drift", "build-record", "open-phase", "close-phase", "system", "draw", "plan", "review", "check-tasks", "check-report", "ready", "uninstall", "change", "pace", "prove", "preview", "doctor", "restore"];
+var CLI_VERBS = ["install", "check-drift", "build-record", "open-phase", "close-phase", "system", "draw", "plan", "review", "check-tasks", "check-criteria", "check-report", "ready", "uninstall", "change", "pace", "route", "prove", "preview", "doctor", "restore"];
 var CONTRACTS = [
   { verb: "install", required: [], conditional: [] },
   { verb: "check-drift", required: [], conditional: [] },
@@ -13329,9 +13936,11 @@ var CONTRACTS = [
   { verb: "plan", required: [], conditional: [] },
   { verb: "review", required: [], conditional: [] },
   { verb: "check-tasks", required: [], conditional: [] },
+  { verb: "check-criteria", required: [], conditional: [] },
   { verb: "ready", required: [], conditional: [] },
   { verb: "uninstall", required: [], conditional: [] },
   { verb: "pace", required: [], conditional: [] },
+  { verb: "route", required: [], conditional: [] },
   { verb: "prove", required: [], conditional: [] },
   { verb: "preview", required: [], conditional: [] },
   { verb: "doctor", required: [], conditional: [] },
@@ -13526,12 +14135,12 @@ function placeholderRefusal(verb, tokens) {
 
 // dist/system-report.js
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { readFileSync as readFileSync14 } from "node:fs";
-import { join as join15 } from "node:path";
+import { readFileSync as readFileSync13 } from "node:fs";
+import { join as join14 } from "node:path";
 function readDescriptionFile(repoRoot) {
   let text;
   try {
-    text = readFileSync14(join15(repoRoot, SYSTEM_DESCRIPTION_REL), "utf-8");
+    text = readFileSync13(join14(repoRoot, SYSTEM_DESCRIPTION_REL), "utf-8");
   } catch (err) {
     const code = err.code;
     return code === "ENOENT" || code === "ENOTDIR" ? { kind: "missing" } : { kind: "unreadable" };
@@ -13706,9 +14315,9 @@ async function checkAndReportDescription(repoRoot, deps, verb, beforeSend = () =
   }
   const unowned = unownedPatterns(checked.description, deps.listTracked(repoRoot));
   const warnings = unowned === null ? "" : unownedPatternLines(unowned, verb);
-  const refusal2 = beforeSend(checked.description);
-  if (refusal2 !== null)
-    return { kind: "stopped", stderr: warnings + refusal2 };
+  const refusal3 = beforeSend(checked.description);
+  if (refusal3 !== null)
+    return { kind: "stopped", stderr: warnings + refusal3 };
   const credentialRead = readCredentialOrLine(repoRoot, deps, verb);
   if (!credentialRead.ok)
     return { kind: "stopped", stderr: warnings + credentialRead.line };
@@ -13755,8 +14364,8 @@ async function runSystem(repoRoot, deps) {
 }
 
 // dist/build-record/write-change.js
-import { existsSync as existsSync10, mkdirSync as mkdirSync9 } from "node:fs";
-import { basename as basename3, isAbsolute as isAbsolute5, join as join16, relative as relative4, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8 } from "node:fs";
+import { basename as basename3, isAbsolute as isAbsolute5, join as join15, relative as relative4, resolve as resolve5 } from "node:path";
 
 // dist/build-record/render-change.js
 function counted2(n, one, many) {
@@ -13901,7 +14510,7 @@ function renderChangeRecordMarkdown(record2) {
 }
 
 // dist/build-record/write-change.js
-var CHANGE_RECORD_DIR = join16("docs", "build-records", "changes");
+var CHANGE_RECORD_DIR = join15("docs", "build-records", "changes");
 var InvalidChangeIdError = class extends Error {
   id;
   constructor(id) {
@@ -13921,15 +14530,15 @@ function writeChangeRecordPair(repoRoot, sortingId, rawRecord, record2, io = NOD
   if (!checked.success)
     throw new InvalidChangeIdError(sortingId);
   const outDir = resolve5(repoRoot, CHANGE_RECORD_DIR);
-  const jsonPath = join16(outDir, `${checked.data}.json`);
-  const mdPath = join16(outDir, `${checked.data}.md`);
+  const jsonPath = join15(outDir, `${checked.data}.json`);
+  const mdPath = join15(outDir, `${checked.data}.md`);
   const mdTmp = `${mdPath}.tmp`;
   for (const candidate of [jsonPath, mdPath, mdTmp]) {
     assertInsideChangeDir(outDir, candidate, sortingId);
   }
   const jsonText = serialiseServedRecord(rawRecord);
   const mdText = renderChangeRecordMarkdown(record2);
-  mkdirSync9(outDir, { recursive: true });
+  mkdirSync8(outDir, { recursive: true });
   if (createPairExclusive(io, jsonPath, jsonText, mdPath, mdText) === "created") {
     return { kind: "created", jsonPath, mdPath };
   }
@@ -14173,9 +14782,9 @@ async function readChangeRecord(deps, credential, sortingId) {
   }
   if (isMissingRoute("GET", status, raw))
     return { kind: "no-route" };
-  const refusal2 = changeRefusalErrorSchema.safeParse(raw);
-  if (refusal2.success)
-    return { kind: "refused", line: refusal2.data.message };
+  const refusal3 = changeRefusalErrorSchema.safeParse(raw);
+  if (refusal3.success)
+    return { kind: "refused", line: refusal3.data.message };
   if (status === 404) {
     const gone = wireErrorSchema.safeParse(raw);
     if (gone.success && gone.data.error === "EngagementNotFound") {
@@ -14198,7 +14807,7 @@ function writePairLines(deps, repoRoot, sortingId, found) {
       };
     }
     return {
-      stdout: `[halfcycle] Its record is in ${join17(CHANGE_RECORD_DIR, `${sortingId}.md`)}.
+      stdout: `[halfcycle] Its record is in ${join16(CHANGE_RECORD_DIR, `${sortingId}.md`)}.
 `,
       stderr: "",
       ok: true
@@ -14437,27 +15046,27 @@ function runChange(repoRoot, args2, deps) {
 }
 
 // dist/shown-record.js
-import { chmodSync as chmodSync4, mkdirSync as mkdirSync10, readFileSync as readFileSync15, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync7 } from "node:fs";
-import { platform as platform5 } from "node:os";
-import { join as join18 } from "node:path";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync9, readFileSync as readFileSync14, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { platform as platform4 } from "node:os";
+import { join as join17 } from "node:path";
 function updateShownRecord(engagementId, update, home) {
   let temp = null;
   try {
     const dir = engagementStateDir(engagementId, home);
-    const path = join18(dir, SHOWN_PLANS_FILENAME);
+    const path = join17(dir, SHOWN_PLANS_FILENAME);
     let current;
     try {
-      current = parseShownRecord(readFileSync15(path, "utf-8"));
+      current = parseShownRecord(readFileSync14(path, "utf-8"));
     } catch {
       current = { entries: [], reviews: [] };
     }
     const next = update(current);
     const body = serialiseShownRecord(next);
-    mkdirSync10(dir, { recursive: true, mode: 448 });
-    temp = join18(dir, `.${SHOWN_PLANS_FILENAME}.${process.pid}.tmp`);
-    writeFileSync7(temp, body, { mode: 384 });
-    if (platform5() !== "win32")
-      chmodSync4(temp, 384);
+    mkdirSync9(dir, { recursive: true, mode: 448 });
+    temp = join17(dir, `.${SHOWN_PLANS_FILENAME}.${process.pid}.tmp`);
+    writeFileSync6(temp, body, { mode: 384 });
+    if (platform4() !== "win32")
+      chmodSync3(temp, 384);
     renameSync3(temp, path);
     return { ok: true, record: next };
   } catch {
@@ -14531,7 +15140,7 @@ function readAndCheckPlan(repoRoot, phase, description, verb) {
   const fileRel = planFileRel(phase);
   let text;
   try {
-    text = readFileSync16(join19(repoRoot, fileRel), "utf-8");
+    text = readFileSync15(join18(repoRoot, fileRel), "utf-8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT" || code === "ENOTDIR") {
@@ -14687,7 +15296,7 @@ function removalOwedLines(verb, parts) {
 function redrawLine(repoRoot, phase) {
   let exists;
   try {
-    exists = existsSync11(join19(repoRoot, DIAGRAM_DIR_REL, embedImageName(phaseDiagramBase(phase))));
+    exists = existsSync11(join18(repoRoot, DIAGRAM_DIR_REL, embedImageName(phaseDiagramBase(phase))));
   } catch {
     return null;
   }
@@ -15274,7 +15883,7 @@ function readObserveLine(stdout) {
 function runRunnerChild(binary, args2, credential, repoRoot, readLine, fallback) {
   if (binary instanceof Error)
     return Promise.resolve(fallback);
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     try {
       execFile(process.execPath, [binary, ...args2], {
         cwd: repoRoot,
@@ -15284,10 +15893,10 @@ function runRunnerChild(binary, args2, credential, repoRoot, readLine, fallback)
         windowsHide: true
       }, (err, stdout) => {
         const stopped = err !== null && err.killed === true;
-        resolve8(stopped || typeof stdout !== "string" ? fallback : readLine(stdout));
+        resolve9(stopped || typeof stdout !== "string" ? fallback : readLine(stdout));
       });
     } catch {
-      resolve8(fallback);
+      resolve9(fallback);
     }
   });
 }
@@ -15630,6 +16239,101 @@ function wentAheadCloseLines(calls) {
 function callsListedLine(n) {
   return `${String(n)} calls made without asking are listed in the review.`;
 }
+var PHASE_MODELS_FILENAME = "phase-models.json";
+var PACING_FOLDER = "pacing";
+function pacingFile(engagementId, name, home) {
+  try {
+    return join19(engagementStateDir(engagementId, home), PACING_FOLDER, name);
+  } catch {
+    return null;
+  }
+}
+function readPhaseLimitFile(engagementId, phase, home) {
+  const path = pacingFile(engagementId, PHASE_LIMIT_FILENAME, home);
+  if (path === null)
+    return null;
+  let text;
+  try {
+    text = readFileSync16(path, "utf-8");
+  } catch (err) {
+    return err.code === "ENOENT" ? "missing" : null;
+  }
+  try {
+    return phaseLimitFileOf(JSON.parse(text), phase);
+  } catch {
+    return null;
+  }
+}
+function readPhaseExpected(engagementId, phase, home) {
+  const file = readPhaseLimitFile(engagementId, phase, home);
+  if (file === null || file === "missing")
+    return null;
+  return { tokens: file.expected, minutes: file.expectedMinutes };
+}
+function phaseLimitLines(engagementId, phase, home) {
+  const file = readPhaseLimitFile(engagementId, phase, home);
+  if (file === null)
+    return [];
+  if (file === "missing")
+    return [LIMIT_C1_NONE];
+  const lines = [limitCloseLineOf(file)];
+  for (const entry of file.history) {
+    const line = limitHistoryLineOf(entry);
+    if (line !== null)
+      lines.push(line);
+  }
+  return lines;
+}
+function relayedChoiceLines(engagementId, phase, home) {
+  const path = pacingFile(engagementId, RELAYED_CHOICES_FILENAME, home);
+  if (path === null)
+    return [];
+  try {
+    const parsed = relayedChoicesFileSchema.safeParse(JSON.parse(readFileSync16(path, "utf-8")));
+    if (!parsed.success || parsed.data.phase !== phase)
+      return [];
+    return parsed.data.entries.map((entry) => relayedChoiceLineOf(entry));
+  } catch {
+    return [];
+  }
+}
+function readPhaseModels(engagementId, phase, openedAt, home) {
+  const path = pacingFile(engagementId, PHASE_MODELS_FILENAME, home);
+  if (path === null)
+    return null;
+  try {
+    const parsed = phaseModelsFileSchema.safeParse(JSON.parse(readFileSync16(path, "utf-8")));
+    if (!parsed.success || parsed.data.phase !== phase)
+      return null;
+    if (openedAt !== null && parsed.data.openedAt !== openedAt)
+      return null;
+    return parsed.data.tasks;
+  } catch {
+    return null;
+  }
+}
+function usageTokensOf(usage2) {
+  return usage2.inputTokens + usage2.outputTokens + usage2.cacheWriteTokens + usage2.cacheReadTokens;
+}
+function tierFigureLines(work, expected, summary, models) {
+  const lines = [];
+  const figures = work === null ? null : tierFiguresOf(work);
+  if (figures !== null)
+    lines.push(tierCountsLineOf(figures));
+  if (expected === null)
+    lines.push(NO_EXPECTED_LINE);
+  else if (summary !== null) {
+    lines.push(expectedActualLineOf(expected, { seconds: summary.elapsedSeconds, tokens: usageTokensOf(summary.usage) }));
+  }
+  if (figures !== null && models !== null) {
+    for (const task of figures.hadCheaperAttempt) {
+      const seen = Object.keys(models[task] ?? {});
+      if (seen.length > 0)
+        lines.push(seenModelsLineOf(task, seen));
+    }
+  }
+  return lines;
+}
 
 // dist/open-phase.js
 function readMethodUpdate(value) {
@@ -16087,9 +16791,9 @@ async function runDraw(repoRoot, picture, deps) {
     const checked = readAndCheckPlan(repoRoot, phase, description, "draw");
     if (!checked.ok)
       return checked.line;
-    const refusal2 = localRefusal(repoRoot, base);
-    if (refusal2 !== null)
-      return refusal2;
+    const refusal3 = localRefusal(repoRoot, base);
+    if (refusal3 !== null)
+      return refusal3;
     checkedPlan = checked.plan;
     return null;
   };
@@ -16191,7 +16895,7 @@ async function writeDrawOutcome(repoRoot, deps, outcome, target, warnings, canno
 
 // dist/check-tasks.js
 import { readFileSync as readFileSync18 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join21, resolve as resolve6 } from "node:path";
 var CHECK_TASKS_USAGE = `${HALFCYCLE_COMMAND} check-tasks <phase> [--with-task-list] [--repo <root>]`;
 function parseCheckTasksArgs(argv) {
   const positionals = [];
@@ -16222,13 +16926,16 @@ function parseCheckTasksArgs(argv) {
   return { ok: true, phase: positionals[0], withTaskList, repoRoot };
 }
 var MISSING_PLAN_LINE = `there is no ${TASK_PLAN_FILE} in this project yet. Run the task-graph step to write it, then run this again.`;
+function planCrew() {
+  return CREW_ROSTER.map((member) => ({ callsign: member.callsign, tier: member.tier }));
+}
 function issuePlace(rel, path) {
   return path.length === 0 ? rel : `${rel}.${path.map(String).join(".")}`;
 }
 function readJsonFile(repoRoot, rel, parse) {
   let text;
   try {
-    text = readFileSync18(join21(repoRoot, rel), "utf-8");
+    text = readFileSync18(resolve6(repoRoot, rel), "utf-8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT" || code === "ENOTDIR")
@@ -16284,15 +16991,32 @@ function readPhasePlanParts(repoRoot, phase, description) {
   if (!isValidPhaseIdentity(phase))
     return void 0;
   const file = planFileRel(phase);
+  let text;
+  try {
+    text = readFileSync18(join21(repoRoot, file), "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "ENOTDIR")
+      return void 0;
+    return { file, unusable: { kind: "unreadable" } };
+  }
   let raw;
   try {
-    raw = JSON.parse(readFileSync18(join21(repoRoot, file), "utf-8"));
-  } catch {
-    return void 0;
+    raw = JSON.parse(text);
+  } catch (err) {
+    return { file, unusable: { kind: "not-json", error: err instanceof Error ? err.message : String(err) } };
+  }
+  const named2 = typeof raw === "object" && raw !== null ? raw["phase"] : void 0;
+  if (isValidPhaseIdentity(named2) && renderPhaseSegment(named2) !== renderPhaseSegment(phase)) {
+    return { file, unusable: { kind: "other-phase", phase: String(named2) } };
   }
   const checked = checkPhasePlan(raw, description);
-  if (!checked.ok || renderPhaseSegment(checked.plan.phase) !== renderPhaseSegment(phase))
-    return void 0;
+  if (!checked.ok) {
+    return {
+      file,
+      unusable: { kind: "problems", problems: checked.problems.map((p) => ({ path: p.path, message: p.message })) }
+    };
+  }
   return { file, partIds: checked.plan.changes.map((change) => change.part) };
 }
 var SPEC_FOLDER = LAYER_ARTEFACT_PATHS.l4[0];
@@ -16315,6 +17039,24 @@ function readPlanSpecFiles(repoRoot, plan) {
   }
   return { kind: "ok", specFiles: { folder: SPEC_FOLDER, entries } };
 }
+function readCriteriaRecordFile(repoRoot, rel = CRITERIA_RECORD_FILE) {
+  return readJsonFile(repoRoot, rel, (raw) => workCriteriaRecordSchema.safeParse(raw));
+}
+function readCriteriaRecord(repoRoot, plan) {
+  const read = readCriteriaRecordFile(repoRoot);
+  if (read.kind === "missing")
+    return { kind: "ok", record: void 0 };
+  if (read.kind === "bad")
+    return { kind: "bad", line: read.line };
+  const record2 = read.value;
+  if (criteriaRecordMismatch(record2, plan) !== null)
+    return { kind: "ok", record: void 0 };
+  const fixTasks = [];
+  for (const row of record2.rows)
+    if (row.status === "fix")
+      fixTasks.push(row.task);
+  return { kind: "ok", record: { check: record2.check, fixTasks } };
+}
 function runCheckTasks(repoRoot, phase, withTaskList) {
   const p = "halfcycle check-tasks:";
   const planRead = readJsonFile(repoRoot, TASK_PLAN_FILE, (raw) => taskPlanSchema.safeParse(raw));
@@ -16347,6 +17089,11 @@ function runCheckTasks(repoRoot, phase, withTaskList) {
   const specs = readPlanSpecFiles(repoRoot, plan);
   if (specs.kind === "bad") {
     return { stdout: "", stderr: `${p} ${specs.line}
+`, exitCode: 2 };
+  }
+  const criteria = readCriteriaRecord(repoRoot, plan);
+  if (criteria.kind === "bad") {
+    return { stdout: "", stderr: `${p} ${criteria.line}
 `, exitCode: 2 };
   }
   const phasePlan = system.kind === "ok" ? readPhasePlanParts(repoRoot, phase, system.description) : void 0;
@@ -16354,14 +17101,67 @@ function runCheckTasks(repoRoot, phase, withTaskList) {
     phase,
     taskList,
     specFiles: specs.specFiles,
+    ...criteria.record !== void 0 ? { criteriaRecord: criteria.record } : {},
     ...system.kind === "ok" ? { system: { file: SYSTEM_DESCRIPTION_REL, partIds: system.partIds } } : {},
-    ...phasePlan !== void 0 ? { phasePlan } : {}
+    ...phasePlan !== void 0 ? { phasePlan } : {},
+    crew: planCrew()
   });
   const stdout = result.lines.map((line) => `${line.text}
 `).join("");
   return { stdout, stderr: "", exitCode: result.refused ? 1 : 0 };
 }
 
+// dist/check-criteria.js
+var CHECK_CRITERIA_USAGE = `${HALFCYCLE_COMMAND} check-criteria [<record file>] [--repo <root>]`;
+function parseCheckCriteriaArgs(argv) {
+  const positionals = [];
+  let repoRoot;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--repo") {
+      const value = argv[i + 1];
+      if (repoRoot !== void 0 || value === void 0 || value === "" || value.startsWith("-"))
+        return { ok: false };
+      repoRoot = value;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("-") || arg === "")
+      return { ok: false };
+    positionals.push(arg);
+  }
+  if (positionals.length > 1)
+    return { ok: false };
+  return { ok: true, file: positionals[0], repoRoot };
+}
+function missingRecordLine(file) {
+  return `there is no ${file} in this project yet. Check the finished phase against each acceptance criterion of its features, write what you found there, then run this again.`;
+}
+function runCheckCriteria(repoRoot, file) {
+  const p = "halfcycle check-criteria:";
+  const fail = (line) => ({ stdout: "", stderr: `${p} ${line}
+`, exitCode: 2 });
+  const planRead = readJsonFile(repoRoot, TASK_PLAN_FILE, (raw) => taskPlanSchema.safeParse(raw));
+  if (planRead.kind === "missing")
+    return fail(MISSING_PLAN_LINE);
+  if (planRead.kind === "bad")
+    return fail(planRead.line);
+  const plan = planRead.value;
+  const recordFile = file ?? CRITERIA_RECORD_FILE;
+  const recordRead = readCriteriaRecordFile(repoRoot, recordFile);
+  if (recordRead.kind === "missing")
+    return fail(missingRecordLine(recordFile));
+  if (recordRead.kind === "bad")
+    return fail(recordRead.line);
+  const specs = readPlanSpecFiles(repoRoot, plan);
+  if (specs.kind === "bad")
+    return fail(specs.line);
+  const result = checkCriteriaRecord(recordRead.value, plan, { file: recordFile, specFiles: specs.specFiles });
+  const stdout = result.lines.map((line) => `${line.text}
+`).join("");
+  return { stdout, stderr: "", exitCode: result.refused ? 1 : 0 };
+}
+
 // dist/check-report.js
 import { readFileSync as readFileSync19 } from "node:fs";
 var CHECK_REPORT_USAGE = `${HALFCYCLE_COMMAND} check-report <file | -> --head <sha>`;
@@ -16386,8 +17186,17 @@ function parseCheckReportArgs(argv) {
     return { ok: false };
   return { ok: true, source: positionals[0], head };
 }
+var SHORT_COMMIT = /^[0-9a-fA-F]{1,39}$/;
 function runCheckReport(source, head, deps = {}) {
   const p = "halfcycle check-report:";
+  if (SHORT_COMMIT.test(head)) {
+    return {
+      stdout: "",
+      stderr: `${p} --head ${head} is a short commit id. Give the full 40-character commit id, then run this again.
+`,
+      exitCode: 2
+    };
+  }
   let body;
   try {
     body = source === "-" ? (deps.readStdin ?? (() => readFileSync19(0, "utf-8")))() : readFileSync19(source, "utf-8");
@@ -16514,7 +17323,17 @@ function runReady(repoRoot, phase, cap) {
   if (specs.kind === "bad")
     return failed2(`${p} ${specs.line}
 `);
-  const check = checkTaskPlan(plan, { phase, taskList: { file: list2 }, specFiles: specs.specFiles });
+  const criteria = readCriteriaRecord(repoRoot, plan);
+  if (criteria.kind === "bad")
+    return failed2(`${p} ${criteria.line}
+`);
+  const check = checkTaskPlan(plan, {
+    phase,
+    taskList: { file: list2 },
+    specFiles: specs.specFiles,
+    ...criteria.record !== void 0 ? { criteriaRecord: criteria.record } : {},
+    crew: planCrew()
+  });
   if (check.refused) {
     return { stdout: check.lines.map((line) => `${line.text}
 `).join(""), stderr: "", exitCode: 1 };
@@ -16569,13 +17388,13 @@ function splitProveInvocation(words) {
 function runProveChild(binary, credential, repoRoot, words, deps = {}) {
   const out = deps.stdout ?? process.stdout;
   const err = deps.stderr ?? process.stderr;
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     let settled = false;
     const finish = (code) => {
       if (settled)
         return;
       settled = true;
-      resolve8(code);
+      resolve9(code);
     };
     let child;
     try {
@@ -16597,9 +17416,9 @@ function runProveChild(binary, credential, repoRoot, words, deps = {}) {
 }
 
 // dist/uninstall.js
-import { lstatSync as lstatSync3, readFileSync as readFileSync20, readdirSync, rmSync as rmSync6, rmdirSync, writeFileSync as writeFileSync8 } from "node:fs";
+import { lstatSync as lstatSync3, readFileSync as readFileSync20, readdirSync, rmSync as rmSync6, rmdirSync, writeFileSync as writeFileSync7 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname7, join as join22, relative as relative6, sep as sep2 } from "node:path";
+import { dirname as dirname6, join as join22, relative as relative6, sep as sep2 } from "node:path";
 var REMOVE_CREDENTIAL_FLAG = "--remove-credential";
 function parseUninstallArgs(args2) {
   let removeCredential = false;
@@ -16700,7 +17519,7 @@ function validate(options, rules) {
     }
     if (engagementId !== void 0) {
       const expectedParent = join22(home ?? homedir5(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME);
-      if (dirname7(engagementStateDir(engagementId, home)) !== expectedParent) {
+      if (dirname6(engagementStateDir(engagementId, home)) !== expectedParent) {
         throw new Refusal(`the project id in ${BUNDLE_PIN_REL} does not name a folder under ~/.halfcycle/engagements. Nothing was removed.`);
       }
     }
@@ -16731,7 +17550,7 @@ function writeBack(targetRepo, rel, current, next, lists, name) {
       rmSync6(path);
       name(lists.removed, rel, rel);
     } else {
-      writeFileSync8(path, next, "utf-8");
+      writeFileSync7(path, next, "utf-8");
       name(lists.restored, rel, rel);
     }
   } catch {
@@ -17513,7 +18332,7 @@ function renderUninstallReport(result, home) {
 
 // dist/banner-facts.js
 import { readFileSync as readFileSync21 } from "node:fs";
-import { basename as basename4, join as join23, resolve as resolve6 } from "node:path";
+import { basename as basename4, join as join23, resolve as resolve7 } from "node:path";
 var BRAND_URL = "halfcycle.ai";
 var TAGLINE = [
   "Fewer cycles.",
@@ -17612,7 +18431,7 @@ function openingBannerContent(projectDir, env = process.env, probes = REAL_PROBE
 }
 function safeBasename(dir) {
   try {
-    const name = basename4(resolve6(dir)).trim();
+    const name = basename4(resolve7(dir)).trim();
     return name === "" ? "project" : name;
   } catch {
     return "project";
@@ -17621,7 +18440,9 @@ function safeBasename(dir) {
 
 // dist/pace.js
 import { spawn as spawn3 } from "node:child_process";
-var PACE_USAGE = `${HALFCYCLE_COMMAND} pace [--start <phase> [--agents <n>]] [--repo <root>]`;
+import { readFileSync as readFileSync22 } from "node:fs";
+import { join as join24 } from "node:path";
+var PACE_USAGE = `${HALFCYCLE_COMMAND} pace [--agent claude-code|codex] [--start <phase> [--agents <n>]] [--repo <root>]`;
 function parsePaceArgs(argv) {
   let repoRoot;
   let phase;
@@ -17629,6 +18450,7 @@ function parsePaceArgs(argv) {
   let sawRepo = false;
   let sawStart = false;
   let sawAgents = false;
+  let agent = null;
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     const value = () => {
@@ -17654,6 +18476,13 @@ function parsePaceArgs(argv) {
       if (v === null)
         return { ok: false };
       phase = v;
+    } else if (arg === "--agent") {
+      if (agent !== null)
+        return { ok: false };
+      const v = value();
+      if (v !== "claude-code" && v !== "codex")
+        return { ok: false };
+      agent = v;
     } else if (arg === "--agents") {
       if (sawAgents)
         return { ok: false };
@@ -17669,21 +18498,21 @@ function parsePaceArgs(argv) {
   if (agents !== void 0 && phase === void 0)
     return { ok: false };
   if (phase === void 0)
-    return { ok: true, start: null, repoRoot };
-  return { ok: true, start: { phase, agents: agents ?? null }, repoRoot };
+    return { ok: true, start: null, repoRoot, agent };
+  return { ok: true, start: { phase, agents: agents ?? null }, repoRoot, agent };
 }
 var PACE_CHILD_DEADLINE_MS = 11 * 60 * 1e3;
 function runPaceChild(binary, credential, repoRoot, args2, deps = {}) {
   if (binary instanceof Error)
     return Promise.resolve({ code: 1, stdout: "" });
   const err = deps.stderr ?? process.stderr;
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     let settled = false;
     const done = (output) => {
       if (settled)
         return;
       settled = true;
-      resolve8(output);
+      resolve9(output);
     };
     try {
       const child = spawn3(process.execPath, [binary, "pace", ...args2], {
@@ -17724,7 +18553,17 @@ function notPacedLine(reason) {
   return reason === "not-configured" ? `${PACE_NOT_CONNECTED_LINE}
 ` : "halfcycle pace: Halfcycle could not read this computer's usage records just now. Run this again in a minute.\n";
 }
-async function runPace(repoRoot, start, deps) {
+function readPromptScript(repoRoot) {
+  try {
+    return readFileSync22(join24(repoRoot, ".claude", "hooks", "user-prompt-scope.sh"), "utf-8");
+  } catch {
+    return null;
+  }
+}
+function promptScriptBehind(script) {
+  return script === null || !script.includes("faster");
+}
+async function runPace(repoRoot, start, deps, agent = null) {
   if (start !== null && !isValidPhaseIdentity(start.phase)) {
     return { stdout: "", stderr: notAPhaseNameLine("pace", start.phase), exitCode: 1 };
   }
@@ -17735,7 +18574,10 @@ async function runPace(repoRoot, start, deps) {
     return { stdout: "", stderr: `${PACE_NOT_CONNECTED_LINE}
 `, exitCode: 1 };
   }
-  const args2 = start === null ? [] : ["--start", start.phase, ...start.agents !== null ? ["--agents", start.agents] : []];
+  const args2 = [
+    ...agent === null ? [] : ["--agent", agent],
+    ...start === null ? [] : ["--start", start.phase, ...start.agents !== null ? ["--agents", start.agents] : []]
+  ];
   const child = await deps.spawnPace(credential, repoRoot, args2);
   if (child.code !== 0)
     return { stdout: "", stderr: "", exitCode: child.code };
@@ -17747,26 +18589,178 @@ async function runPace(repoRoot, start, deps) {
   if (start !== null) {
     if (result.suggestion === void 0)
       return { stdout: "", stderr: notPacedLine("unreadable"), exitCode: 0 };
-    return { stdout: `${paceStartLinesOf(result.suggestion).join("\n")}
+    const behind = promptScriptBehind((deps.readPromptScript ?? readPromptScript)(repoRoot));
+    return { stdout: `${paceStartLinesOf(result.suggestion, behind).join("\n")}
 `, stderr: "", exitCode: 0 };
   }
   const lines = [paceAllowedNowOf(result.allowedNow)];
+  if (result.limit === "reached" && result.limitHeld !== void 0) {
+    const held = result.limitHeld;
+    lines.push(limitReachedLineOf(held.used, held.limit, held.working, held.raiseBy));
+  }
   if (result.windowKind !== void 0 && result.until !== void 0) {
     const until = new Date(result.until);
+    const share = result.keepFreePercent ?? KEEP_FREE_DEFAULT;
     if (result.pace === "slowing")
-      lines.push(paceS1Of(result.windowKind, result.allowedNow, until, deps.now()));
+      lines.push(paceS1Of(result.windowKind, result.allowedNow, until, deps.now(), share));
     else if (result.pace === "holding")
-      lines.push(paceS2Of(result.windowKind, result.allowedNow, until, deps.now()));
+      lines.push(paceS2Of(result.windowKind, result.allowedNow, until, deps.now(), share));
   }
   return { stdout: `${lines.join("\n")}
 `, stderr: "", exitCode: 0 };
 }
 
+// dist/route.js
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync23, renameSync as renameSync4, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname7, join as join25 } from "node:path";
+var ROUTE_USAGE = `${HALFCYCLE_COMMAND} route <phase> <task> [--agent claude-code|codex] [--repo <root>]`;
+var ROUTING_FILENAME = "routing.json";
+var ROUTE_WORK_READ_DEADLINE_MS = 5e3;
+function parseRouteArgs(argv) {
+  const positionals = [];
+  let agent = null;
+  let repoRoot;
+  let sawRepo = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const value = () => {
+      const v = argv[i + 1];
+      if (v === void 0 || v === "" || v.startsWith("-"))
+        return null;
+      i += 1;
+      return v;
+    };
+    if (arg === "--agent") {
+      if (agent !== null)
+        return { ok: false };
+      const v = value();
+      if (v !== "claude-code" && v !== "codex")
+        return { ok: false };
+      agent = v;
+    } else if (arg === "--repo") {
+      if (sawRepo)
+        return { ok: false };
+      sawRepo = true;
+      const v = value();
+      if (v === null)
+        return { ok: false };
+      repoRoot = v;
+    } else if (arg.startsWith("-") || arg === "") {
+      return { ok: false };
+    } else {
+      positionals.push(arg);
+    }
+  }
+  if (positionals.length !== 2)
+    return { ok: false };
+  return { ok: true, phase: positionals[0], task: positionals[1], agent: agent ?? "claude-code", repoRoot };
+}
+function routingPath(engagementId, home) {
+  return join25(engagementStateDir(engagementId, home), ROUTING_FILENAME);
+}
+function readCheapStarted(path, phase) {
+  try {
+    const parsed = routingRecordSchema.safeParse(JSON.parse(readFileSync23(path, "utf-8")));
+    if (!parsed.success || parsed.data.phase !== phase)
+      return [];
+    return [...parsed.data.cheapStarted];
+  } catch {
+    return [];
+  }
+}
+function recordCheapStarted(path, phase, task) {
+  const started = readCheapStarted(path, phase);
+  const record2 = { phase, cheapStarted: started.includes(task) ? started : [...started, task] };
+  mkdirSync10(dirname7(path), { recursive: true, mode: 448 });
+  const tmp = `${path}.${String(process.pid)}.tmp`;
+  writeFileSync8(tmp, `${JSON.stringify(record2)}
+`, { mode: 384 });
+  renameSync4(tmp, path);
+}
+function attemptsOf(read, task) {
+  if (read.kind !== "work")
+    return null;
+  return read.work.tasks.find((t) => t.task === task)?.attempts ?? [];
+}
+function lastTierOf(attempts) {
+  return [...attempts].sort((a, b) => b.attempt - a.attempt)[0].builderTier;
+}
+async function readWorkInTime(deps, credential, phase) {
+  let timer;
+  const late = new Promise((resolve9) => {
+    timer = setTimeout(() => resolve9({ kind: "unreachable" }), ROUTE_WORK_READ_DEADLINE_MS);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([deps.readWork(credential, phase).catch(() => ({ kind: "unreachable" })), late]);
+  } finally {
+    if (timer !== void 0)
+      clearTimeout(timer);
+  }
+}
+async function runRoute(repoRoot, phase, taskId, agent, deps) {
+  const p = "halfcycle route:";
+  const answer = (line) => ({ stdout: `${line}
+`, stderr: "", exitCode: 0 });
+  const planRead = readJsonFile(repoRoot, TASK_PLAN_FILE, (raw) => taskPlanSchema.safeParse(raw));
+  if (planRead.kind === "missing")
+    return { stdout: "", stderr: `${p} ${MISSING_PLAN_LINE}
+`, exitCode: 2 };
+  if (planRead.kind === "bad")
+    return { stdout: "", stderr: `${p} ${planRead.line}
+`, exitCode: 2 };
+  const plan = planRead.value;
+  if (plan.phase !== phase) {
+    return { stdout: "", stderr: `${p} ${taskPlanLineText.O6(plan.phase, phase)}
+`, exitCode: 1 };
+  }
+  const task = plan.tasks.find((t) => t.id === taskId);
+  if (task === void 0)
+    return { stdout: "", stderr: `${p} ${routeNoSuchTaskLineOf(taskId)}
+`, exitCode: 1 };
+  const holder = task.agent;
+  if (holder === void 0)
+    return { stdout: "", stderr: `${p} ${taskPlanLineText.V4(taskId)}
+`, exitCode: 1 };
+  const member = CREW_ROSTER.find((m) => m.callsign === holder);
+  if (member === void 0)
+    return answer(routeStartUnknownLineOf(holder, taskId));
+  const startsCheaperWhenFirst = task.kind === "build" && task.cheapFirst === true && member.tier === "standard";
+  if (!startsCheaperWhenFirst)
+    return answer(routeStartLineOf(holder, taskId, member.tier));
+  let credential;
+  try {
+    credential = deps.readCredential(repoRoot);
+  } catch {
+    return answer(routeStartLineOf(holder, taskId, member.tier));
+  }
+  const attempts = attemptsOf(await readWorkInTime(deps, credential, phase), taskId);
+  if (attempts !== null && attempts.length > 0) {
+    return answer(routeStartLineOf(holder, taskId, tierAboveOf(lastTierOf(attempts))));
+  }
+  if (agent === "codex" && !hasCheaperRole(member))
+    return answer(routeStartLineOf(holder, taskId, member.tier));
+  let path;
+  try {
+    path = routingPath(credential.engagementId, deps.home);
+  } catch {
+    return answer(routeStartLineOf(holder, taskId, member.tier));
+  }
+  if (readCheapStarted(path, phase).includes(taskId))
+    return answer(routeStartLineOf(holder, taskId, member.tier));
+  try {
+    recordCheapStarted(path, phase, taskId);
+  } catch {
+    return answer(routeStartLineOf(holder, taskId, member.tier));
+  }
+  return answer(agent === "codex" ? routeCheaperCodexLineOf(holder, taskId) : routeCheaperClaudeLineOf(holder, taskId, AGENT_PROFILES["claude-code"].tierModels.fast.model));
+}
+
 // dist/restore.js
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { closeSync as closeSync3, fchmodSync, lstatSync as lstatSync4, mkdirSync as mkdirSync11, openSync as openSync3, readdirSync as readdirSync2, readFileSync as readFileSync22, readlinkSync, realpathSync as realpathSync6, rmSync as rmSync7, symlinkSync, writeSync as writeSync2 } from "node:fs";
+import { closeSync as closeSync3, fchmodSync, lstatSync as lstatSync4, mkdirSync as mkdirSync11, openSync as openSync3, readdirSync as readdirSync2, readFileSync as readFileSync24, readlinkSync, realpathSync as realpathSync6, rmSync as rmSync7, symlinkSync, writeSync as writeSync2 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join24, resolve as resolve7 } from "node:path";
+import { join as join26, resolve as resolve8 } from "node:path";
 var RESTORE_USAGE = `${HALFCYCLE_COMMAND} restore [<id>]`;
 function parseRestoreArgs(rest) {
   if (rest.length > 1)
@@ -17788,7 +18782,7 @@ function runRestore(cwd, id, options = {}) {
   if (engagementId === null) {
     return refused2(`Halfcycle is not set up in this project, so it has saved nothing here. To set it up, run: ${HALFCYCLE_COMMAND}`);
   }
-  const folder = join24(options.home ?? homedir6(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, SAVED_DIR_NAME);
+  const folder = join26(options.home ?? homedir6(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, SAVED_DIR_NAME);
   const refs = savedRefs(root);
   if (refs === null)
     return refused2("Halfcycle could not read the saved copies in this project, so nothing was put back.");
@@ -17864,7 +18858,7 @@ function restoreOne(root, folder, refs, rawId) {
     if (p.keptIn === "commit")
       fromCommit.push(p.path);
     else
-      restoreCopy(root, join24(folder, id), p.path, out);
+      restoreCopy(root, join26(folder, id), p.path, out);
   }
   if (fromCommit.length > 0)
     restoreFromCommit(root, ref, fromCommit, out);
@@ -17892,7 +18886,7 @@ function makeFolders(root, rel) {
   const segments = rel.split("/");
   let at = root;
   for (let i = 0; i < segments.length - 1; i++) {
-    at = join24(at, segments[i]);
+    at = join26(at, segments[i]);
     const shown2 = segments.slice(0, i + 1).join("/");
     let st = lstatOrNull3(at);
     if (st === null) {
@@ -17912,7 +18906,7 @@ function makeFolders(root, rel) {
   return null;
 }
 function place(root, rel, content, out) {
-  const abs = join24(root, rel);
+  const abs = join26(root, rel);
   const there = lstatOrNull3(abs);
   if (there !== null) {
     if (sameAs(abs, there, content))
@@ -17950,7 +18944,7 @@ function sameAs(abs, st, content) {
   try {
     if ("link" in content)
       return st.isSymbolicLink() && readlinkSync(abs) === content.link;
-    return st.isFile() && readFileSync22(abs).equals(content.bytes);
+    return st.isFile() && readFileSync24(abs).equals(content.bytes);
   } catch {
     return false;
   }
@@ -17960,20 +18954,20 @@ function restoreCopy(root, saveDir, rel, out) {
   let at = saveDir;
   const chain = [SAVED_COPIES_DIR_NAME, ...segments];
   for (let i = 0; i < chain.length - 1; i++) {
-    at = join24(at, chain[i]);
+    at = join26(at, chain[i]);
     const st2 = lstatOrNull3(at);
     if (st2 === null || st2.isSymbolicLink() || !st2.isDirectory()) {
       out.left.push(`${rel}: the saved copy does not hold it`);
       return;
     }
   }
-  const src = join24(at, chain[chain.length - 1]);
+  const src = join26(at, chain[chain.length - 1]);
   const st = lstatOrNull3(src);
   try {
     if (st !== null && st.isSymbolicLink())
       return place(root, rel, { link: readlinkSync(src) }, out);
     if (st !== null && st.isFile())
-      return place(root, rel, { bytes: readFileSync22(src), mode: st.mode & 511 }, out);
+      return place(root, rel, { bytes: readFileSync24(src), mode: st.mode & 511 }, out);
   } catch {
   }
   out.left.push(`${rel}: the saved copy does not hold it`);
@@ -18071,7 +19065,7 @@ function restoreLines(root, ref, saved, out) {
 }
 function pinnedEngagement(root) {
   try {
-    const pin = JSON.parse(readFileSync22(join24(root, BUNDLE_PIN_REL), "utf-8"));
+    const pin = JSON.parse(readFileSync24(join26(root, BUNDLE_PIN_REL), "utf-8"));
     return isEngagementId(pin.engagementId) ? pin.engagementId : null;
   } catch {
     return null;
@@ -18093,16 +19087,16 @@ function savedRefs(root) {
   return refs;
 }
 function readSaved(folder, id) {
-  const dir = join24(folder, id);
+  const dir = join26(folder, id);
   const st = lstatOrNull3(dir);
   if (st === null || !st.isDirectory())
     return null;
-  const file = join24(dir, SAVED_FILE_NAME);
+  const file = join26(dir, SAVED_FILE_NAME);
   const fst = lstatOrNull3(file);
   if (fst === null || !fst.isFile())
     return null;
   try {
-    const parsed = savedSchema.safeParse(JSON.parse(readFileSync22(file, "utf-8")));
+    const parsed = savedSchema.safeParse(JSON.parse(readFileSync24(file, "utf-8")));
     return parsed.success && parsed.data.id === id ? parsed.data : null;
   } catch {
     return null;
@@ -18111,7 +19105,7 @@ function readSaved(folder, id) {
 function pruneAtRestore(root, folder, refs, now) {
   try {
     const common = git2(root, ["rev-parse", "--git-common-dir"]);
-    const repository = common.ok && common.text.trim() !== "" ? realOrSelf(resolve7(root, common.text.trim())) : null;
+    const repository = common.ok && common.text.trim() !== "" ? realOrSelf(resolve8(root, common.text.trim())) : null;
     let names = [];
     try {
       names = readdirSync2(folder);
@@ -18123,7 +19117,7 @@ function pruneAtRestore(root, folder, refs, now) {
       if (!savedIdSchema.safeParse(id).success)
         continue;
       here.add(id);
-      const dir = join24(folder, id);
+      const dir = join26(folder, id);
       const st = lstatOrNull3(dir);
       const answer = savedPruneAnswer({
         refMadeAt: refs.get(id) ?? null,
@@ -18151,7 +19145,7 @@ function pruneAtRestore(root, folder, refs, now) {
 }
 function markedRepository(dir) {
   try {
-    const text = readFileSync22(join24(dir, SAVED_REPOSITORY_FILE_NAME), "utf-8").trim();
+    const text = readFileSync24(join26(dir, SAVED_REPOSITORY_FILE_NAME), "utf-8").trim();
     return text === "" ? null : text;
   } catch {
     return null;
@@ -18255,6 +19249,8 @@ var USAGE = `  ${HALFCYCLE_COMMAND} [install] [target-repo] [engagement-id] [sel
          run a task's test command on this machine, once before the change and once after, and record what it saw
   ${CHECK_TASKS_USAGE}
          check a phase's plan in docs/build-records/ for work that would collide if it ran at once
+  ${CHECK_CRITERIA_USAGE}
+         check that the record of a finished phase's check names every acceptance criterion of its features
   ${CHECK_REPORT_USAGE}
          check a worker's report, saved from its pull request, against the commit it must be about
   ${READY_USAGE}
@@ -18265,6 +19261,8 @@ var USAGE = `  ${HALFCYCLE_COMMAND} [install] [target-repo] [engagement-id] [sel
   ${PACE_USAGE}
          suggest how many agents this build should run at once, and for how long; with no flag, how
          many may start right now
+  ${ROUTE_USAGE}
+         say how to start a task of a phase's plan: which crew member, and on which tier
   ${HALFCYCLE_COMMAND} preview [folder]
          show what setting up this folder would add, change, remove or leave alone; writes nothing
   ${HALFCYCLE_COMMAND} doctor
@@ -18711,7 +19709,6 @@ ${PROJECT_RESET_LINE}
         process.stdout.write(`[halfcycle] Method version: ${methodVersion}
 `);
       }
-      await setupClaudePlan({ serviceUrl: credential?.serviceUrl ?? serviceUrl, engagementId, ownsProject, consoleUrl }, { interactive: () => isInteractiveRun(), assumeYes, ask: askLine, write: (text) => process.stdout.write(text) });
       if (checks.gitInstalled) {
         process.stdout.write(`[halfcycle] Git for Windows is installed. Open a new terminal before starting Claude Code.
 `);
@@ -18929,6 +19926,22 @@ halfcycle build-record: until ${obtained.stampFailure.path} can be written, the
     process.exitCode = run.exitCode;
     return;
   }
+  if (cmd === "check-criteria") {
+    const parsed = parseCheckCriteriaArgs(rest);
+    if (!parsed.ok) {
+      process.stderr.write(`halfcycle check-criteria: usage: ${CHECK_CRITERIA_USAGE}
+`);
+      process.exitCode = 2;
+      return;
+    }
+    const run = runCheckCriteria(parsed.repoRoot ?? process.cwd(), parsed.file);
+    if (run.stdout !== "")
+      process.stdout.write(run.stdout);
+    if (run.stderr !== "")
+      process.stderr.write(run.stderr);
+    process.exitCode = run.exitCode;
+    return;
+  }
   if (cmd === "check-report") {
     const reportShortfalls = missingRequirements("check-report", rest);
     if (reportShortfalls.length > 0) {
@@ -18987,7 +20000,7 @@ halfcycle build-record: until ${obtained.stampFailure.path} can be written, the
       readCredential: (root) => readRepoCredential(root),
       spawnPace: (credential, root, args2) => runPaceChild(runner, credential, root, args2),
       now: () => /* @__PURE__ */ new Date()
-    });
+    }, parsed.agent);
     if (run.stdout !== "")
       process.stdout.write(run.stdout);
     if (run.stderr !== "")
@@ -18995,6 +20008,23 @@ halfcycle build-record: until ${obtained.stampFailure.path} can be written, the
     process.exitCode = run.exitCode;
     return;
   }
+  if (cmd === "route") {
+    const parsed = parseRouteArgs(rest);
+    if (!parsed.ok) {
+      process.stderr.write(`halfcycle route: usage: ${ROUTE_USAGE}
+`);
+      process.exitCode = 2;
+      return;
+    }
+    const run = await runRoute(parsed.repoRoot ?? process.cwd(), parsed.phase, parsed.task, parsed.agent, {
+      readCredential: (root) => readRepoCredential(root),
+      readWork: (credential, phase) => readPhaseWork(credential, phase)
+    });
+    if (run.stderr !== "")
+      process.stderr.write(run.stderr);
+    process.stdout.write(run.stdout, () => process.exit(run.exitCode));
+    return;
+  }
   if (cmd === "change") {
     const parsed = parseChangeArgs(rest);
     if (!parsed.ok) {
@@ -19217,12 +20247,22 @@ halfcycle open-phase: until ${opened.stampFailure.path} can be written, guard ev
         const timeSummary = await readCloseTimeSummary(credential, phaseArg);
         for (const line of timeTotalsLines(timeSummary))
           process.stdout.write(`${line}
+`);
+        for (const line of phaseLimitLines(credential.engagementId, phaseArg))
+          process.stdout.write(`${line}
+`);
+        for (const line of relayedChoiceLines(credential.engagementId, phaseArg))
+          process.stdout.write(`${line}
 `);
         const declarations = await readCloseOwnerWaitDeclarations(credential, phaseArg);
+        const work = await readPhaseWork(credential, phaseArg);
+        for (const line of tierFigureLines(work.kind === "work" ? work.work : null, readPhaseExpected(credential.engagementId, phaseArg), timeSummary, readPhaseModels(credential.engagementId, phaseArg, timeSummary?.openedAt ?? null))) {
+          process.stdout.write(`${line}
+`);
+        }
         for (const line of ownerWaitCloseLines(declarations))
           process.stdout.write(`${line}
 `);
-        const work = await readPhaseWork(credential, phaseArg);
         if (work.kind === "work") {
           for (const line of wentAheadCloseLines(work.work.calls))
             process.stdout.write(`${line}