halfcycle 0.5.3 → 0.7.0

package/dist/cli.js

@@ -510,9 +510,19 @@ 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";
+var TASK_PLAN_CRITERIA_NONE = "none";
+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",
@@ -526,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),
@@ -538,8 +549,27 @@ var taskPlanTaskSchema = z2.object({
   }).strict().optional(),
   wholeProject: z2.literal(true).optional(),
   ships: z2.enum(["deploy", "release"]).optional(),
-  builds: z2.union([z2.literal(TASK_PLAN_BUILDS_NONE), z2.array(planText)]).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(),
+  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",
@@ -564,6 +594,7 @@ var taskPlanTaskSchema = z2.object({
 });
 var taskPlanSchema = z2.object({
   phase: z2.string().min(1).refine((text) => !CONTROL_CHARACTER.test(text), { message: "holds a control character" }),
+  specs: z2.union([z2.literal(TASK_PLAN_SPECS_NONE), z2.array(planText)]).optional(),
   tasks: z2.array(taskPlanTaskSchema).max(TASK_PLAN_TASKS_MAX)
 }).strict();
 var taskListRowSchema = z2.object({
@@ -574,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.`,
@@ -586,6 +618,22 @@ var taskPlanLineText = {
   N1: (asked) => `The task list in ${TASK_LIST_FILE} is not for "${asked}", so it was not compared.`,
   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.`,
+  C3: (slug, n) => `${slug} AC${n} is not delivered by any build task. Add "${slug} AC${n}" to the criteria of the build task that delivers it.`,
+  C4: (a) => `"${a}" does not say which acceptance criteria it delivers. Add "criteria" with each one as <spec name> AC<number>. If it delivers none, write "criteria": "${TASK_PLAN_CRITERIA_NONE}".`,
+  C5: (a, x, slug) => `"${a}" names "${x}", but "${slug}" is not in the plan's specs. Add it to "specs" if it belongs to this phase, or remove the citation.`,
+  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, 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.`,
   K1: (a) => `"${a}" is in no batch: no whole-project check waits for it. Add it to the dependsOn of the first whole-project check that it does not already wait for and that waits for every build task it waits for, or add a whole-project check after it.`,
   K2: (a, b) => `"${a}" and "${b}" are both whole-project checks and neither waits for the other. Make the later one wait for the earlier.`,
   K3: (b, a, c) => `"${b}" builds on "${a}" before "${c}" has checked it. Add "${c}" to the dependsOn of "${b}".`,
@@ -593,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) {
@@ -610,10 +671,10 @@ function planInterfaceKey(text) {
     return null;
   return `${kind}: ${name}`.toLowerCase();
 }
-function comparableItemsOf(task) {
+function pathItemsOf(paths) {
   const files = [];
   const folders = [];
-  for (const path of task.touches?.files ?? []) {
+  for (const path of paths) {
     if (isMalformedPlanPath(path))
       continue;
     const item = { shown: path, key: path.toLowerCase() };
@@ -621,6 +682,10 @@ function comparableItemsOf(task) {
     if (item.key.endsWith("/"))
       folders.push(item);
   }
+  return { files, folders };
+}
+function comparableItemsOf(task) {
+  const { files, folders } = pathItemsOf(task.touches?.files ?? []);
   const interfaces = [];
   for (const text of task.touches?.interfaces ?? []) {
     const key = planInterfaceKey(text);
@@ -657,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();
@@ -794,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();
@@ -814,18 +904,23 @@ 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;
 }
+function note(code, text) {
+  return { code, text, refuses: false };
+}
 function refusal(code, text) {
   return { code, text, refuses: true };
 }
@@ -838,6 +933,249 @@ function mustNameParts(task) {
 function namesNoPart(task) {
   return task.builds === void 0 || Array.isArray(task.builds) && task.builds.length === 0;
 }
+function partsNotInPlan(tasks, planPartIds) {
+  const planned = new Set(planPartIds);
+  const out = [];
+  for (const task of tasks) {
+    if (task.reviews !== void 0 || task.kind === "review")
+      continue;
+    if (!Array.isArray(task.builds))
+      continue;
+    if (task.whyOutsidePlan !== void 0 && task.whyOutsidePlan.trim() !== "")
+      continue;
+    const parts = [...new Set(task.builds.filter((part) => !planned.has(part)))];
+    if (parts.length > 0)
+      out.push({ id: task.id, parts });
+  }
+  return out;
+}
+function namesNoCriterion(task) {
+  return task.criteria === void 0 || Array.isArray(task.criteria) && task.criteria.length === 0;
+}
+function isPlanSpecName(text) {
+  return SPEC_NAME.test(text);
+}
+function planSpecNamesToRead(plan) {
+  if (!Array.isArray(plan.specs))
+    return [];
+  return distinct(plan.specs.filter(isPlanSpecName));
+}
+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]?)( \(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));
+  if (start < 0)
+    return [];
+  const items = [];
+  let current = null;
+  const close = () => {
+    if (current !== null)
+      items.push(current);
+    current = null;
+  };
+  for (let i = start + 1; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (SECTION_HEADING.test(line))
+      break;
+    if (CHECKLIST_ITEM.test(line)) {
+      close();
+      current = line.slice("- [ ] ".length);
+      continue;
+    }
+    if (line.trim() === "" || ANY_HEADING.test(line)) {
+      close();
+      continue;
+    }
+    if (current !== null)
+      current = `${current} ${line.trim()}`;
+  }
+  close();
+  return items.map((item, i) => {
+    const explicit = EXPLICIT_NUMBER.exec(item);
+    return {
+      number: explicit ? explicit[1] : String(i + 1),
+      retired: RETIRED_LEAD.test(item),
+      kind: explicit?.[2] !== void 0 ? "edge" : "normal"
+    };
+  });
+}
+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)
+    return [];
+  if (plan.specs === void 0 || plan.specs.length === 0) {
+    return [refusal("C6", taskPlanLineText.C6None(folder))];
+  }
+  const criteriaOf = specCriteriaBySlug(specFiles);
+  const lines = [];
+  for (const name of distinct(plan.specs)) {
+    if (!isPlanSpecName(name)) {
+      lines.push(refusal("C6", taskPlanLineText.C6Malformed(name, folder)));
+    } else if ((criteriaOf.get(name) ?? null) === null) {
+      lines.push(refusal("C6", taskPlanLineText.C6Missing(name, folder)));
+    }
+  }
+  const covered = /* @__PURE__ */ new Set();
+  for (const task of plan.tasks) {
+    if (task.kind !== "build" || !Array.isArray(task.criteria))
+      continue;
+    for (const citation of task.criteria)
+      covered.add(citation);
+  }
+  for (const slug of planSpecNamesToRead(plan)) {
+    const criteria = criteriaOf.get(slug) ?? null;
+    if (criteria === null)
+      continue;
+    for (const n of liveCriterionNumbers(criteria)) {
+      if (!covered.has(`${slug} AC${n}`))
+        lines.push(refusal("C3", taskPlanLineText.C3(slug, n)));
+    }
+  }
+  return lines;
+}
+function specCriteriaBySlug(specFiles) {
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const entry of specFiles.entries) {
+    if (!bySlug.has(entry.slug))
+      bySlug.set(entry.slug, entry.criteria);
+  }
+  return bySlug;
+}
+function citationLine(taskId, citation, plan, specFiles, criteriaOf) {
+  const match = CITATION.exec(citation);
+  if (match === null) {
+    const first = Array.isArray(plan.specs) ? plan.specs.find(isPlanSpecName) : void 0;
+    return refusal("C1", taskPlanLineText.C1Form(taskId, citation, first ?? EXAMPLE_SPEC));
+  }
+  if (plan.specs === void 0 || plan.specs.length === 0)
+    return null;
+  const slug = match[1];
+  const n = match[2];
+  if (plan.specs === TASK_PLAN_SPECS_NONE || !plan.specs.includes(slug)) {
+    return refusal("C5", taskPlanLineText.C5(taskId, citation, slug));
+  }
+  const criteria = criteriaOf.get(slug) ?? null;
+  if (criteria === null)
+    return null;
+  const items = criteria.filter((c) => c.number === n);
+  if (items.length === 0) {
+    return refusal("C1", taskPlanLineText.C1Number(taskId, citation, specFiles.folder, slug, n));
+  }
+  if (items.every((c) => c.retired))
+    return refusal("C2", taskPlanLineText.C2(taskId, citation));
+  return null;
+}
+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) {
+  const boundaryOf = boundaryBySlug(specFiles);
+  const owned = /* @__PURE__ */ new Map();
+  for (const slug of planSpecNamesToRead(plan)) {
+    const boundary = boundaryOf.get(slug) ?? null;
+    if (boundary === null || boundary.kind !== "section")
+      continue;
+    const paths = [];
+    for (const item of boundary.owns) {
+      if (item.kind === "path" && !isMalformedOwnsPath(item.path))
+        paths.push(item.path);
+    }
+    owned.set(slug, paths);
+  }
+  return owned;
+}
+function isMalformedOwnsPath(path) {
+  return isMalformedPlanPath(path) || CONTROL_CHARACTER.test(path);
+}
+function boundaryBySlug(specFiles) {
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const entry of specFiles.entries) {
+    if (!bySlug.has(entry.slug))
+      bySlug.set(entry.slug, entry.boundary);
+  }
+  return bySlug;
+}
+function ownershipLines(plan, specFiles) {
+  const lines = [];
+  const boundaryOf = boundaryBySlug(specFiles);
+  for (const slug of planSpecNamesToRead(plan)) {
+    const boundary = boundaryOf.get(slug) ?? null;
+    if (boundary === null || boundary.kind !== "section")
+      continue;
+    for (const item of boundary.owns) {
+      if (item.kind === "bad") {
+        lines.push(refusal("B2", taskPlanLineText.B2(slug, shownFileText(item.text))));
+      } else if (isMalformedOwnsPath(item.path)) {
+        lines.push(refusal("B2", taskPlanLineText.B2(slug, shownFileText(item.path))));
+      }
+    }
+  }
+  const owned = [...ownedPathsBySpec(plan, specFiles)].map(([slug, paths]) => {
+    const { files, folders } = pathItemsOf(paths);
+    const items = {
+      files,
+      fileKeys: new Set(files.map((f) => f.key)),
+      folders,
+      interfaces: [],
+      interfaceKeys: /* @__PURE__ */ new Set()
+    };
+    return { slug, items };
+  });
+  for (let i = 0; i < owned.length; i += 1) {
+    for (let j = i + 1; j < owned.length; j += 1) {
+      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;
+}
+function ownershipNotes(plan, specFiles) {
+  const lines = [];
+  const boundaryOf = boundaryBySlug(specFiles);
+  for (const slug of planSpecNamesToRead(plan)) {
+    if (boundaryOf.get(slug)?.kind === "none")
+      lines.push(note("N3", taskPlanLineText.N3(slug)));
+  }
+  const owned = ownedPathsBySpec(plan, specFiles);
+  const listed = new Set(planSpecNamesToRead(plan));
+  for (const task of plan.tasks) {
+    if (task.kind !== "build" || !Array.isArray(task.criteria))
+      continue;
+    const ownPaths = [];
+    let anySection = false;
+    for (const slug of distinct(task.criteria.map((c) => CITATION.exec(c)?.[1] ?? ""))) {
+      const paths = listed.has(slug) ? owned.get(slug) : void 0;
+      if (paths === void 0)
+        continue;
+      anySection = true;
+      ownPaths.push(...paths);
+    }
+    if (!anySection)
+      continue;
+    const { files: ownedFiles, folders: ownedFolders } = pathItemsOf(ownPaths);
+    const ownedKeys = new Set(ownedFiles.map((f) => f.key));
+    const unowned = pathItemsOf(task.touches?.files ?? []).files.filter((touched) => !ownedKeys.has(touched.key) && !ownedFolders.some((folder) => touched.key.startsWith(folder.key)));
+    if (unowned.length > 0) {
+      lines.push(note("N2", taskPlanLineText.N2(task.id, distinct(unowned.map((f) => f.shown)))));
+    }
+  }
+  return lines;
+}
 function isWholeProjectCheck(task) {
   return task.kind === "check" && task.wholeProject === true;
 }
@@ -966,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 };
@@ -973,6 +1478,12 @@ function checkTaskPlan(plan, request) {
   const tasks = plan.tasks;
   const lines = [];
   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();
@@ -1013,7 +1524,36 @@ 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 && "partIds" in phasePlan) {
+      for (const found of partsNotInPlan([task], phasePlan.partIds)) {
+        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)) {
+      lines.push(refusal("C4", taskPlanLineText.C4(task.id)));
+    }
+    if (Array.isArray(task.criteria)) {
+      for (const citation of task.criteria) {
+        const line = citationLine(task.id, citation, plan, request.specFiles, criteriaOf);
+        if (line !== null)
+          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);
   for (const path of cycles)
     lines.push(refusal("O4", taskPlanLineText.O4Cycle(path)));
@@ -1034,6 +1574,7 @@ function checkTaskPlan(plan, request) {
       }
     }
   }
+  lines.push(...ownershipLines(plan, request.specFiles));
   if (request.taskList !== void 0) {
     const file = request.taskList.file;
     if (file !== null && !Array.isArray(file) && file.phase === request.phase) {
@@ -1044,13 +1585,269 @@ function checkTaskPlan(plan, request) {
       lines.push({ code: "N1", text: taskPlanLineText.N1(request.phase), refuses: false });
     }
   }
+  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 = [
+  SPEC_BOUNDARY_OWNS_LABEL,
+  "**Out of boundary.**",
+  "**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,})/;
+var BULLET = /^- /;
+var INDENTED = /^[ \t]/;
+var ONE_SPAN = /^`([^`]+)`$/;
+function fenceTracker() {
+  let open = null;
+  return (line) => {
+    const match = FENCE.exec(line);
+    if (open === null) {
+      if (match === null)
+        return true;
+      open = match[1];
+      return false;
+    }
+    if (match !== null && match[1][0] === open[0] && match[1].length >= open.length) {
+      const rest = line.slice(line.indexOf(match[1]) + match[1].length);
+      if (rest.trim() === "")
+        open = null;
+    }
+    return false;
+  };
+}
+function itemOf(first, continued) {
+  const head = first.trim();
+  if (continued.length > 0)
+    return { kind: "bad", text: [head, ...continued].join(" ") };
+  const span = ONE_SPAN.exec(head);
+  if (span === null)
+    return { kind: "bad", text: head };
+  return { kind: "path", path: span[1] };
+}
+function readSpecBoundary(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  const outside = fenceTracker();
+  let start = -1;
+  for (let i = 0; i < lines.length; i += 1) {
+    if (outside(lines[i]) && BOUNDARY_HEADING.test(lines[i])) {
+      start = i;
+      break;
+    }
+  }
+  if (start < 0)
+    return { kind: "none" };
+  const owns = [];
+  let ownsSeen = false;
+  let listOpen = false;
+  let first = null;
+  let continued = [];
+  const closeBullet = () => {
+    if (first !== null)
+      owns.push(itemOf(first, continued));
+    first = null;
+    continued = [];
+  };
+  const closeList = () => {
+    closeBullet();
+    listOpen = false;
+  };
+  for (let i = start + 1; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (!outside(line)) {
+      closeList();
+      continue;
+    }
+    if (SECTION_HEADING2.test(line))
+      break;
+    const trimmed = line.trimEnd();
+    if (SPEC_BOUNDARY_LABELS.includes(trimmed)) {
+      closeList();
+      if (trimmed === SPEC_BOUNDARY_OWNS_LABEL) {
+        if (ownsSeen) {
+          owns.push({ kind: "bad", text: REPEATED_OWNS_TEXT });
+        } else {
+          ownsSeen = true;
+          listOpen = true;
+        }
+      }
+      continue;
+    }
+    if (!listOpen)
+      continue;
+    if (BULLET.test(line)) {
+      closeBullet();
+      first = line.slice(2);
+      continue;
+    }
+    if (INDENTED.test(line) && line.trim() !== "" && first !== null) {
+      continued.push(line.trim());
+      continue;
+    }
+    closeList();
+  }
+  closeList();
+  return { kind: "section", owns };
+}
+
 // ../core/dist/agent-profile.js
 var AGENT_IDS = ["claude-code", "codex"];
 var CLAUDE_CODE_PROFILE = {
@@ -1148,6 +1945,222 @@ var AGENT_PROFILES = {
 };
 var ALL_HOOK_COMMANDS = new Set(AGENT_IDS.flatMap((id) => [...AGENT_PROFILES[id].commands]));
 
+// ../core/dist/worker-report.js
+var WORKER_REPORT_STATUSES = Object.freeze([
+  "done",
+  "needs-human-verification",
+  "blocked-on-human",
+  "failed"
+]);
+var WORKER_REPORT_RULE_FIELDS = Object.freeze({
+  W1: "Worker report",
+  W2: "Status",
+  W3: "Head",
+  W4: "Head",
+  W5: "Verification",
+  W6: "Verification",
+  W7: "Verification",
+  W8: "Unverified"
+});
+var WORKER_REPORT_LINES = Object.freeze({
+  noBlock: () => 'There is no "## Worker report" block in this report.',
+  statusMissing: (statuses) => `The report has no Status line. Use one of: ${statuses.join(", ")}.`,
+  statusUnknown: (found, statuses) => `The report's Status is "${found}". Use one of: ${statuses.join(", ")}.`,
+  headMissing: () => "The report has no Head line. Give the full commit id the report is about.",
+  headMalformed: (found) => `The report's Head is "${found}", which is not a full commit id.`,
+  headDiffers: (found, head) => `The report is about commit ${found}, but the work's head is ${head}. Ask for a report on the current head.`,
+  noVerification: () => "The report does not say what was run. List each check under Verification with its exit code.",
+  noExitCode: (entry) => `"${entry}" under Verification does not give an exit code.`,
+  nonZeroOnDone: (entry) => `"${entry}" exited with a code other than 0, so the work is not done.`,
+  noUnverified: () => 'The report has no Unverified line. Say what was not checked, or "nothing".',
+  clear: () => "The report is complete and names the commit it is about."
+});
+var FIELD_LINE = /^([A-Z][A-Za-z0-9 ]*):(.*)$/;
+var FULL_COMMIT = /^[0-9a-f]{40}$/;
+var EXIT_CODE = /(?:→|\bexit(?:ed)?(?:\s*code)?)\s*(\d+)/giu;
+function extractWorkerReportBlock(body) {
+  const lines = String(body ?? "").replace(/\r\n/g, "\n").split("\n");
+  const start = lines.findIndex((l) => /^##\s+Worker report\s*$/.test(l.trim()));
+  if (start === -1)
+    return null;
+  const out = [];
+  for (const line of lines.slice(start + 1)) {
+    if (/^#{1,3}\s/.test(line.trim()))
+      break;
+    if (/^```/.test(line.trim()))
+      continue;
+    out.push(line);
+  }
+  return out;
+}
+function parseWorkerReportFields(blockLines) {
+  const fields = /* @__PURE__ */ new Map();
+  let current = null;
+  for (const raw of blockLines) {
+    const m = FIELD_LINE.exec(raw);
+    if (m) {
+      const name = m[1];
+      if (fields.has(name)) {
+        current = null;
+        continue;
+      }
+      current = { inline: m[2].trim(), continuation: [] };
+      fields.set(name, current);
+      continue;
+    }
+    if (current)
+      current.continuation.push(raw);
+  }
+  return fields;
+}
+function splitOutsideBackticks(text) {
+  const parts = [];
+  let buf = "";
+  let inTick = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "`")
+      inTick = !inTick;
+    if (!inTick && ch === ";") {
+      parts.push(buf);
+      buf = "";
+      continue;
+    }
+    if (!inTick && text.startsWith(" \xB7 ", i)) {
+      parts.push(buf);
+      buf = "";
+      i += 2;
+      continue;
+    }
+    buf += ch;
+  }
+  parts.push(buf);
+  return parts.map((p) => p.trim()).filter(Boolean);
+}
+function verificationEntries(field) {
+  if (!field)
+    return [];
+  const entries = field.inline ? splitOutsideBackticks(field.inline) : [];
+  for (const line of field.continuation) {
+    const m = /^\s*[-*]\s+(.*)$/.exec(line);
+    if (m && m[1].trim())
+      entries.push(m[1].trim());
+  }
+  return entries;
+}
+function verificationExitCode(entry) {
+  let code = null;
+  for (const m of entry.matchAll(EXIT_CODE))
+    code = Number(m[1]);
+  return code;
+}
+function checkWorkerReport(body, options = {}) {
+  const statuses = options.statuses ?? WORKER_REPORT_STATUSES;
+  const given = options.head ? options.head : null;
+  const problems = [];
+  const add = (id, line) => {
+    problems.push({ id, field: WORKER_REPORT_RULE_FIELDS[id], line });
+  };
+  const block = extractWorkerReportBlock(body);
+  if (block === null) {
+    add("W1", WORKER_REPORT_LINES.noBlock());
+    return { problems, headChecked: false, fields: {} };
+  }
+  const fields = parseWorkerReportFields(block);
+  const inline = (name) => fields.get(name)?.inline;
+  const status = inline("Status");
+  if (status === void 0)
+    add("W2", WORKER_REPORT_LINES.statusMissing(statuses));
+  else if (!statuses.includes(status))
+    add("W2", WORKER_REPORT_LINES.statusUnknown(status, statuses));
+  const head = inline("Head");
+  let headChecked = false;
+  if (head === void 0)
+    add("W3", WORKER_REPORT_LINES.headMissing());
+  else if (!FULL_COMMIT.test(head))
+    add("W3", WORKER_REPORT_LINES.headMalformed(head));
+  else if (given !== null) {
+    headChecked = true;
+    if (head !== given)
+      add("W4", WORKER_REPORT_LINES.headDiffers(head, given));
+  }
+  const entries = verificationEntries(fields.get("Verification"));
+  if (entries.length === 0)
+    add("W5", WORKER_REPORT_LINES.noVerification());
+  const codes = entries.map((entry) => ({ entry, code: verificationExitCode(entry) }));
+  for (const { entry, code } of codes) {
+    if (code === null)
+      add("W6", WORKER_REPORT_LINES.noExitCode(entry));
+  }
+  if (status === "done") {
+    for (const { entry, code } of codes) {
+      if (code !== null && code !== 0)
+        add("W7", WORKER_REPORT_LINES.nonZeroOnDone(entry));
+    }
+  }
+  if (!fields.has("Unverified"))
+    add("W8", WORKER_REPORT_LINES.noUnverified());
+  const flat = {};
+  for (const [name, field] of fields)
+    flat[name] = field.inline;
+  return { problems, headChecked, fields: flat };
+}
+
+// ../core/dist/task-ready.js
+var READY_DEFAULT_MINUTES = 60;
+function minutesOf(row) {
+  return typeof row.minutes === "number" ? row.minutes : READY_DEFAULT_MINUTES;
+}
+function readyTasks(rows) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!byId.has(row.id))
+      byId.set(row.id, row);
+  }
+  const children = /* @__PURE__ */ new Map();
+  for (const id of byId.keys())
+    children.set(id, []);
+  for (const row of byId.values()) {
+    for (const dep of row.dependsOn)
+      children.get(dep)?.push(row.id);
+  }
+  const memo = /* @__PURE__ */ new Map();
+  const pathFrom = (id) => {
+    const known = memo.get(id);
+    if (known !== void 0)
+      return known;
+    memo.set(id, 0);
+    let best = 0;
+    for (const childId of children.get(id) ?? []) {
+      const child = byId.get(childId);
+      if (child === void 0 || child.progress === "completed")
+        continue;
+      best = Math.max(best, pathFrom(childId));
+    }
+    const total = minutesOf(byId.get(id)) + best;
+    memo.set(id, total);
+    return total;
+  };
+  const startable = [];
+  const person = [];
+  for (const row of byId.values()) {
+    if (row.progress !== "pending")
+      continue;
+    if (!row.dependsOn.every((dep) => byId.get(dep)?.progress === "completed"))
+      continue;
+    if (row.person) {
+      person.push(row.id);
+      continue;
+    }
+    startable.push({ id: row.id, path: 0, tieRank: row.tieRank });
+  }
+  for (const entry of startable)
+    entry.path = pathFrom(entry.id);
+  startable.sort((a, b) => b.path - a.path || a.tieRank - b.tieRank || a.id.localeCompare(b.id));
+  person.sort((a, b) => a.localeCompare(b));
+  return { ready: startable.map((entry) => entry.id), person };
+}
+
 // ../events/dist/result.js
 import { z as z3 } from "zod";
 var firedGuardSchema = z3.object({
@@ -1219,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");
@@ -1719,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 [];
@@ -1730,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 });
     }
@@ -1813,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";
@@ -2293,16 +3313,16 @@ function planCrossFieldProblems(raw, description) {
   if (!isRecord(raw) || !Array.isArray(raw.changes))
     return problems;
   const known = new Set(description.parts.map((p) => p.id));
-  const named = /* @__PURE__ */ new Map();
+  const named2 = /* @__PURE__ */ new Map();
   raw.changes.forEach((change, i) => {
     if (!isRecord(change) || typeof change.part !== "string")
       return;
     if (!known.has(change.part)) {
       problems.push({ path: `changes.${i}.part`, message: `names no part in the system description: ${shown(change.part)}` });
     }
-    const earlier = named.get(change.part);
+    const earlier = named2.get(change.part);
     if (earlier === void 0) {
-      named.set(change.part, i);
+      named2.set(change.part, i);
     } else {
       problems.push({ path: `changes.${i}.part`, message: `${shown(change.part)} is already listed at changes.${earlier}` });
     }
@@ -3285,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
@@ -3334,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);
@@ -3600,8 +4666,8 @@ function contractProblems(raw, description) {
     if (!isRecord(contract) || typeof contract.from !== "string" || typeof contract.to !== "string")
       return;
     const { from, to } = contract;
-    const named = description.connections.some((c) => c.from === from && c.to === to || c.from === to && c.to === from);
-    if (!named) {
+    const named2 = description.connections.some((c) => c.from === from && c.to === to || c.from === to && c.to === from);
+    if (!named2) {
       problems.push({
         path: `contracts.${i}`,
         message: `names no connection in the system description: ${shown(from)} to ${shown(to)}`
@@ -5199,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(),
@@ -5260,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"),
@@ -5274,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.`;
@@ -5359,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";
@@ -5582,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";
@@ -7260,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)) {
@@ -7282,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 = """`,
@@ -7303,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);
@@ -7602,12 +8905,12 @@ function findNotShared(targetRepo, manifest, collidedPaths) {
   if (ignored === null)
     return null;
   const sorted = [...ignored].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
-  const named = sorted.find((entry) => entry.path === SETTINGS_REL) ?? sorted[0];
+  const named2 = sorted.find((entry) => entry.path === SETTINGS_REL) ?? sorted[0];
   return {
-    path: named.path,
-    pattern: named.pattern,
-    source: named.source,
-    line: named.line,
+    path: named2.path,
+    pattern: named2.pattern,
+    source: named2.source,
+    line: named2.line,
     others: sorted.length - 1
   };
 }
@@ -8175,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.
 #
@@ -8208,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
 
@@ -9632,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) {
@@ -9655,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();
@@ -9668,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;
@@ -9682,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());
   });
 }
 
@@ -9707,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")
@@ -9754,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;
@@ -9768,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();
@@ -9811,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) {
@@ -9913,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;
@@ -10111,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);
@@ -10460,8 +11768,8 @@ function renderBlock(content, layout, environment) {
 function renderLine(content, environment) {
   const unicode = decideUnicode(environment);
   const dot = unicode ? UNICODE_GLYPHS.dot : ASCII_GLYPHS.dot;
-  const named = content.version === "" ? "Halfcycle" : `Halfcycle v${content.version}`;
-  const raw = `${named} ${dot} ${content.url}`;
+  const named2 = content.version === "" ? "Halfcycle" : `Halfcycle v${content.version}`;
+  const raw = `${named2} ${dot} ${content.url}`;
   return unicode ? raw : toAscii(raw);
 }
 function renderBanner(content, environment = {}) {
@@ -10545,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();
@@ -10814,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)) {
@@ -10967,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 });
@@ -11395,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) {
@@ -11549,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"],
@@ -11591,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 {
@@ -11600,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);
@@ -11639,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;
@@ -11987,10 +13196,10 @@ function leftForYouLines(left, p) {
   return lines;
 }
 function shownBy(steps) {
-  const named = steps.filter((s) => s.name !== void 0).length;
-  if (named === 0)
+  const named2 = steps.filter((s) => s.name !== void 0).length;
+  if (named2 === 0)
     return "Each is shown by the method's own label for it:";
-  if (named === steps.length)
+  if (named2 === steps.length)
     return "Each is shown by the method's own name for it:";
   return "Each is shown by the method's own name for it, or by its label where the record holds no name:";
 }
@@ -12226,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");
@@ -12257,7 +13466,7 @@ function isEexist(err) {
 }
 function readIfPresent(path) {
   try {
-    return readFileSync12(path, "utf-8");
+    return readFileSync11(path, "utf-8");
   } catch {
     return null;
   }
@@ -12289,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);
@@ -12327,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]) {
@@ -12336,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 };
   }
@@ -12374,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}`;
@@ -12437,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) {
@@ -12474,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;
@@ -12534,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 };
     }
@@ -12637,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: [] };
   }
@@ -12712,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", "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: [] },
@@ -12725,12 +13936,26 @@ 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: [] },
   { verb: "restore", required: [], conditional: [] },
+  {
+    verb: "check-report",
+    required: [
+      {
+        flag: "--head",
+        takesValue: true,
+        missingMessage: "halfcycle check-report: --head is required \u2014 give the full commit id of the work the report is about, so the report can be checked against it."
+      }
+    ],
+    conditional: []
+  },
   {
     verb: "open-phase",
     required: [
@@ -12910,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" };
@@ -13090,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 };
@@ -13139,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) {
@@ -13285,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) {
@@ -13305,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 };
   }
@@ -13457,16 +14682,16 @@ function parseChangeArgs(rest) {
       return notAChangeId("up", change);
     return { ok: true, args: { form: "up", to, target: { kind: "change", sortingId: change }, ...where } };
   }
-  const named = phase ?? "";
-  if (!isValidPhaseIdentity(named)) {
-    return { ok: false, line: `halfcycle change up: '${named}' cannot be a phase name. Nothing was sent.
+  const named2 = phase ?? "";
+  if (!isValidPhaseIdentity(named2)) {
+    return { ok: false, line: `halfcycle change up: '${named2}' cannot be a phase name. Nothing was sent.
 `, exitCode: 2 };
   }
   if (to === "mini") {
     return { ok: false, line: `halfcycle change up: ${CHANGE_PATH_WORDS["only-up"]} Nothing was sent.
 `, exitCode: 1 };
   }
-  return { ok: true, args: { form: "up", to, target: { kind: "phase", phase: named }, ...where } };
+  return { ok: true, args: { form: "up", to, target: { kind: "phase", phase: named2 }, ...where } };
 }
 var OBSERVE_CHANGE_UNREACHABLE = { outcome: "not-sent", reason: "unreachable" };
 function readObserveChangeLine(stdout) {
@@ -13557,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") {
@@ -13582,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
@@ -13821,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 {
@@ -13915,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") {
@@ -13939,11 +15164,11 @@ function readAndCheckPlan(repoRoot, phase, description, verb) {
     return { ok: false, line: `${p} ${fileRel} is not valid JSON (${why}). Fix it, then run this again. Nothing was sent.
 ` };
   }
-  const named = typeof raw === "object" && raw !== null ? raw["phase"] : void 0;
-  if (isValidPhaseIdentity(named) && renderPhaseSegment(named) !== renderPhaseSegment(phase)) {
+  const named2 = typeof raw === "object" && raw !== null ? raw["phase"] : void 0;
+  if (isValidPhaseIdentity(named2) && renderPhaseSegment(named2) !== renderPhaseSegment(phase)) {
     return {
       ok: false,
-      line: `${p} ${fileRel} is the plan for phase "${String(named)}", not phase "${phase}". Run this for the phase the plan names, or correct the plan's phase. Nothing was sent.
+      line: `${p} ${fileRel} is the plan for phase "${String(named2)}", not phase "${phase}". Run this for the phase the plan names, or correct the plan's phase. Nothing was sent.
 `
     };
   }
@@ -14071,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;
   }
@@ -14658,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,
@@ -14668,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);
     }
   });
 }
@@ -14719,10 +15944,10 @@ async function openPhaseReview(credential, phase, request, observe, repoRoot, se
     }
   };
   const parsed = openReviewRequestSchema.safeParse(body);
-  const named = phaseNameSchema.safeParse(phase);
-  if (!parsed.success || !named.success) {
+  const named2 = phaseNameSchema.safeParse(phase);
+  if (!parsed.success || !named2.success) {
     const issues = [
-      ...named.success ? [] : named.error.issues.map((i) => `the phase name: ${i.message}`),
+      ...named2.success ? [] : named2.error.issues.map((i) => `the phase name: ${i.message}`),
       ...parsed.success ? [] : parsed.error.issues.map((i) => `${describeIssuePath(i.path)}: ${i.message}`)
     ];
     throw new CloseRequestInvalid(`that close is not one this platform accepts, so nothing was sent: ${issues.join("; ")}.`);
@@ -15014,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) {
@@ -15471,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;
   };
@@ -15575,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 = [];
@@ -15605,13 +16925,17 @@ function parseCheckTasksArgs(argv) {
     return { ok: false };
   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")
@@ -15661,7 +16985,77 @@ function readSystemParts(repoRoot) {
 ` + problemLines(file.value, checked.problems)
     };
   }
-  return { kind: "ok", partIds: checked.description.parts.map((part) => part.id) };
+  return { kind: "ok", partIds: checked.description.parts.map((part) => part.id), description: checked.description };
+}
+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(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) {
+    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];
+function readPlanSpecFiles(repoRoot, plan) {
+  const entries = [];
+  for (const slug of planSpecNamesToRead(plan)) {
+    const rel = `${SPEC_FOLDER}/${slug}.md`;
+    let text;
+    try {
+      text = readFileSync18(join21(repoRoot, rel), "utf-8");
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT" || code === "ENOTDIR") {
+        entries.push({ slug, criteria: null, boundary: null });
+        continue;
+      }
+      return { kind: "bad", line: `${rel} could not be read. Check that it is a file you can open, then run this again.` };
+    }
+    entries.push({ slug, criteria: readSpecCriteria(text), boundary: readSpecBoundary(text) });
+  }
+  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:";
@@ -15669,7 +17063,7 @@ function runCheckTasks(repoRoot, phase, withTaskList) {
   if (planRead.kind === "missing") {
     return {
       stdout: "",
-      stderr: `${p} there is no ${TASK_PLAN_FILE} in this project yet. Run the task-graph step to write it, then run this again.
+      stderr: `${p} ${MISSING_PLAN_LINE}
 `,
       exitCode: 2
     };
@@ -15692,16 +17086,284 @@ function runCheckTasks(repoRoot, phase, withTaskList) {
   if (system.kind === "bad") {
     return { stdout: "", stderr: `${p} ${system.line}`, exitCode: 2 };
   }
+  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;
   const result = checkTaskPlan(plan, {
     phase,
     taskList,
-    ...system.kind === "ok" ? { system: { file: SYSTEM_DESCRIPTION_REL, partIds: system.partIds } } : {}
+    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 } : {},
+    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>`;
+function parseCheckReportArgs(argv) {
+  const positionals = [];
+  let head;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--head") {
+      const value = argv[i + 1];
+      if (head !== void 0 || value === void 0 || value.trim() === "" || value.startsWith("-"))
+        return { ok: false };
+      head = value.trim();
+      i++;
+      continue;
+    }
+    if (arg !== "-" && arg.startsWith("-"))
+      return { ok: false };
+    positionals.push(arg);
+  }
+  if (positionals.length !== 1 || head === void 0)
+    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");
+  } catch (err) {
+    const code = err.code;
+    const what = source === "-" ? "The report could not be read from standard input" : `${source} could not be read`;
+    const line = code === "ENOENT" && source !== "-" ? `${p} there is no file at ${source}. Save the report to a file, then run this again.` : `${p} ${what}. Check that it is a file you can open, then run this again.`;
+    return { stdout: "", stderr: `${line}
+`, exitCode: 2 };
+  }
+  const result = checkWorkerReport(body, { head, statuses: WORKER_REPORT_STATUSES });
+  if (result.problems.length === 0) {
+    return { stdout: `${WORKER_REPORT_LINES.clear()}
+`, stderr: "", exitCode: 0 };
+  }
+  return { stdout: result.problems.map((problem) => `${problem.line}
+`).join(""), stderr: "", exitCode: 1 };
+}
+
+// dist/ready.js
+var READY_USAGE = `${HALFCYCLE_COMMAND} ready <phase> [--cap <n>] [--repo <root>]`;
+var STATES_TEXT = buildTaskStateSchema.options.join(", ");
+var READY_LINES = {
+  start: (id, title) => `Ready to start: ${named(id, title)}`,
+  pastCap: (id, title) => `Ready, but past the number allowed now: ${named(id, title)}`,
+  person: (id, title) => `Waiting on a person: ${named(id, title)}`,
+  noCap: () => "No number was given, so every task that can start is listed.",
+  nothing: () => "Nothing can start now.",
+  noTaskList: () => `There is no task list at ${TASK_LIST_FILE}, so which tasks are done is not known. Write the task list for this phase, then run this again.`,
+  otherPhase: (phase) => `The task list in ${TASK_LIST_FILE} is not for "${phase}", so which tasks are done is not known. Write the task list for this phase, then run this again.`,
+  noState: (id) => `"${id}" in ${TASK_LIST_FILE} does not give its state as one of: ${STATES_TEXT}.`
+};
+function named(id, title) {
+  return title === void 0 ? id : `${id}, ${title}`;
+}
+function parseReadyArgs(argv) {
+  const positionals = [];
+  let repoRoot;
+  let cap;
+  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 === "--cap") {
+      const value = argv[i + 1];
+      if (cap !== void 0 || value === void 0 || !/^[0-9]+$/.test(value))
+        return { ok: false };
+      const n = Number(value);
+      if (!Number.isSafeInteger(n))
+        return { ok: false };
+      cap = n;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("-"))
+      return { ok: false };
+    positionals.push(arg);
+  }
+  if (positionals.length !== 1)
+    return { ok: false };
+  return { ok: true, phase: positionals[0], cap, repoRoot };
+}
+var PROGRESS = {
+  pending: "pending",
+  completed: "completed",
+  "in-flight": "other",
+  failed: "other",
+  blocked: "other"
+};
+function readyRowsFromFiles(plan, taskList) {
+  const listed = /* @__PURE__ */ new Map();
+  for (const entry of taskList.tasks) {
+    if (!listed.has(entry.id))
+      listed.set(entry.id, entry);
+  }
+  const rows = [];
+  const lines = [];
+  plan.tasks.forEach((task, place2) => {
+    const entry = listed.get(task.id);
+    const state = buildTaskStateSchema.safeParse(entry?.state);
+    if (entry === void 0 || !state.success) {
+      lines.push(READY_LINES.noState(task.id));
+      return;
+    }
+    const title = typeof entry.title === "string" && entry.title !== "" ? entry.title : void 0;
+    const minutes = typeof entry.budgetMinutes === "number" ? entry.budgetMinutes : void 0;
+    rows.push({
+      id: task.id,
+      dependsOn: task.dependsOn,
+      progress: PROGRESS[state.data],
+      person: task.heldBy === "person" || entry.agent === HUMAN_AGENT,
+      ...minutes === void 0 ? {} : { minutes },
+      tieRank: place2,
+      title
+    });
+  });
+  return lines.length > 0 ? { ok: false, lines } : { ok: true, rows };
+}
+function failed2(stderr) {
+  return { stdout: "", stderr, exitCode: 2 };
+}
+function runReady(repoRoot, phase, cap) {
+  const p = "halfcycle ready:";
+  const planRead = readJsonFile(repoRoot, TASK_PLAN_FILE, (raw) => taskPlanSchema.safeParse(raw));
+  if (planRead.kind === "missing")
+    return failed2(`${p} ${MISSING_PLAN_LINE}
+`);
+  if (planRead.kind === "bad")
+    return failed2(`${p} ${planRead.line}
+`);
+  const plan = planRead.value;
+  const listRead = readJsonFile(repoRoot, TASK_LIST_FILE, (raw) => taskListFileSchema.safeParse(raw));
+  if (listRead.kind === "bad")
+    return failed2(`${p} ${listRead.line}
+`);
+  const list2 = listRead.kind === "ok" ? listRead.value : null;
+  const specs = readPlanSpecFiles(repoRoot, plan);
+  if (specs.kind === "bad")
+    return failed2(`${p} ${specs.line}
+`);
+  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 };
+  }
+  if (list2 === null)
+    return failed2(`${READY_LINES.noTaskList()}
+`);
+  if (Array.isArray(list2) || list2.phase !== phase)
+    return failed2(`${READY_LINES.otherPhase(phase)}
+`);
+  const read = readyRowsFromFiles(plan, list2);
+  if (!read.ok)
+    return failed2(read.lines.map((line) => `${line}
+`).join(""));
+  const titles = new Map(read.rows.map((row) => [row.id, row.title]));
+  const set = readyTasks(read.rows);
+  const out = [];
+  if (cap === void 0)
+    out.push(READY_LINES.noCap());
+  set.ready.forEach((id, i) => {
+    out.push(cap === void 0 || i < cap ? READY_LINES.start(id, titles.get(id)) : READY_LINES.pastCap(id, titles.get(id)));
+  });
+  for (const id of set.person)
+    out.push(READY_LINES.person(id, titles.get(id)));
+  if (set.ready.length === 0 && set.person.length === 0)
+    out.push(READY_LINES.nothing());
+  return { stdout: out.map((line) => `${line}
+`).join(""), stderr: "", exitCode: 0 };
+}
+
 // dist/prove.js
 import { spawn as spawn2 } from "node:child_process";
 var PROVE_USAGE = `${HALFCYCLE_COMMAND} prove <phase> <task> --label "<label>" --before -- <test command>
@@ -15726,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 {
@@ -15754,9 +17416,9 @@ function runProveChild(binary, credential, repoRoot, words, deps = {}) {
 }
 
 // dist/uninstall.js
-import { lstatSync as lstatSync3, readFileSync as readFileSync19, 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;
@@ -15797,7 +17459,7 @@ function readMergedJson(targetRepo, rule) {
   let text;
   let value;
   try {
-    text = readFileSync19(path, "utf-8");
+    text = readFileSync20(path, "utf-8");
   } catch {
     text = "";
   }
@@ -15822,7 +17484,7 @@ function validate(options, rules) {
   let manifest = null;
   if (lexists(manifestPath)) {
     try {
-      manifest = parseManifest(readFileSync19(manifestPath, "utf-8"));
+      manifest = parseManifest(readFileSync20(manifestPath, "utf-8"));
     } catch (err) {
       const why = err instanceof UnreadableManifestError ? err.message : "it could not be read";
       throw new Refusal(`${INSTALL_MANIFEST_REL} cannot be read (${why}), so nothing was removed. Restore it from git, or run "${HALFCYCLE_COMMAND}" once to rewrite it, then run "${HALFCYCLE_COMMAND} uninstall" again.`);
@@ -15832,7 +17494,7 @@ function validate(options, rules) {
   let pinReadable = true;
   if (lexists(pinPath)) {
     try {
-      const pin = JSON.parse(readFileSync19(pinPath, "utf-8"));
+      const pin = JSON.parse(readFileSync20(pinPath, "utf-8"));
       const id = isPlainObject3(pin) ? pin[PIN_ENGAGEMENT_ID_FIELD] : void 0;
       engagementId = typeof id === "string" && id !== "" ? id : void 0;
     } catch {
@@ -15857,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.`);
       }
     }
@@ -15888,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 {
@@ -15899,7 +17561,7 @@ function statusLineClaimedFromTree(targetRepo, writeSet) {
   try {
     if (symlinkOnPath(targetRepo, SETTINGS_REL))
       return {};
-    const value = JSON.parse(readFileSync19(join22(targetRepo, SETTINGS_REL), "utf-8"));
+    const value = JSON.parse(readFileSync20(join22(targetRepo, SETTINGS_REL), "utf-8"));
     if (!isPlainObject3(value) || !("statusLine" in value))
       return {};
     const hash = canonicalSha256(value["statusLine"]);
@@ -15913,7 +17575,7 @@ function noRecord(targetRepo, writeSet) {
   const claim = (rel, header, lines) => {
     let text;
     try {
-      text = symlinkOnPath(targetRepo, rel) ? "" : readFileSync19(join22(targetRepo, rel), "utf-8");
+      text = symlinkOnPath(targetRepo, rel) ? "" : readFileSync20(join22(targetRepo, rel), "utf-8");
     } catch {
       text = "";
     }
@@ -16195,7 +17857,7 @@ function removeSelfBuildCrewRoster(targetRepo, lists, name) {
   const abs = join22(targetRepo, rel);
   let bytes;
   try {
-    bytes = readFileSync19(abs);
+    bytes = readFileSync20(abs);
   } catch {
     return;
   }
@@ -16222,7 +17884,7 @@ function removeSelfBuildCrewProfile(targetRepo, rel, text, lists, name) {
   const abs = join22(targetRepo, rel);
   let bytes;
   try {
-    bytes = readFileSync19(abs);
+    bytes = readFileSync20(abs);
   } catch {
     return;
   }
@@ -16333,17 +17995,17 @@ function uninstall(options) {
   const manifest = checked.manifest ?? noRecord(targetRepo, writeSet);
   const deleteWhenEmpty = (created) => created || checked.manifest === null;
   const deleteCodexWhenEmpty = (record2) => record2 === void 0 || deleteWhenEmpty(record2.created);
-  const named = /* @__PURE__ */ new Set();
+  const named2 = /* @__PURE__ */ new Set();
   const name = (list2, text, path) => {
     list2.push(text);
     if (path !== void 0)
-      named.add(path);
+      named2.add(path);
   };
   const settingsEmptyGoes = deleteWhenEmpty(manifest.settings.created);
   applyMergedJson(targetRepo, rules.settings, checked.settings, settingsEmptyGoes, result, name, (value) => {
     const { changed, refused: refused3 } = unmergeSettings(value, manifest.settings, writeSet);
-    for (const note of refused3)
-      name(result.leftAlone, note);
+    for (const note2 of refused3)
+      name(result.leftAlone, note2);
     return { changed, adopted: manifest.settings.adopted };
   });
   const mcpRecord = manifest.mcp ?? BEFORE_UNKNOWN_MCP;
@@ -16403,17 +18065,17 @@ function uninstall(options) {
     removeInstalledFile(targetRepo, BUNDLE_PIN_REL, recorded.get(BUNDLE_PIN_REL), writeSet, result, name);
     try {
       rmSync6(join22(targetRepo, INSTALL_MANIFEST_REL), { force: true });
-      named.add(INSTALL_MANIFEST_REL);
+      named2.add(INSTALL_MANIFEST_REL);
     } catch {
       name(result.failed, INSTALL_MANIFEST_REL, INSTALL_MANIFEST_REL);
     }
     removeEmptyDir(targetRepo, ".halfcycle", writeSet, result, name);
   } else {
-    named.add(BUNDLE_PIN_REL);
-    named.add(INSTALL_MANIFEST_REL);
+    named2.add(BUNDLE_PIN_REL);
+    named2.add(INSTALL_MANIFEST_REL);
   }
   for (const path of filesUnder(targetRepo, ".halfcycle")) {
-    if (!named.has(path))
+    if (!named2.has(path))
       name(result.leftAlone, path, path);
   }
   const exitCode = result.failed.length > 0 || credentialFailed || credential.kind === "no-project-id" ? 1 : 0;
@@ -16453,7 +18115,7 @@ function removeCodexConfigBlock(targetRepo, record2, deleteWhenEmpty, lists, nam
   try {
     if (!lstatSync3(path).isFile())
       return;
-    text = readFileSync19(path, "utf-8");
+    text = readFileSync20(path, "utf-8");
   } catch {
     return;
   }
@@ -16502,7 +18164,7 @@ function removeInstalledFile(targetRepo, path, entry, writeSet, lists, name) {
   if (!writeSet.ownedDirs.has(path.slice(0, path.lastIndexOf("/")))) {
     let bytes;
     try {
-      bytes = readFileSync19(abs);
+      bytes = readFileSync20(abs);
     } catch {
       name(lists.failed, path, path);
       return;
@@ -16544,7 +18206,7 @@ function trimAppendedFile(targetRepo, rec, deleteWhenEmpty, rules, lists, name)
   const path = join22(targetRepo, rel);
   let before;
   try {
-    before = readFileSync19(path, "utf-8");
+    before = readFileSync20(path, "utf-8");
   } catch {
     return [];
   }
@@ -16669,8 +18331,8 @@ function renderUninstallReport(result, home) {
 }
 
 // dist/banner-facts.js
-import { readFileSync as readFileSync20 } from "node:fs";
-import { basename as basename4, join as join23, resolve as resolve6 } from "node:path";
+import { readFileSync as readFileSync21 } from "node:fs";
+import { basename as basename4, join as join23, resolve as resolve7 } from "node:path";
 var BRAND_URL = "halfcycle.ai";
 var TAGLINE = [
   "Fewer cycles.",
@@ -16683,7 +18345,7 @@ var TAGLINE_NARROW = [
 ];
 function bundleVersion() {
   try {
-    const pkg = JSON.parse(readFileSync20(join23(BUNDLE_ROOT, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync21(join23(BUNDLE_ROOT, "package.json"), "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : void 0;
   } catch {
     return void 0;
@@ -16769,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";
@@ -16778,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;
@@ -16786,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 = () => {
@@ -16811,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 };
@@ -16826,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], {
@@ -16881,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 };
   }
@@ -16892,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 };
@@ -16904,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 readFileSync21, 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)
@@ -16945,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.");
@@ -16998,9 +18835,9 @@ function printable(text) {
 }
 function restoreOne(root, folder, refs, rawId) {
   const valid = savedIdSchema.safeParse(rawId);
-  const named = valid.success ? `"${rawId}"` : "with that name";
+  const named2 = valid.success ? `"${rawId}"` : "with that name";
   if (!valid.success || !refs.has(rawId)) {
-    return refused2(`No saved copy ${named} is kept in this project. Saved copies are kept for 7 days. To see the ones there are, run: ${LIST_COMMAND}`);
+    return refused2(`No saved copy ${named2} is kept in this project. Saved copies are kept for 7 days. To see the ones there are, run: ${LIST_COMMAND}`);
   }
   const id = valid.data;
   const saved = readSaved(folder, id);
@@ -17021,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);
@@ -17049,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) {
@@ -17069,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))
@@ -17107,7 +18944,7 @@ function sameAs(abs, st, content) {
   try {
     if ("link" in content)
       return st.isSymbolicLink() && readlinkSync(abs) === content.link;
-    return st.isFile() && readFileSync21(abs).equals(content.bytes);
+    return st.isFile() && readFileSync24(abs).equals(content.bytes);
   } catch {
     return false;
   }
@@ -17117,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: readFileSync21(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`);
@@ -17228,7 +19065,7 @@ function restoreLines(root, ref, saved, out) {
 }
 function pinnedEngagement(root) {
   try {
-    const pin = JSON.parse(readFileSync21(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;
@@ -17250,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(readFileSync21(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;
@@ -17268,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);
@@ -17280,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,
@@ -17308,7 +19145,7 @@ function pruneAtRestore(root, folder, refs, now) {
 }
 function markedRepository(dir) {
   try {
-    const text = readFileSync21(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;
@@ -17412,12 +19249,20 @@ 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}
+         list the tasks of a phase's plan that can start now, longest chain first, up to the number given
   ${CHANGE_USAGE}
          sort a change you are asked for into a small change, a mini phase or a full phase; move it up;
          end a small change and write its record into docs/build-records/changes/
   ${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
@@ -17864,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.
 `);
@@ -18082,6 +19926,61 @@ 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) {
+      process.stderr.write(`${reportShortfalls[0].message}
+`);
+      process.exitCode = 2;
+      return;
+    }
+    const parsed = parseCheckReportArgs(rest);
+    if (!parsed.ok) {
+      process.stderr.write(`halfcycle check-report: usage: ${CHECK_REPORT_USAGE}
+`);
+      process.exitCode = 2;
+      return;
+    }
+    const run = runCheckReport(parsed.source, parsed.head);
+    if (run.stdout !== "")
+      process.stdout.write(run.stdout);
+    if (run.stderr !== "")
+      process.stderr.write(run.stderr);
+    process.exitCode = run.exitCode;
+    return;
+  }
+  if (cmd === "ready") {
+    const parsed = parseReadyArgs(rest);
+    if (!parsed.ok) {
+      process.stderr.write(`halfcycle ready: usage: ${READY_USAGE}
+`);
+      process.exitCode = 2;
+      return;
+    }
+    const run = runReady(parsed.repoRoot ?? process.cwd(), parsed.phase, parsed.cap);
+    if (run.stdout !== "")
+      process.stdout.write(run.stdout);
+    if (run.stderr !== "")
+      process.stderr.write(run.stderr);
+    process.exitCode = run.exitCode;
+    return;
+  }
   if (cmd === "pace") {
     const parsed = parsePaceArgs(rest);
     if (!parsed.ok) {
@@ -18101,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 !== "")
@@ -18109,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) {
@@ -18331,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}