catherd-cli 1.5.0 → 2.0.0-beta.20261022113309

package/src/domain/fail-lines.ts

@@ -0,0 +1,26 @@
+const ANSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+
+/**
+ * The lines of a check's output that name a failure, stripped of colour, timings and counters so two runs compare
+ * equal: at most 60 lines of at most 300 characters (t3herd `failLines`).
+ */
+export function checkFailLines(out: string): string[] {
+  const seen = new Set<string>();
+  for (const raw of out.split("\n")) {
+    const line = raw
+      .replace(ANSI, "")
+      .replace(/\s*[[(]\s*\d+(\.\d+)?\s*(ms|s|m)\s*[\])]/g, "")
+      .replace(/\b\d+(\.\d+)?(ms|s)\b/g, "")
+      .trim();
+    const vuln = line.match(/^Vulnerability #\d+: (GO-\d{4}-\d+)/)?.[1];
+    if (vuln) seen.add(`vulnerability ${vuln}`);
+    else if (/(^|\s)(FAIL|FAILED|✗|✕|×)(\s|:|$)|^\(fail\)|^--- FAIL|^not ok\b|\bpanic:|^error:/.test(line))
+      seen.add(line.slice(0, 300));
+    if (seen.size >= 60) break;
+  }
+  return [...seen];
+}
+
+/** The lines of `fails` the base does not have; all of them when there is no base record. */
+export const newFails = (fails: string[], base: string[] | null): string[] =>
+  fails.filter((f) => !base?.includes(f));

package/src/domain/failover.ts

@@ -1,8 +1,6 @@
-import { billingKeyOf, type Catalog, DIMS, type Dim, rungInfo, scoresOf } from "./catalog.ts";
+import { billingKeyOf, type Catalog, pairOf, rungInfo } from "./catalog.ts";
 import { type BillingMode, compareCost, type Cost, costOf, DEFAULT_BILLING } from "./cost.ts";
 import { type Rung, tryParseRung } from "./ids.ts";
-import { DIFFICULTIES, KINDS } from "./lane.ts";
-import { EFFORT_ORDER } from "./sources.ts";
 
 /**
  * Spec §7.1 and §4.5: a stand-in on the same quota would be out of quota too. The billing key names the
@@ -16,74 +14,35 @@ export function claudeBilled(rung: string): boolean {
   return r !== null && quotaOf(r) === "claude-code";
 }
 
-/** A rung's scores by dim, its own or borrowed through a treat-like; null when unscored or not a rung. */
-export function valuesOf(c: Catalog, rung: string): Partial<Record<Dim, number>> | null {
-  try {
-    return scoresOf(c, rungInfo(c, rung).canonical)?.values ?? null;
-  } catch {
-    return null;
-  }
-}
+/** A rung's intelligence index; null when it is not a rung or not indexed. */
+export const intelligenceOf = (c: Catalog, rung: string): number | null =>
+  pairOf(c, rung)?.intelligence ?? null;
 
-/** The dims used by the routing bars (kind × difficulty) the rung clears: what makes it fit its lanes. */
-export function barDims(c: Catalog, rung: string): Dim[] {
-  const v = valuesOf(c, rung);
-  if (!v) return [];
-  const used = new Set<Dim>();
-  for (const kind of KINDS)
-    for (const d of DIFFICULTIES) {
-      const bar = Object.entries(c.bars[kind][d]).filter(([, min]) => min !== undefined) as [Dim, number][];
-      if (bar.every(([dim, min]) => (v[dim] ?? Number.NEGATIVE_INFINITY) >= min))
-        for (const [dim] of bar) used.add(dim);
-    }
-  return DIMS.filter((d) => used.has(d));
+/** Spec 1.1 §11: `standIn` is a downgrade when the rung is indexed and the stand-in is not, or is less intelligent. */
+export function downgrade(c: Catalog, rung: string, standIn: string): boolean {
+  const a = intelligenceOf(c, rung);
+  const b = intelligenceOf(c, standIn);
+  return a !== null && (b === null || b < a);
 }
 
-/**
- * Spec 1.1 §11: the dims, among those the rung's bars use, on which `standIn` scores below `rung` (a
- * missing score counts as below). Empty means the stand-in clears every bar the rung clears, at least as
- * well: no downgrade.
- */
-export function downgradeDims(c: Catalog, rung: string, standIn: string): Dim[] {
-  return downgradeAgainst(valuesOf(c, rung), barDims(c, rung), valuesOf(c, standIn));
-}
-
-/** downgradeDims with the rung's values and bar dims computed once, for a pool of stand-ins. */
-function downgradeAgainst(
-  a: Partial<Record<Dim, number>> | null,
-  dims: Dim[],
-  standIn: Partial<Record<Dim, number>> | null,
-): Dim[] {
-  if (!a) return [];
-  const b = standIn ?? {};
-  return dims.filter((d) => (b[d] ?? Number.NEGATIVE_INFINITY) < (a[d] as number));
-}
-
-/**
- * Spec 1.1 §11 "the ladder goes down": the dims both rungs are scored on where `upper` (the later rung)
- * scores below `lower`, when it scores above it on none of them. Empty when it does not go down.
- */
-export function ladderDropDims(c: Catalog, lower: string, upper: string): Dim[] {
-  const a = valuesOf(c, lower);
-  const b = valuesOf(c, upper);
-  if (!a || !b) return [];
-  const shared = DIMS.filter((d) => a[d] !== undefined && b[d] !== undefined);
-  if (shared.some((d) => (b[d] as number) > (a[d] as number))) return [];
-  return shared.filter((d) => (b[d] as number) < (a[d] as number));
+/** Spec 1.1 §11 "the ladder goes down": the later rung (`upper`) is less intelligent than `lower`. */
+export function ladderDrop(c: Catalog, lower: string, upper: string): boolean {
+  const a = intelligenceOf(c, lower);
+  const b = intelligenceOf(c, upper);
+  return a !== null && b !== null && b < a;
 }
 
 const costFor = (c: Catalog, billing: Partial<Record<string, BillingMode>>, rung: string): Cost => {
   const info = rungInfo(c, rung);
-  return costOf(info.family, info.parsed.effort, billing[info.key] ?? DEFAULT_BILLING[info.key]);
+  return costOf(info.family, info.pair, info.parsed.effort, billing[info.key] ?? DEFAULT_BILLING[info.key]);
 };
 
 /**
  * Spec 1.1 §11: the rungs of `pool` that can stand in for `rung`, best first. A stand-in is on another
- * quota, scored, paid from a plan or subscription under `billing` (a metered one spends money nobody chose
- * to), startable by `dispatch` (not a native `claude:` subagent), and no downgrade on the rung's bar dims.
- * Claude-billed stand-ins rank last, then the effort nearest the rung's own (a model's efforts carry one
- * another's values as `adjacent`, spec 1.2 §4.3, so the cheapest would otherwise be its lowest effort; plan 14
- * Ruling 4), then the cheapest.
+ * quota, indexed, paid from a plan or subscription under `billing` (a metered one spends money nobody chose
+ * to), startable by `dispatch` (not a native `claude:` subagent), and never less intelligent than the rung
+ * (a rung with no index of its own keeps every stand-in). Claude-billed stand-ins rank last, then the
+ * nearest intelligence above the rung's own, then the cheapest.
  */
 export function rankStandIns(
   c: Catalog,
@@ -93,17 +52,15 @@ export function rankStandIns(
 ): string[] {
   const from = tryParseRung(rung);
   if (!from) return [];
-  // the rung's own values and bar dims, once for the whole pool
-  const own = valuesOf(c, rung);
-  const dims = barDims(c, rung);
+  const own = intelligenceOf(c, rung);
   const fits = [...new Set(pool)].filter((x) => {
     const r = tryParseRung(x);
-    const values = r ? valuesOf(c, x) : null;
-    if (!r || r.backend === "claude" || quotaOf(r) === quotaOf(from) || !values) return false;
+    const i = r ? intelligenceOf(c, x) : null;
+    if (!r || r.backend === "claude" || quotaOf(r) === quotaOf(from) || i === null) return false;
     if (costFor(c, billing, x).tier === 1) return false;
-    return downgradeAgainst(own, dims, values).length === 0;
+    return own === null || i >= own;
   });
-  const gap = (x: string) => effortGap(from.effort, tryParseRung(x)?.effort ?? "");
+  const gap = (x: string) => (own === null ? 0 : (intelligenceOf(c, x) as number) - own);
   return fits.sort(
     (a, b) =>
       Number(claudeBilled(a)) - Number(claudeBilled(b)) ||
@@ -113,35 +70,28 @@ export function rankStandIns(
   );
 }
 
-/** How many effort steps apart two efforts are; an effort that is no effort word (`default`) is far from all. */
-function effortGap(a: string, b: string): number {
-  const i = (EFFORT_ORDER as readonly string[]).indexOf(a);
-  const j = (EFFORT_ORDER as readonly string[]).indexOf(b);
-  if (a === b) return 0;
-  return i < 0 || j < 0 ? EFFORT_ORDER.length : Math.abs(i - j);
-}
-
-/** How a family's `on` key or a model id's prefix maps to the backend that runs it. */
+/** How a family's `on` key maps to the backend that runs it. */
 const BACKEND_OF_KEY: Record<string, string> = { "opencode-go": "opencode" };
 
 /**
- * Every rung the catalog knows how to name: each shipped family's model on each backend at each effort (at
- * `#default` when it has none),
- * each listed model at each effort, and each treat-like whose model is an opencode id (`opencode-go/…`,
- * `opencode/…`), such as the shipped Kimi K3 stand-in. Sorted, without duplicates.
+ * Every indexed rung catherd can name: each shipped family's model on each backend at each effort the index
+ * (or the backend's listing) gives it, and each listed model at each listed effort. Sorted, without duplicates.
  */
-export function catalogRungs(c: Catalog): string[] {
+export function catalogPairs(c: Catalog): string[] {
   const out = new Set<string>();
+  const add = (backend: string, model: string, efforts: readonly string[]) => {
+    for (const e of [...efforts, "default"]) {
+      const rung = `${backend}:${model}#${e}`;
+      if (pairOf(c, rung)) out.add(rung);
+    }
+  };
   for (const f of c.families)
     for (const [key, m] of Object.entries(f.on)) {
       if (!m) continue;
-      // a model with no effort has one rung, #default (Claude Code's Haiku, Cursor's Composer; spec 1.3 §7.1)
-      for (const e of m.efforts.length ? m.efforts : ["default"])
-        out.add(`${BACKEND_OF_KEY[key] ?? key}:${m.id}#${e}`);
+      const backend = BACKEND_OF_KEY[key] ?? key;
+      add(backend, m.id, rungInfo(c, `${backend}:${m.id}#default`).efforts);
     }
   for (const [backend, l] of Object.entries(c.listed))
-    for (const m of l.models) for (const e of m.efforts) out.add(`${backend}:${m.id}#${e}`);
-  for (const canonical of Object.keys(c.treatLike))
-    if (/^opencode(-go)?\//.test(canonical)) out.add(`opencode:${canonical}`);
+    for (const m of l.models) add(backend, m.id, m.efforts);
   return [...out].sort();
 }

package/src/domain/findings.ts

@@ -0,0 +1,47 @@
+import type { Finding } from "./run-events.ts";
+
+const LINE = /^\s*(?:[-*]\s+|\d+[.)]\s+)?\**(BLOCKER|BUG|NIT)\b\**\s*:?\s*(.*)$/;
+/** What a reviewer writes where it has nothing to report: `BUG: none`, `NIT n/a`, a lone dash. */
+const NOTHING = /^(?:none|n\/a|nil|no findings?|clean|[-—–]+)\.?\**$/i;
+const PATH = /^[`'"(]*((?:\.{0,2}\/)?[\w@~.+-]+(?:\/[\w@~.+-]+)*)(?::\d+(?:[-:]\d+)?)?[`'"),;:]*$/;
+
+/**
+ * The first `path:line` or `path` token of a finding's first words (a reviewer writes
+ * `BLOCKER file:line — problem — fix`), or null: a path has a `/` or an extension.
+ */
+export function fileOf(text: string): string | null {
+  for (const tok of text.trim().split(/\s+/).slice(0, 4)) {
+    if (/^[—–-]+$/.test(tok)) return null;
+    const p = PATH.exec(tok)?.[1];
+    if (p && (p.includes("/") || /\.[A-Za-z]\w*$/.test(p))) return p;
+  }
+  return null;
+}
+
+/** A reviewer's reply as findings, in order: its BLOCKER, BUG and NIT lines, as written; "none" lines left out. */
+export function parseFindings(reply: string): Finding[] {
+  const out: Finding[] = [];
+  for (const line of reply.split("\n")) {
+    const m = LINE.exec(line);
+    if (!m) continue;
+    const rest = (m[2] ?? "").trim();
+    if (!rest || NOTHING.test(rest)) continue;
+    out.push({ label: m[1] as Finding["label"], text: line.trim(), file: fileOf(rest) });
+  }
+  return out;
+}
+
+/** The lines a failing verifier lists below its VERDICT line, as BLOCKERs: what the next fix round starts from. */
+export function parseFailLines(reply: string, max = 12): Finding[] {
+  const lines = reply.split("\n").map((l) => l.trim());
+  const at = lines.findIndex((l) => l !== "");
+  return lines
+    .slice(at + 1)
+    .filter((l) => l !== "" && !/^STATUS:/i.test(l))
+    .slice(0, max)
+    .map((l) => ({
+      label: "BLOCKER" as const,
+      text: l.replace(/^(?:[-*]\s+|\d+[.)]\s+)/, ""),
+      file: fileOf(l.replace(/^(?:[-*]\s+|\d+[.)]\s+)/, "").replace(/^\**FAIL\**:?\s*/i, "")),
+    }));
+}

package/src/domain/gate-brief.ts

@@ -8,6 +8,7 @@ export const RECHECK_COMMAND_MIN = 10;
 /** The rules of the gate, one paragraph each. */
 export const VERIFIER_GATE_RULES = [
   "Run the root gate (the milestone's full check) as one gate item and each per-service acceptance suite as its own item, never as one command: a failure then names its item, and a re-check reruns only that item. Acceptance that builds from HEAD (git archive, a commit's image) is yours: workers do not commit, so they never run it.",
+  "Run the milestone's full check with gate_run (or catherd gate run), on the committed HEAD, never by hand: catherd runs it detached under the verifier lock, reruns a failure with new lines once, scans the run's commits for secrets and records the result, and land reads that record. If it answers running, call it again. When it fails and no baseline exists, it says how to record the base's own failures from a checkout of the base.",
   "Stay in the foreground until your verdict: no background watcher, and never end your turn while a command runs.",
   `When the machine, not the work, stops an item (a VPN filter, a Docker client proxy, a dead registry, no DNS), probe it directly, twice, 5 s apart, and if it still fails, reply VERDICT: BLOCKED: environment — <the probe and its output>. That is a blocker for the owner, not a FAIL.`,
   "Last, when you built Docker images, run docker image prune -f, so the gates of later milestones do not fill the disk.",

package/src/domain/ids.ts

@@ -11,8 +11,8 @@ export function assertId(kind: string, value: string): string {
   return value;
 }
 
-/** The backends that run as a process through a `BackendAdapter` (spec 1.3: cursor, grok and antigravity). */
-export const ADAPTER_IDS = ["codex", "claude-code", "opencode", "cursor", "grok", "antigravity"] as const;
+/** The backends that run as a process through a `BackendAdapter`. */
+export const ADAPTER_IDS = ["codex", "claude-code", "opencode", "cursor"] as const;
 
 /** `claude` is the native Claude Code subagent path (no process); the rest are adapters. */
 const RUNG_BACKENDS = [...ADAPTER_IDS, "claude"] as const;
@@ -56,8 +56,19 @@ export function tryParseRung(s: string): Rung | null {
   }
 }
 
+/** Reasoning efforts from least to most; a rung's effort that is none of these (`default`) cannot be ranked. */
+export const EFFORT_ORDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"] as const;
+export type EffortWord = (typeof EFFORT_ORDER)[number];
+
+/** Index in `EFFORT_ORDER`; -1 when `e` is not an effort word. */
+export const effortRank = (e: string): number => (EFFORT_ORDER as readonly string[]).indexOf(e);
+
 export const formatRung = (r: Rung): string => `${r.backend}:${r.model}#${r.effort}`;
 
+/** Spec 2.0 decision 12: the daemon runs every role headless, so a native `claude:` rung runs as `claude-code:`. */
+export const headlessRung = (rung: string): string =>
+  rung.startsWith("claude:") ? `claude-code:${rung.slice("claude:".length)}` : rung;
+
 const B32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 
 let lastTime = -1;

package/src/domain/jev.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { BLOCKED_REASONS } from "./blocked.ts";
 import { type Difficulty, KINDS, type Kind, parseLaneHeader } from "./lane.ts";
 import { scrubKeyShapes, scrubSecretAssignments } from "./secrets.ts";
 
@@ -29,6 +30,12 @@ const RouteRuleSchema = z.object({
   /** exactly two levels each, in order: copy then build, logic then hard */
   trackA: z.array(z.string()).length(2),
   trackB: z.array(z.string()).length(2),
+  /** a noul answer at or above this is a yes */
+  noulMin: z.number().min(0).max(1),
+  /** a yes to any of these lifts the lane to at least logic */
+  floorLogic: z.array(z.string()),
+  /** a yes to any of these holds the lane at build; the floor wins */
+  capBuild: z.array(z.string()),
 });
 export type RouteRule = z.infer<typeof RouteRuleSchema>;
 const VerdictRuleSchema = z.object({ min: z.number().min(0).max(1), fallback: z.string() });
@@ -38,9 +45,16 @@ export const JevFileSchema = z.looseObject({
   schema: z.literal(1),
   model: z.string(),
   sets: z.object({
-    "route-v2": z.object({ questions: z.record(z.string(), QuestionSchema), rule: RouteRuleSchema }),
+    "route-v2": z
+      .object({ questions: z.record(z.string(), QuestionSchema), rule: RouteRuleSchema })
+      .superRefine((set, ctx) => {
+        for (const id of [...set.rule.floorLogic, ...set.rule.capBuild])
+          if (set.questions[id]?.type !== "noul")
+            ctx.addIssue({ code: "custom", message: `${id} is no noul question of route-v2` });
+      }),
     finding: z.object({ questions: z.record(z.string(), QuestionSchema), rule: VerdictRuleSchema }),
     "same-defect": z.object({ questions: z.record(z.string(), QuestionSchema), rule: VerdictRuleSchema }),
+    stop: z.object({ questions: z.record(z.string(), QuestionSchema), rule: VerdictRuleSchema }),
   }),
 });
 export type JevFile = z.infer<typeof JevFileSchema>;
@@ -50,6 +64,7 @@ export type SetName = keyof JevFile["sets"];
 export const VERDICT_OPTIONS = {
   finding: ["design", "code", "unclear"],
   "same-defect": ["yes", "no"],
+  stop: [...BLOCKED_REASONS, "other"],
 } as const;
 
 /** JSON with object keys sorted at every depth, so equal data always hashes the same. */
@@ -199,7 +214,7 @@ export interface RouteJudgement {
  * different option counts; the rule reads probabilities instead: the kind at p_max ≥ kindMin, the track
  * when the summed probability of its levels reaches trackMin, and neither in between (the dead band).
  */
-export function judgeRoute(rule: RouteRule, answers: JevAnswers): RouteJudgement {
+function decideRoute(rule: RouteRule, answers: JevAnswers): RouteJudgement {
   const k = answers.kind;
   const d = answers.difficulty;
   const nouls: Record<string, number> = {};
@@ -252,6 +267,36 @@ export function judgeRoute(rule: RouteRule, answers: JevAnswers): RouteJudgement
   };
 }
 
+/**
+ * `decideRoute`, then Jev's yes/no answers (decision 11): a yes to a `floorLogic` question lifts the lane
+ * to logic (hard stays hard), else a yes to a `capBuild` question holds it at build (copy stays copy). The
+ * floor wins, and both apply in the dead band. The reason names the answer only when the difficulty moved.
+ */
+export function judgeRoute(rule: RouteRule, answers: JevAnswers): RouteJudgement {
+  const j = decideRoute(rule, answers);
+  const yes = (ids: string[]) => ids.find((id) => (j.nouls[id] ?? 0) >= rule.noulMin);
+  const lift = yes(rule.floorLogic);
+  const hold = lift === undefined ? yes(rule.capBuild) : undefined;
+  const now: Difficulty | null =
+    lift !== undefined
+      ? j.difficulty === "hard"
+        ? "hard"
+        : "logic"
+      : hold !== undefined
+        ? j.difficulty === "copy"
+          ? "copy"
+          : "build"
+        : j.difficulty;
+  if (now === j.difficulty) return j;
+  const [what, id] = lift !== undefined ? ["floor logic", lift] : ["cap build", hold ?? ""];
+  return {
+    ...j,
+    track: now === "logic" || now === "hard" ? "B" : "A",
+    difficulty: now,
+    rule: `${j.rule}; ${what}: ${id} ${j.nouls[id]}`,
+  };
+}
+
 export interface Verdict<T extends string> {
   value: T;
   /** the chosen answer's probability, when Jev answered */

package/src/domain/judge.ts

@@ -0,0 +1,124 @@
+import { z } from "zod";
+import { BLOCKED_LINE } from "./blocked.ts";
+
+export const JUDGE_KINDS = ["triage", "question", "unexpected", "rules"] as const;
+export type JudgeKind = (typeof JUDGE_KINDS)[number];
+
+/** What a judge call is given: its kind, the unit it is about, a context text and the numbered findings. */
+export interface JudgeInput {
+  id: string;
+  kind: JudgeKind;
+  unit: string;
+  context: string;
+  findings: string[];
+  lanes: { id: string; owns: string[] }[];
+}
+
+const why = z.string();
+
+/** A finished run's rules review proposes at most this many changes to the standing rules (plan 34). */
+export const MAX_RULE_CHANGES = 5;
+export const RuleChangeSchema = z.object({ op: z.enum(["add", "remove"]), text: z.string().min(1), why });
+export type RuleChange = z.infer<typeof RuleChangeSchema>;
+
+export const JudgeDecisionSchema = z.discriminatedUnion("verb", [
+  z.object({
+    verb: z.literal("route"),
+    routes: z.array(z.object({ finding: z.number().int().min(1), to: z.string(), why })),
+  }),
+  z.object({ verb: z.literal("answer"), answer: z.string() }),
+  z.object({ verb: z.literal("ask_owner"), question: z.string() }),
+  z.object({ verb: z.literal("park"), question: z.string() }),
+  z.object({ verb: z.literal("retry"), why }),
+  z.object({ verb: z.literal("climb"), why }),
+  z.object({ verb: z.literal("skip"), why }),
+  z.object({ verb: z.literal("rules"), changes: z.array(RuleChangeSchema) }),
+]);
+export type JudgeDecision = z.infer<typeof JudgeDecisionSchema>;
+
+export const judgeName = (id: string): string => `judge-${id}`;
+
+/** The judge's reply contract, appended to every judge brief (spec 2.0 decision 3). */
+export const JUDGE_CONTRACT = [
+  "Your first line is DECISION: <verb>, one of the verbs your brief lists. Then, by verb:",
+  "- route: one line per finding, ROUTE <n> -> <lane id>|architect|dismiss — <why>",
+  "- answer: ANSWER: <the answer the worker needs, from the plan and the code>",
+  "- ask_owner or park: QUESTION: <one question only the owner can answer>",
+  "- retry, climb or skip: WHY: <one line>",
+  "- rules: up to five lines, ADD <a one-line rule, with a [role, …] tag when it is not for every role> — <the event it comes from>, or REMOVE <the text of one line of knowledge.md> — <why>; no line when nothing should change",
+  `Decide only from what the brief and the run's files show. The last line of your reply is: STATUS: complete — <one line why>. ${BLOCKED_LINE}`,
+].join("\n");
+
+/** The verbs each kind of call may answer with. */
+export const JUDGE_VERBS: Record<JudgeKind, readonly JudgeDecision["verb"][]> = {
+  triage: ["route"],
+  question: ["answer", "ask_owner"],
+  unexpected: ["retry", "climb", "skip", "park"],
+  rules: ["rules"],
+};
+
+/** A line without the emphasis a model puts around it (`**DECISION: retry**`, backticks). */
+const plain = (l: string): string => l.trim().replace(/^[*_`\s]+|[*_`\s]+$/g, "");
+const STATUS = /^STATUS:\s*(complete|partial|blocked|refused|flaky)\b/i;
+const RULE_LINE = /^\s*(?:[-*]|\d+[.)])?\s*\**(ADD|REMOVE)\**:?\s+(.+)$/;
+const ROUTE = /^[-*\s]*ROUTE\s+(\d+)\s*(?:->|→)\s*(\S+)\s*(?:—|–|-|:)?\s*(.*)$/;
+
+/** The text after `label:` on its line and the lines under it, up to the STATUS line. */
+function section(lines: string[], label: string): string | null {
+  const at = lines.findIndex((l) => new RegExp(`^${label}:`, "i").test(plain(l)));
+  if (at < 0) return null;
+  const rest = [plain(lines[at] as string).slice(label.length + 1)];
+  for (const l of lines.slice(at + 1)) {
+    if (STATUS.test(plain(l))) break;
+    rest.push(l.trim());
+  }
+  return rest.join("\n").trim();
+}
+
+/** The judge's decision, or null when the reply is not one its kind allows (the daemon asks once more). */
+export function parseJudgeReply(reply: string, kind: JudgeKind): JudgeDecision | null {
+  const lines = reply.split("\n");
+  const first = lines.map(plain).find(Boolean) ?? "";
+  const verb = /^DECISION:\s*(\w+)\s*$/i.exec(first)?.[1]?.toLowerCase();
+  if (!verb || !(JUDGE_VERBS[kind] as readonly string[]).includes(verb)) return null;
+  const decision = ((): unknown => {
+    switch (verb) {
+      case "route": {
+        const routes = lines.flatMap((l) => {
+          const m = ROUTE.exec(plain(l));
+          return m ? [{ finding: Number(m[1]), to: m[2] as string, why: (m[3] ?? "").trim() }] : [];
+        });
+        return routes.length ? { verb, routes } : null;
+      }
+      case "answer": {
+        const answer = section(lines, "ANSWER");
+        return answer ? { verb, answer } : null;
+      }
+      case "ask_owner":
+      case "park": {
+        const question = section(lines, "QUESTION");
+        return question ? { verb, question } : null;
+      }
+      case "rules": {
+        const changes = lines.flatMap((l) => {
+          const m = RULE_LINE.exec(l);
+          if (!m) return [];
+          const rest = (m[2] as string).trim();
+          const at = rest.lastIndexOf(" — ");
+          return [
+            {
+              op: (m[1] as string).toLowerCase(),
+              text: (at < 0 ? rest : rest.slice(0, at)).trim(),
+              why: at < 0 ? "" : rest.slice(at + 3).trim(),
+            },
+          ];
+        });
+        return { verb, changes: changes.slice(0, MAX_RULE_CHANGES) };
+      }
+      default:
+        return { verb, why: section(lines, "WHY") ?? "" };
+    }
+  })();
+  const parsed = JudgeDecisionSchema.safeParse(decision);
+  return parsed.success ? parsed.data : null;
+}

package/src/domain/lane.ts

@@ -1,4 +1,5 @@
 import { CatherdError } from "./errors.ts";
+import { TASK_REF } from "./plan-doc.ts";
 
 export const KINDS = ["repo_code", "terminal", "ui", "prose", "research"] as const;
 export type Kind = (typeof KINDS)[number];
@@ -15,10 +16,12 @@ export interface LaneHeader {
   after: string[];
   /** `Allow: path[:line], …` under the check: hits of the lane's absence check that are allowed exceptions */
   allow: string[];
+  /** `Tasks: 3, plan.md#4`: the plan tasks the lane implements (catherd inlines them into its worker's brief) */
+  tasks: string[];
 }
 
-/** A lane id in an After: line: Mx.Ly, the shape lanes/<id>.md takes. */
-const LANE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*\.[A-Za-z0-9][A-Za-z0-9._-]*$/;
+/** An After: entry: a lane id (Mx.Ly, the shape lanes/<id>.md takes) or a whole milestone (Mx). */
+const LANE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*(\.[A-Za-z0-9][A-Za-z0-9._-]*)?$/;
 
 /** An Allow: entry: a repo-relative path, optionally `:<line>`. */
 const ALLOW_ENTRY = /^([^\s:]+)(?::(\d+))?$/;
@@ -89,13 +92,29 @@ export function parseLaneHeader(text: string): LaneHeader {
     difficulty: oneOf(field(text, "difficulty"), DIFFICULTIES),
     after: list("after"),
     allow: list("allow"),
+    tasks: list("tasks"),
   };
 }
 
+/** The milestones, other than `m`, that `m`'s lanes wait on (After: entries, lane or milestone), in numeric order. */
+export function milestoneAfter(lanes: { id: string; after: string[] }[], m: string): string[] {
+  const out = new Set<string>();
+  for (const l of lanes)
+    if (l.id.split(".")[0] === m)
+      for (const a of l.after) {
+        const dep = a.split(".")[0] as string;
+        if (dep !== m) out.add(dep);
+      }
+  return [...out].sort((a, b) => a.localeCompare(b, "en", { numeric: true }));
+}
+
 /** What is wrong with the After: and Allow: entries, one line each; none when they are well formed. */
 function orderProblems(h: LaneHeader): string[] {
   const out: string[] = [];
-  for (const a of h.after) if (!LANE_ID.test(a)) out.push(`After "${a}" is not a lane id like M1.L1`);
+  for (const a of h.after)
+    if (!LANE_ID.test(a)) out.push(`After "${a}" is not a lane or milestone id like M1.L1 or M1`);
+  for (const t of h.tasks)
+    if (!TASK_REF.test(t)) out.push(`Tasks "${t}" is not a task number like 3 or plan.md#3`);
   for (const a of h.allow) {
     const m = ALLOW_ENTRY.exec(a);
     try {

package/src/domain/milestone-memory.ts

@@ -0,0 +1,53 @@
+/**
+ * Plan 35 D6: how many milestones of a base run may work side by side. A new one starts when none is working,
+ * else when the memory the machine has free, less a reserve and less what the ramping milestones are still to take,
+ * stays above a floor. The three megabyte numbers are the run profile's `limits.memory`.
+ */
+export const MEMORY_LIMITS = {
+  reserveMb: 2048,
+  perMilestoneMb: 3072,
+  floorMb: 3072,
+  /** a milestone counts at `perMilestoneMb` for this long after its tree is ready: its lanes have not reached their memory yet */
+  rampMs: 300_000,
+  recheckMs: 120_000,
+} as const;
+
+export type MemoryLimits = {
+  reserveMb: number;
+  perMilestoneMb: number;
+  floorMb: number;
+  rampMs: number;
+  recheckMs: number;
+};
+
+/** The profile's own memory limits over the defaults. */
+export function memoryLimitsOf(p: {
+  limits?: { memory?: Partial<Pick<MemoryLimits, "reserveMb" | "perMilestoneMb" | "floorMb">> };
+}): MemoryLimits {
+  return { ...MEMORY_LIMITS, ...p.limits?.memory };
+}
+
+/** Milestones working (a tree, not landed, merged or parked) and those of them still ramping up. */
+export function memoryLoad(
+  ms: { tree: string | null; status: string; treeAt: string | null }[],
+  nowMs: number,
+  l: MemoryLimits = MEMORY_LIMITS,
+): { working: number; ramping: number } {
+  const working = ms.filter((m) => m.tree !== null && !["landed", "merged", "parked"].includes(m.status));
+  return {
+    working: working.length,
+    ramping: working.filter((m) => m.treeAt !== null && Date.parse(m.treeAt) > nowMs - l.rampMs).length,
+  };
+}
+
+/** The memory a deferral waits for: the reserve, what the ramping milestones will take, and the floor. */
+export const neededMb = (ramping: number, l: MemoryLimits = MEMORY_LIMITS): number =>
+  l.reserveMb + ramping * l.perMilestoneMb + l.floorMb;
+
+/** Whether one more milestone may start: always when none is working, so a run always moves. */
+export function mayStartMilestone(
+  i: { availableMb: number; working: number; ramping: number },
+  l: MemoryLimits = MEMORY_LIMITS,
+): boolean {
+  return i.working === 0 || i.availableMb - l.reserveMb - i.ramping * l.perMilestoneMb >= l.floorMb;
+}