halfcycle 0.5.3 → 0.6.0

package/dist/cli.js

@@ -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)}`
@@ -7602,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
   };
 }
@@ -10460,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 = {}) {
@@ -11987,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:";
 }
@@ -12715,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: [] },
@@ -12725,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: [
@@ -13457,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) {
@@ -13939,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.
 `
     };
   }
@@ -14719,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("; ")}.`);
@@ -15605,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(".")}`;
 }
@@ -15661,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:";
@@ -15669,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
     };
@@ -15692,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>
@@ -15754,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";
@@ -15797,7 +16640,7 @@ function readMergedJson(targetRepo, rule) {
   let text;
   let value;
   try {
-    text = readFileSync19(path, "utf-8");
+    text = readFileSync20(path, "utf-8");
   } catch {
     text = "";
   }
@@ -15822,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.`);
@@ -15832,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 {
@@ -15899,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"]);
@@ -15913,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 = "";
     }
@@ -16195,7 +17038,7 @@ function removeSelfBuildCrewRoster(targetRepo, lists, name) {
   const abs = join22(targetRepo, rel);
   let bytes;
   try {
-    bytes = readFileSync19(abs);
+    bytes = readFileSync20(abs);
   } catch {
     return;
   }
@@ -16222,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;
   }
@@ -16333,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;
@@ -16403,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;
@@ -16453,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;
   }
@@ -16502,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;
@@ -16544,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 [];
   }
@@ -16669,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 = [
@@ -16683,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;
@@ -16921,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>]`;
@@ -16998,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);
@@ -17107,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;
   }
@@ -17130,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`);
@@ -17228,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;
@@ -17259,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;
@@ -17308,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;
@@ -17412,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/
@@ -18082,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) {