halfcycle 0.5.2 → 0.6.0

package/dist/cli.js

@@ -414,15 +414,15 @@ function readReviewPart(raw) {
   const name = raw["name"];
   const built = raw["built"];
   const decidable = raw["decidable"];
-  const awaitingAnswer2 = raw["awaitingAnswer"];
+  const awaitingAnswer = raw["awaitingAnswer"];
   const sentBack = raw["sentBack"];
   if (!isNonEmptyString(part) || !isNonEmptyString(name))
     return null;
   if (typeof built !== "boolean" || typeof decidable !== "boolean")
     return null;
-  if (typeof awaitingAnswer2 !== "boolean" || typeof sentBack !== "boolean")
+  if (typeof awaitingAnswer !== "boolean" || typeof sentBack !== "boolean")
     return null;
-  return { part, name, built, decidable, awaitingAnswer: awaitingAnswer2, sentBack };
+  return { part, name, built, decidable, awaitingAnswer, sentBack };
 }
 function isPlainObject(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
@@ -513,6 +513,11 @@ var TASK_LIST_FILE = "docs/build-records/build-tasks.json";
 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]?)$/;
 var TASK_PLAN_KINDS = ["build", "review", "spec", "walk", "check"];
 var TASK_PLAN_INTERFACE_KINDS = [
   "route",
@@ -538,7 +543,9 @@ 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()
 }).strict().superRefine((task, ctx) => {
   if (task.reviews !== void 0 && task.kind !== "review") {
     ctx.addIssue({
@@ -564,6 +571,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({
@@ -586,6 +594,20 @@ 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".`,
+  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) => `"${s}" and "${t}" both own ${x}. A file belongs to one spec: keep it in the Owns of the spec that mainly changes it, and let the other spec's tasks list it in what they touch.`,
+  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}".`,
@@ -610,10 +632,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 +643,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);
@@ -826,6 +852,9 @@ function firstDifference(plan, list2) {
   }
   return null;
 }
+function note(code, text) {
+  return { code, text, refuses: false };
+}
 function refusal(code, text) {
   return { code, text, refuses: true };
 }
@@ -838,6 +867,243 @@ 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]?)(?: —|\.|:)/;
+var RETIRED_LEAD = /^\*\*AC(?:0|[1-9][0-9]*)[a-z]? — 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)
+    };
+  });
+}
+function liveNumbers(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 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 liveNumbers(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 shownOwnsText(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, shownOwnsText(item.text))));
+      } else if (isMalformedOwnsPath(item.path)) {
+        lines.push(refusal("B2", taskPlanLineText.B2(slug, shownOwnsText(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 = firstSharedItem(owned[i].items, owned[j].items);
+      if (shared !== null)
+        lines.push(refusal("B1", taskPlanLineText.B1(owned[i].slug, owned[j].slug, shared)));
+    }
+  }
+  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;
 }
@@ -973,6 +1239,8 @@ function checkTaskPlan(plan, request) {
   const tasks = plan.tasks;
   const lines = [];
   const system = request.system;
+  const criteriaOf = specCriteriaBySlug(request.specFiles);
+  const phasePlan = request.phasePlan;
   const ids = new Set(tasks.map((task) => task.id));
   const seen = /* @__PURE__ */ new Set();
   const reportedTwice = /* @__PURE__ */ new Set();
@@ -1013,7 +1281,23 @@ 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) {
+      for (const found of partsNotInPlan([task], phasePlan.partIds)) {
+        lines.push(refusal("O8", taskPlanLineText.O8(found.id, found.parts, 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);
+      }
+    }
   }
+  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 +1318,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,6 +1329,7 @@ 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));
   const refused3 = lines.some((line) => line.refuses);
   if (!refused3)
@@ -1051,6 +1337,108 @@ function checkTaskPlan(plan, request) {
   return { lines, refused: refused3 };
 }
 
+// ../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 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 && !ownsSeen) {
+        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 +1536,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({
@@ -2293,16 +2897,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}` });
     }
@@ -3600,8 +4204,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)}`
@@ -4503,6 +5107,30 @@ var phaseReviewViewSchema = z20.discriminatedUnion("state", [
   phaseReviewOpenSchema,
   phaseReviewClosedSchema
 ]);
+function reviewPartAwaitingAnswer(part) {
+  return part.questions.some((q) => q.agentAnswer === void 0);
+}
+function reviewPartSentBackIn(part, round) {
+  return part.sentBack.some((s) => s.round === round);
+}
+function shownReviewEntryOf(view, shownAt) {
+  const parts = view.parts.map((p) => ({
+    part: p.part,
+    name: p.name,
+    built: p.built,
+    decidable: p.decidable,
+    awaitingAnswer: reviewPartAwaitingAnswer(p),
+    sentBack: reviewPartSentBackIn(p, view.round)
+  }));
+  return {
+    phase: view.phase,
+    number: view.number,
+    round: view.round,
+    reviewVersion: view.reviewVersion,
+    shownAt,
+    parts
+  };
+}
 
 // ../events/dist/build-record-v3.js
 var BUILD_RECORD_V3_FORMAT = "halfcycle-build-record/v3";
@@ -5146,8 +5774,35 @@ function ownerWaitClosedLineOf(item, question2) {
 }
 var OWNER_WAIT_DECLARATIONS_READ_FAILED = "Halfcycle could not read the decisions that waited for you.";
 
-// ../events/dist/pacing.js
+// ../events/dist/owner-wait-answer.js
 import { z as z32 } from "zod";
+var ownerWaitShortIdSchema = z32.string().regex(/^[0-9a-f]{8}$/);
+var OWNER_WAIT_ANSWER_ACTS = ["approve", "decline"];
+var ownerWaitAnswerActSchema = z32.enum(OWNER_WAIT_ANSWER_ACTS);
+var ownerWaitChatRequestSchema = z32.discriminatedUnion("act", [
+  z32.object({ act: z32.literal("approve"), wait: ownerWaitShortIdSchema }).strict(),
+  z32.object({ act: z32.literal("decline"), wait: ownerWaitShortIdSchema, note: scopeNoteWireSchema }).strict()
+]);
+function bareOutcome3(outcome) {
+  return z32.object({ outcome: z32.literal(outcome) }).strict();
+}
+var ownerWaitChatResultSchema = z32.discriminatedUnion("outcome", [
+  z32.object({
+    outcome: z32.literal("recorded"),
+    act: ownerWaitAnswerActSchema,
+    question: z32.string().min(1)
+  }).strict(),
+  z32.object({ outcome: z32.literal("refused"), problems: z32.array(systemDescriptionProblemSchema).min(1) }).strict(),
+  bareOutcome3("not-owner"),
+  bareOutcome3("no-owner"),
+  bareOutcome3("not-found"),
+  bareOutcome3("ambiguous"),
+  bareOutcome3("not-offered"),
+  bareOutcome3("unavailable")
+]);
+
+// ../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 }),
@@ -5158,7 +5813,7 @@ var CLAUDE_PLANS = Object.freeze([
   Object.freeze({ id: "not-sure", words: "Not sure", startingAgents: 2 })
 ]);
 var CLAUDE_PLAN_IDS = Object.freeze(CLAUDE_PLANS.map((plan) => plan.id));
-var claudePlanSchema = z32.enum(CLAUDE_PLAN_IDS);
+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];
@@ -5167,21 +5822,21 @@ function claudePlanKnown(id) {
   return id !== null && id !== CLAUDE_PLAN_UNKNOWN;
 }
 var CLAUDE_PLAN_SET_IN = ["setup", "console"];
-var claudePlanSetInSchema = z32.enum(CLAUDE_PLAN_SET_IN);
+var claudePlanSetInSchema = z33.enum(CLAUDE_PLAN_SET_IN);
 var KEEP_FREE_PERCENTS = [0, 20];
-var keepFreePercentSchema = z32.union([z32.literal(KEEP_FREE_PERCENTS[0]), z32.literal(KEEP_FREE_PERCENTS[1])]);
+var keepFreePercentSchema = z33.union([z33.literal(KEEP_FREE_PERCENTS[0]), z33.literal(KEEP_FREE_PERCENTS[1])]);
 var PACE_AGENTS_MAX = 20;
 var PACE_WINDOW_KINDS = ["five-hour", "seven-day"];
-var paceWindowKindSchema = z32.enum(PACE_WINDOW_KINDS);
+var paceWindowKindSchema = z33.enum(PACE_WINDOW_KINDS);
 var PACE_WINDOW_WORDS = Object.freeze({
   "five-hour": "5-hour window",
   "seven-day": "weekly window"
 });
 var PACE_STATES = ["full", "slowing", "holding"];
-var paceStateSchema = z32.enum(PACE_STATES);
-var claudePlanRequestSchema = z32.object({ claudePlan: claudePlanSchema }).strict();
-var keepFreeRequestSchema = z32.object({ keepFreePercent: keepFreePercentSchema }).strict();
-var pacingSettingsSchema = z32.object({
+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
@@ -5189,43 +5844,43 @@ var pacingSettingsSchema = z32.object({
   message: "a plan says where it was given, and only a plan does",
   path: ["claudePlanSetIn"]
 });
-var pacingBasisTaskSchema = z32.object({
+var pacingBasisTaskSchema = z33.object({
   id: buildTaskIdSchema,
-  dependsOn: z32.array(buildTaskIdSchema).max(BUILD_SNAPSHOT_TASK_LIMIT),
-  budgetMinutes: z32.number().int().min(1).max(BUILD_TASK_BUDGET_MAX_MINUTES).optional(),
-  human: z32.boolean()
+  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()
 }).strict();
-var pacingBasisSchema = z32.object({
-  outcome: z32.literal("basis"),
+var pacingBasisSchema = z33.object({
+  outcome: z33.literal("basis"),
   claudePlan: claudePlanSchema.nullable(),
   keepFreePercent: keepFreePercentSchema,
-  settingsUrl: z32.string().min(1),
+  settingsUrl: z33.string().min(1),
   phase: phaseNameSchema.nullable(),
-  tasks: z32.array(pacingBasisTaskSchema).max(BUILD_SNAPSHOT_TASK_LIMIT),
-  medianTaskMinutes: z32.number().nonnegative().nullable(),
-  medianTaskTokens: z32.number().nonnegative().nullable()
+  tasks: z33.array(pacingBasisTaskSchema).max(BUILD_SNAPSHOT_TASK_LIMIT),
+  medianTaskMinutes: z33.number().nonnegative().nullable(),
+  medianTaskTokens: z33.number().nonnegative().nullable()
 }).strict();
-var paceSuggestionSchema = z32.object({
-  number: z32.number().int().min(1).max(PACE_AGENTS_MAX),
-  minutes: z32.number().int().nonnegative().nullable(),
-  pauses: z32.number().int().nonnegative(),
+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: z32.string().min(1).nullable(),
+  settingsUrl: z33.string().min(1).nullable(),
   knownWindow: paceWindowKindSchema.nullable()
 }).strict();
 var PACE_NOT_PACED_REASONS = ["not-configured", "unreadable"];
-var paceRunResultSchema = z32.discriminatedUnion("outcome", [
-  z32.object({
-    outcome: z32.literal("paced"),
+var paceRunResultSchema = z33.discriminatedUnion("outcome", [
+  z33.object({
+    outcome: z33.literal("paced"),
     pace: paceStateSchema,
-    number: z32.number().int().min(1).max(PACE_AGENTS_MAX),
-    allowedNow: z32.number().int().nonnegative(),
+    number: z33.number().int().min(1).max(PACE_AGENTS_MAX),
+    allowedNow: z33.number().int().nonnegative(),
     windowKind: paceWindowKindSchema.optional(),
     until: utcIso8601.optional(),
     suggestion: paceSuggestionSchema.optional()
   }).strict(),
-  z32.object({ outcome: z32.literal("not-paced"), reason: z32.enum(PACE_NOT_PACED_REASONS) }).strict()
+  z33.object({ outcome: z33.literal("not-paced"), reason: z33.enum(PACE_NOT_PACED_REASONS) }).strict()
 ]);
 function paceAgentsOf(n) {
   return n === 1 ? "1 agent" : `${String(n)} agents`;
@@ -5310,15 +5965,15 @@ function paceAllowedNowOf(k) {
 var PACE_AGENTS_TOO_MANY = `Run at most ${String(PACE_AGENTS_MAX)} agents at once.`;
 
 // ../events/dist/autonomy.js
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 var AUTONOMY_CHANGED_IN = ["console", "chat"];
-var autonomyChangedInSchema = z33.enum(AUTONOMY_CHANGED_IN);
-var autonomySettingsSchema = z33.object({
-  on: z33.boolean(),
+var autonomyChangedInSchema = z34.enum(AUTONOMY_CHANGED_IN);
+var autonomySettingsSchema = z34.object({
+  on: z34.boolean(),
   // whether builds run on their own
-  mayPublish: z33.boolean(),
+  mayPublish: z34.boolean(),
   // whether builds may publish or release without waiting
-  maySpend: z33.boolean(),
+  maySpend: z34.boolean(),
   // whether builds may spend money or sign up without waiting
   changedAt: utcIso8601.nullable(),
   // when the setting last changed; null if never
@@ -5328,37 +5983,37 @@ var autonomySettingsSchema = z33.object({
   message: "says when and where it changed, or neither",
   path: ["changedIn"]
 });
-var autonomyChangeRequestSchema = z33.object({
-  on: z33.boolean(),
+var autonomyChangeRequestSchema = z34.object({
+  on: z34.boolean(),
   // the switch
-  mayPublish: z33.boolean(),
+  mayPublish: z34.boolean(),
   // the publish box
-  maySpend: z33.boolean()
+  maySpend: z34.boolean()
   // the spend box
 }).strict();
 var AUTONOMY_CHAT_ACTS = ["on", "off"];
-var autonomyChatActSchema = z33.enum(AUTONOMY_CHAT_ACTS);
-var autonomyChatRequestSchema = z33.object({
+var autonomyChatActSchema = z34.enum(AUTONOMY_CHAT_ACTS);
+var autonomyChatRequestSchema = z34.object({
   act: autonomyChatActSchema
   // what the owner typed
 }).strict();
-var autonomyChatResultSchema = z33.discriminatedUnion("outcome", [
-  z33.object({
-    outcome: z33.literal("recorded"),
-    on: z33.boolean()
+var autonomyChatResultSchema = z34.discriminatedUnion("outcome", [
+  z34.object({
+    outcome: z34.literal("recorded"),
+    on: z34.boolean()
     // whether builds now run on their own
   }).strict(),
-  z33.object({ outcome: z33.literal("not-owner") }).strict(),
-  z33.object({ outcome: z33.literal("no-owner") }).strict(),
-  z33.object({ outcome: z33.literal("not-offered") }).strict(),
-  z33.object({ outcome: z33.literal("unavailable") }).strict()
+  z34.object({ outcome: z34.literal("not-owner") }).strict(),
+  z34.object({ outcome: z34.literal("no-owner") }).strict(),
+  z34.object({ outcome: z34.literal("not-offered") }).strict(),
+  z34.object({ outcome: z34.literal("unavailable") }).strict()
 ]);
-var autonomyStateSchema = z33.object({
-  on: z33.boolean(),
+var autonomyStateSchema = z34.object({
+  on: z34.boolean(),
   // whether builds run on their own
-  mayPublish: z33.boolean(),
+  mayPublish: z34.boolean(),
   // whether builds may publish or release without waiting
-  maySpend: z33.boolean()
+  maySpend: z34.boolean()
   // whether builds may spend money or sign up without waiting
 }).strict();
 var autonomyStateFileSchema = autonomyStateSchema.extend({
@@ -5367,8 +6022,8 @@ var autonomyStateFileSchema = autonomyStateSchema.extend({
 }).strict();
 var AUTONOMY_STATE_FILE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var AUTONOMY_ACTIVITY_KINDS = ["went-ahead", "waiting", "approved", "closed", "waiting-on-owner"];
-var autonomyActivityKindSchema = z33.enum(AUTONOMY_ACTIVITY_KINDS);
-var autonomyActivityRowSchema = z33.object({
+var autonomyActivityKindSchema = z34.enum(AUTONOMY_ACTIVITY_KINDS);
+var autonomyActivityRowSchema = z34.object({
   kind: autonomyActivityKindSchema,
   // what happened
   phase: scopePhaseSchema,
@@ -5381,6 +6036,8 @@ var autonomyActivityRowSchema = z33.object({
   // whether the agent says it can be undone
   how: statementText(STATEMENT_MAX).optional(),
   // how to undo it, when it can be
+  wait: ownerWaitShortIdSchema.optional(),
+  // the short id the owner types to answer a waiting decision
   at: utcIso8601
   // when it happened
 }).strict().superRefine((row, ctx) => {
@@ -5407,6 +6064,9 @@ var autonomyActivityRowSchema = z33.object({
       });
     }
   }
+  if (row.kind !== "waiting" && row.wait !== void 0) {
+    ctx.addIssue({ code: "custom", message: "only a waiting decision is answered by typing", path: ["wait"] });
+  }
   if (row.kind === "waiting" && (row.undoable !== void 0 || row.how !== void 0)) {
     ctx.addIssue({ code: "custom", message: "a waiting decision has not been made yet", path: ["undoable"] });
   }
@@ -5414,11 +6074,11 @@ var autonomyActivityRowSchema = z33.object({
     ctx.addIssue({ code: "custom", message: "says how to undo it exactly when it can be undone", path: ["how"] });
   }
 });
-var autonomyActivitySchema = z33.object({
-  rows: z33.array(autonomyActivityRowSchema)
+var autonomyActivitySchema = z34.object({
+  rows: z34.array(autonomyActivityRowSchema)
   // newest first
 }).strict();
-var savedIdSchema = z33.string().min(1).max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "must be lower-case letters, digits and single hyphens");
+var savedIdSchema = z34.string().min(1).max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "must be lower-case letters, digits and single hyphens");
 var SAVED_REF_PREFIX = "refs/halfcycle/saved/";
 function savedRefOf(id) {
   return `${SAVED_REF_PREFIX}${id}`;
@@ -5457,33 +6117,33 @@ function isGitFolderSegment(segment) {
   return t === ".git" || /^git~\d+$/.test(t);
 }
 var SAVED_PATH_KEPT_IN = ["commit", "copy"];
-var savedPathSchema = z33.object({
-  path: z33.string().max(4096).refine(isProjectRelativePath, { message: "must be a path inside the project" }),
+var savedPathSchema = z34.object({
+  path: z34.string().max(4096).refine(isProjectRelativePath, { message: "must be a path inside the project" }),
   // the file, relative to the project
-  keptIn: z33.enum(SAVED_PATH_KEPT_IN)
+  keptIn: z34.enum(SAVED_PATH_KEPT_IN)
   // in the save's commit, or copied beside this file
 }).strict();
-var savedCommitSchema = z33.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/, "must be a full commit hash");
-var savedBranchSchema = z33.object({
-  name: z33.string().min(1).max(255).refine((n) => !hasControlCharacter(n) && !n.startsWith("-") && !n.includes("..") && n !== "HEAD", {
+var savedCommitSchema = z34.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/, "must be a full commit hash");
+var savedBranchSchema = z34.object({
+  name: z34.string().min(1).max(255).refine((n) => !hasControlCharacter(n) && !n.startsWith("-") && !n.includes("..") && n !== "HEAD", {
     message: "must be a branch name"
   }),
   // the branch's name
   commit: savedCommitSchema
   // the commit it pointed at
 }).strict();
-var savedSchema = z33.object({
+var savedSchema = z34.object({
   id: savedIdSchema,
   // what restore is typed with
   savedAt: utcIso8601,
   // when the copy was made
-  ref: z33.string().min(1),
+  ref: z34.string().min(1),
   // where the saved commit is kept
-  what: z33.string().min(1).max(2e3),
+  what: z34.string().min(1).max(2e3),
   // what the action would have changed, in words
-  paths: z33.array(savedPathSchema),
+  paths: z34.array(savedPathSchema),
   // every saved file
-  branches: z33.array(savedBranchSchema)
+  branches: z34.array(savedBranchSchema)
   // every saved line of work
 }).strict().refine((s) => s.ref === savedRefOf(s.id), { message: "must be the ref of this save", path: ["ref"] });
 function autonomyA13(accepted, carried) {
@@ -5493,8 +6153,9 @@ function autonomyA14(count, parts, acceptLine) {
   const typed = acceptLine === null ? 'say "review what was built" and type the lines it gives.' : `say "review what was built", then type ${acceptLine} to accept them with those parts, or type the reject line it gives for a task's tests.`;
   return `The phase waits for you: ${String(count)} tests the agents said pass were not run by Halfcycle, so ${namesOf(parts)} wait for you too. Only you can accept or reject those tests. In your own coding agent's session, ` + typed;
 }
-function autonomyA15(count) {
-  return `The phase waits for you: ${String(count)} parts were built without an approved scope, and only you can decide them.`;
+function autonomyA15(count, acceptLine) {
+  const typed = acceptLine === null ? 'say "review what was built" and type the lines it gives.' : `type ${acceptLine} to accept them and close the phase, or say "review what was built" to decide one differently.`;
+  return `The phase waits for you: ${String(count)} parts were built without an approved scope or outside the plan, and only you can decide them. In your own coding agent's session, ${typed}`;
 }
 function namesOf(names) {
   if (names.length <= 1)
@@ -7545,12 +8206,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
   };
 }
@@ -10403,8 +11064,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 = {}) {
@@ -11930,10 +12591,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:";
 }
@@ -12658,7 +13319,7 @@ function isMissingRoute(method, status, body) {
 import { join as join17 } 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-report", "ready", "uninstall", "change", "pace", "prove", "preview", "doctor", "restore"];
 var CONTRACTS = [
   { verb: "install", required: [], conditional: [] },
   { verb: "check-drift", required: [], conditional: [] },
@@ -12668,12 +13329,24 @@ var CONTRACTS = [
   { verb: "plan", required: [], conditional: [] },
   { verb: "review", required: [], conditional: [] },
   { verb: "check-tasks", required: [], conditional: [] },
+  { verb: "ready", required: [], conditional: [] },
   { verb: "uninstall", required: [], conditional: [] },
   { verb: "pace", 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: [
@@ -13400,16 +14073,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) {
@@ -13882,11 +14555,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.
 `
     };
   }
@@ -14189,20 +14862,14 @@ var CHANGE_WORDS = {
   remove: "planned to be removed",
   "not-in-plan": "not in the plan"
 };
-function awaitingAnswer(part) {
-  return part.questions.some((q) => q.agentAnswer === void 0);
-}
-function sentBackInRound(part, round) {
-  return part.sentBack.some((s) => s.round === round);
-}
 function partStatus(part, round) {
   const settled = settledStatus(part);
   if (settled !== void 0) {
     return part.givenIn === "autonomy" ? `${settled}, ${DECIDED_BY_AUTONOMY_SENTENCE}` : settled;
   }
-  if (awaitingAnswer(part))
+  if (reviewPartAwaitingAnswer(part))
     return "Waiting for the agent's answer";
-  if (sentBackInRound(part, round))
+  if (reviewPartSentBackIn(part, round))
     return "Sent back, waiting for the next round";
   return "Waits for your decision";
 }
@@ -14377,22 +15044,7 @@ var AN3_LINE = "halfcycle review: the answer must be one paragraph of at most 1,
 var AN4_LINE = "halfcycle review: the answer looks like it holds a password or key, so it was not sent. Write it again without it.";
 var AN5_LINE = "halfcycle review: the answer was not accepted. Reword it in plain words and run this again.";
 function shownReviewEntry(view, shownAt) {
-  const parts = view.parts.map((p) => ({
-    part: p.part,
-    name: p.name,
-    built: p.built,
-    decidable: p.decidable,
-    awaitingAnswer: awaitingAnswer(p),
-    sentBack: sentBackInRound(p, view.round)
-  }));
-  return {
-    phase: view.phase,
-    number: view.number,
-    round: view.round,
-    reviewVersion: view.reviewVersion,
-    shownAt,
-    parts
-  };
+  return shownReviewEntryOf(view, shownAt);
 }
 function writeShownReview(engagementId, entry, home) {
   const written = updateShownRecord(engagementId, (current) => ({
@@ -14683,10 +15335,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("; ")}.`);
@@ -14864,7 +15516,7 @@ function closeStepReport(phase, attempt, engagementId) {
           exitCode = 0;
           break;
         case "autonomy-waits":
-          stdout.push(answer.reason === "unchecked-claims" ? autonomyA14(answer.count, answer.parts.map((p) => p.name), typedAcceptLine(phase)) : autonomyA15(answer.count));
+          stdout.push(answer.reason === "unchecked-claims" ? autonomyA14(answer.count, answer.parts.map((p) => p.name), typedAcceptLine(phase)) : autonomyA15(answer.count, typedAcceptLine(phase)));
           exitCode = 0;
           break;
         default:
@@ -15569,6 +16221,7 @@ 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 issuePlace(rel, path) {
   return path.length === 0 ? rel : `${rel}.${path.map(String).join(".")}`;
 }
@@ -15625,7 +16278,42 @@ 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 raw;
+  try {
+    raw = JSON.parse(readFileSync18(join21(repoRoot, file), "utf-8"));
+  } catch {
+    return void 0;
+  }
+  const checked = checkPhasePlan(raw, description);
+  if (!checked.ok || renderPhaseSegment(checked.plan.phase) !== renderPhaseSegment(phase))
+    return void 0;
+  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 runCheckTasks(repoRoot, phase, withTaskList) {
   const p = "halfcycle check-tasks:";
@@ -15633,7 +16321,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
     };
@@ -15656,16 +16344,207 @@ 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 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,
+    ...system.kind === "ok" ? { system: { file: SYSTEM_DESCRIPTION_REL, partIds: system.partIds } } : {},
+    ...phasePlan !== void 0 ? { phasePlan } : {}
   });
   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 };
+}
+function runCheckReport(source, head, deps = {}) {
+  const p = "halfcycle check-report:";
+  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 check = checkTaskPlan(plan, { phase, taskList: { file: list2 }, specFiles: specs.specFiles });
+  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>
@@ -15718,7 +16597,7 @@ 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 writeFileSync8 } 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";
 var REMOVE_CREDENTIAL_FLAG = "--remove-credential";
@@ -15761,7 +16640,7 @@ function readMergedJson(targetRepo, rule) {
   let text;
   let value;
   try {
-    text = readFileSync19(path, "utf-8");
+    text = readFileSync20(path, "utf-8");
   } catch {
     text = "";
   }
@@ -15786,7 +16665,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.`);
@@ -15796,7 +16675,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 {
@@ -15863,7 +16742,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"]);
@@ -15877,7 +16756,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 = "";
     }
@@ -16159,7 +17038,7 @@ function removeSelfBuildCrewRoster(targetRepo, lists, name) {
   const abs = join22(targetRepo, rel);
   let bytes;
   try {
-    bytes = readFileSync19(abs);
+    bytes = readFileSync20(abs);
   } catch {
     return;
   }
@@ -16186,7 +17065,7 @@ function removeSelfBuildCrewProfile(targetRepo, rel, text, lists, name) {
   const abs = join22(targetRepo, rel);
   let bytes;
   try {
-    bytes = readFileSync19(abs);
+    bytes = readFileSync20(abs);
   } catch {
     return;
   }
@@ -16297,17 +17176,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;
@@ -16367,17 +17246,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;
@@ -16417,7 +17296,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;
   }
@@ -16466,7 +17345,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;
@@ -16508,7 +17387,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 [];
   }
@@ -16633,7 +17512,7 @@ function renderUninstallReport(result, home) {
 }
 
 // dist/banner-facts.js
-import { readFileSync as readFileSync20 } from "node:fs";
+import { readFileSync as readFileSync21 } from "node:fs";
 import { basename as basename4, join as join23, resolve as resolve6 } from "node:path";
 var BRAND_URL = "halfcycle.ai";
 var TAGLINE = [
@@ -16647,7 +17526,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;
@@ -16885,7 +17764,7 @@ async function runPace(repoRoot, start, deps) {
 
 // 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 readFileSync22, 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";
 var RESTORE_USAGE = `${HALFCYCLE_COMMAND} restore [<id>]`;
@@ -16962,9 +17841,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);
@@ -17071,7 +17950,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() && readFileSync22(abs).equals(content.bytes);
   } catch {
     return false;
   }
@@ -17094,7 +17973,7 @@ function restoreCopy(root, saveDir, rel, out) {
     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: readFileSync22(src), mode: st.mode & 511 }, out);
   } catch {
   }
   out.left.push(`${rel}: the saved copy does not hold it`);
@@ -17192,7 +18071,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(readFileSync22(join24(root, BUNDLE_PIN_REL), "utf-8"));
     return isEngagementId(pin.engagementId) ? pin.engagementId : null;
   } catch {
     return null;
@@ -17223,7 +18102,7 @@ function readSaved(folder, id) {
   if (fst === null || !fst.isFile())
     return null;
   try {
-    const parsed = savedSchema.safeParse(JSON.parse(readFileSync21(file, "utf-8")));
+    const parsed = savedSchema.safeParse(JSON.parse(readFileSync22(file, "utf-8")));
     return parsed.success && parsed.data.id === id ? parsed.data : null;
   } catch {
     return null;
@@ -17272,7 +18151,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 = readFileSync22(join24(dir, SAVED_REPOSITORY_FILE_NAME), "utf-8").trim();
     return text === "" ? null : text;
   } catch {
     return null;
@@ -17376,6 +18255,10 @@ 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_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/
@@ -18046,6 +18929,45 @@ halfcycle build-record: until ${obtained.stampFailure.path} can be written, the
     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) {