catherd-cli 1.4.0 → 2.0.0-beta.20261022113309

package/src/services/panel-setup.ts

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import { BILLING_MODES } from "../domain/cost.ts";
+import { pairOf } from "../domain/catalog.ts";
+import { ROLES, type Role } from "../domain/roles.ts";
+import { catalogQuery, loadCatalog, type IndexedPair } from "./catalog-service.ts";
+import { backendChecks, usedBackends } from "./doctor-backends.ts";
+import { indexCheck } from "./doctor-checks.ts";
+import type { Deps, ProfileSaved } from "./ports.ts";
+import { profileFor } from "./profile-store.ts";
+
+// The panel's Setup page (spec 2.0 decision 25): backends with their doctor status, and each role's rungs picked
+// from the indexed pairs. Every write goes through the ProfilePort.
+
+export const CheckSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  state: z.enum(["ok", "warn", "fail", "skip", "info"]),
+  word: z.string(),
+  detail: z.string(),
+  fix: z.string().optional(),
+});
+export const IssueSchema = z.object({ path: z.string(), message: z.string(), fix: z.string().optional() });
+export const IndexedPairSchema = z.object({
+  rung: z.string(),
+  intelligence: z.number(),
+  price: z.object({ input: z.number(), output: z.number() }).nullable(),
+  speed: z.number().nullable(),
+  context: z.number().nullable(),
+  cost: z.object({
+    tier: z.union([z.literal(0), z.literal(1)]),
+    value: z.number().nullable(),
+    mode: z.enum(BILLING_MODES),
+  }),
+  evidence: z.string().nullable(),
+});
+export const ProfileSavedSchema = z.object({
+  saved: z.boolean(),
+  errors: z.array(IssueSchema),
+  warnings: z.array(IssueSchema),
+  diff: z.array(z.object({ path: z.string(), before: z.unknown(), after: z.unknown() })),
+  linked: z.array(z.string()),
+  pruned: z.array(z.string()),
+  newSessionNeededFor: z.array(z.string()),
+});
+export const SetupViewSchema = z.object({
+  repo: z.string().nullable(),
+  profile: z.object({ name: z.string(), active: z.string(), profiles: z.array(z.string()) }),
+  catalog: CheckSchema,
+  backends: z.array(CheckSchema),
+  issues: z.object({ errors: z.array(IssueSchema), warnings: z.array(IssueSchema) }),
+  roles: z.array(
+    z.object({
+      role: z.enum(ROLES),
+      enabled: z.boolean(),
+      rungs: z.array(z.object({ rung: z.string(), intelligence: z.number().nullable() })),
+      offered: z.array(IndexedPairSchema),
+    }),
+  ),
+});
+export type SetupView = z.infer<typeof SetupViewSchema>;
+
+/** What the Setup page shows: the profile `repo` runs on (the active one without a repo). */
+export async function setupView(deps: Deps, repo: string | null): Promise<SetupView> {
+  const g = deps.profiles.get(undefined, repo);
+  const p = profileFor(repo, deps.host.host);
+  const issues = deps.profiles.validate(undefined, repo);
+  const catalog = loadCatalog({ repo: repo ?? undefined });
+  const intelligence = (rung: string) => pairOf(catalog, rung)?.intelligence ?? null;
+  return {
+    repo,
+    profile: { name: g.here, active: g.active, profiles: g.profiles },
+    catalog: indexCheck(),
+    backends: await backendChecks(usedBackends([p]), [p]),
+    issues: { errors: issues.errors, warnings: issues.warnings },
+    roles: ROLES.map((role) => {
+      const r = g.profile.roles[role];
+      const offered = new Map<string, IndexedPair>();
+      for (const m of catalogQuery({ role, limit: 1000, repo: repo ?? undefined }, g.profile.billing).models)
+        for (const x of m.rungs) offered.set(x.rung, x);
+      return {
+        role,
+        enabled: r?.enabled ?? false,
+        rungs: (r?.rungs ?? []).map((rung) => ({ rung, intelligence: intelligence(rung) })),
+        offered: [...offered.values()].sort(
+          (a, b) => b.intelligence - a.intelligence || a.rung.localeCompare(b.rung),
+        ),
+      };
+    }),
+  };
+}
+
+/** Unique, rising intelligence with unindexed last; ties keep the previous order, then the pick order. */
+export function orderRungs(
+  rungs: string[],
+  previous: string[],
+  intelligence: (r: string) => number | null,
+): string[] {
+  const at = (list: string[], r: string) => {
+    const i = list.indexOf(r);
+    return i < 0 ? Number.MAX_SAFE_INTEGER : i;
+  };
+  return [...new Set(rungs)].sort(
+    (a, b) =>
+      (intelligence(a) ?? Infinity) - (intelligence(b) ?? Infinity) ||
+      at(previous, a) - at(previous, b) ||
+      at(rungs, a) - at(rungs, b),
+  );
+}
+
+/** Saves a role's rungs, in ladder order, through the profile service (its validation is the gate). */
+export function setRoleRungs(deps: Deps, repo: string | null, role: Role, rungs: string[]): ProfileSaved {
+  const current = deps.profiles.get(undefined, repo).profile.roles[role]?.rungs ?? [];
+  const catalog = loadCatalog({ repo: repo ?? undefined });
+  const ordered = orderRungs(rungs, current, (r) => pairOf(catalog, r)?.intelligence ?? null);
+  return deps.profiles.set(undefined, { roles: { [role]: { rungs: ordered } } }, repo);
+}

package/src/services/pause.ts

@@ -0,0 +1,161 @@
+import { join } from "node:path";
+import { CatherdError } from "../domain/errors.ts";
+import type { Span } from "../domain/util.ts";
+import { dataDir } from "../infra/paths.ts";
+import { appendJsonl, ensureJsonlHeader, readJsonl } from "../infra/store.ts";
+/** What a pause is checked against: a run, or a workspace step about to start one. */
+type Covered = { meta: { workspace?: { id: string; step: string } } };
+import { findWorkspace, workspaceDirectory } from "./workspace-store.ts";
+
+// Spec 1.5 plan 25, "Group pause": one environment blocker (a VPN, Docker down) pauses every run on the
+// machine, or every child of a workspace, at once: admission refuses with the reason until it is resumed.
+
+/** One row per pause or resume, oldest first; `reason` null is a resume. */
+interface PauseRow {
+  at: string;
+  reason: string | null;
+}
+
+/** A pause in force: whose (the machine, or one workspace), why and since when. */
+export interface Pause {
+  scope: "machine" | "workspace";
+  /** the workspace id, for a workspace pause */
+  workspace?: string;
+  reason: string;
+  since: string;
+}
+
+/** A stretch of time something was paused; `to` null while it still is. */
+export interface PauseInterval {
+  from: string;
+  to: string | null;
+}
+
+export const machinePauseFile = (): string => join(dataDir(), "pauses.jsonl");
+export const workspacePauseFile = (id: string): string => join(workspaceDirectory(id), "pauses.jsonl");
+
+const rows = (file: string): PauseRow[] =>
+  readJsonl<PauseRow>(file).rows.filter(
+    (r) => typeof r?.at === "string" && (r.reason === null || typeof r.reason === "string"),
+  );
+
+/** The pause in force in `file`, or null: its last row, when that row pauses. */
+function current(file: string): { reason: string; since: string } | null {
+  const last = rows(file).at(-1);
+  return last && last.reason !== null ? { reason: last.reason, since: last.at } : null;
+}
+
+/** Every paused stretch `file` records, oldest first. */
+export function pauseIntervals(file: string): PauseInterval[] {
+  const out: PauseInterval[] = [];
+  for (const r of rows(file)) {
+    const open = out.at(-1);
+    if (r.reason !== null && (!open || open.to !== null)) out.push({ from: r.at, to: null });
+    else if (r.reason === null && open && open.to === null) open.to = r.at;
+  }
+  return out;
+}
+
+function append(file: string, row: PauseRow): void {
+  ensureJsonlHeader(file, "pauses");
+  appendJsonl(file, row);
+}
+
+const PAUSE_HINT = "push the reason to the owner once (PushNotification); every run it covers waits on it";
+
+/** `catherd pause --machine <reason>`: every dispatch on this machine is refused until resumed. */
+export function pauseMachine(now: number, reason: string): { pause: Pause; hints: string[] } {
+  if (!reason.trim())
+    throw new CatherdError("E_INPUT_INVALID", "a pause needs a reason", {
+      fix: 'catherd pause --machine "the VPN takes the default route"',
+    });
+  const at = new Date(now).toISOString();
+  append(machinePauseFile(), { at, reason });
+  return { pause: { scope: "machine", reason, since: at }, hints: [PAUSE_HINT] };
+}
+
+/** `catherd resume --machine`: lifts the machine pause; the previous one, or null when none was in force. */
+export function resumeMachine(now: number): { resumed: Pause | null } {
+  const was = current(machinePauseFile());
+  if (was) append(machinePauseFile(), { at: new Date(now).toISOString(), reason: null });
+  return { resumed: was ? { scope: "machine", ...was } : null };
+}
+
+/** `workspace_pause(workspace, reason)`: every child of the workspace is refused admission until resumed. */
+export function pauseWorkspace(
+  now: number,
+  i: { workspace: string; reason: string },
+): { pause: Pause; hints: string[] } {
+  const workspace = findWorkspace(i.workspace);
+  if (!i.reason.trim())
+    throw new CatherdError("E_INPUT_INVALID", "a pause needs a reason", {
+      fix: 'workspace_pause(workspace, "the VPN takes the default route")',
+    });
+  const at = new Date(now).toISOString();
+  append(workspacePauseFile(workspace.id), { at, reason: i.reason });
+  return {
+    pause: { scope: "workspace", workspace: workspace.id, reason: i.reason, since: at },
+    hints: [PAUSE_HINT],
+  };
+}
+
+/** `workspace_resume(workspace)`: lifts the workspace's pause; the previous one, or null. */
+export function resumeWorkspace(now: number, i: { workspace: string }): { resumed: Pause | null } {
+  const workspace = findWorkspace(i.workspace);
+  const file = workspacePauseFile(workspace.id);
+  const was = current(file);
+  if (was) append(file, { at: new Date(now).toISOString(), reason: null });
+  return { resumed: was ? { scope: "workspace", workspace: workspace.id, ...was } : null };
+}
+
+/** The pauses in force over `run`: the machine's, then its workspace's. */
+export function pausesFor(run: Covered | null): Pause[] {
+  const out: Pause[] = [];
+  const machine = current(machinePauseFile());
+  if (machine) out.push({ scope: "machine", ...machine });
+  const id = run?.meta.workspace?.id;
+  const ws = id ? current(workspacePauseFile(id)) : null;
+  if (id && ws) out.push({ scope: "workspace", workspace: id, ...ws });
+  return out;
+}
+
+/** Every stretch the machine, or the run's workspace, was paused, in epoch ms: `land` leaves them out. */
+export function pauseSpans(run: Covered): Span[] {
+  const id = run.meta.workspace?.id;
+  const files = [machinePauseFile(), ...(id ? [workspacePauseFile(id)] : [])];
+  return files.flatMap((f) =>
+    pauseIntervals(f).map((p) => ({ from: Date.parse(p.from), to: p.to === null ? null : Date.parse(p.to) })),
+  );
+}
+
+/** The pauses in force over any of `runs`, each once, the machine's first. */
+export function pausesOver(runs: Covered[]): Pause[] {
+  const seen = new Set<string>();
+  const out: Pause[] = [];
+  for (const p of [pausesFor(null), ...runs.map(pausesFor)].flat()) {
+    const key = `${p.scope} ${p.workspace ?? ""}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      out.push(p);
+    }
+  }
+  return out;
+}
+
+const describe = (p: Pause): string =>
+  `${p.scope === "machine" ? "the machine" : `workspace ${p.workspace}`} is paused since ${p.since}: ${p.reason}`;
+
+/** One line per pause, for status and the admission refusal. */
+export const pauseLine = describe;
+
+/** Admission refuses while a pause covers the run, naming its reason and how to lift it. */
+export function assertNotPaused(run: Covered): void {
+  const [p] = pausesFor(run);
+  if (!p) return;
+  throw new CatherdError("E_ADMIT_PAUSED", describe(p), {
+    fix:
+      p.scope === "machine"
+        ? "when the blocker is gone, the owner runs: catherd resume --machine"
+        : `when the blocker is gone, call workspace_resume(${p.workspace})`,
+  });
+}

package/src/services/peek.ts

@@ -49,6 +49,45 @@ export interface PeekRun extends Reentry {
   native: { name: string; role: string; rung: string; status: string; at: string } | null;
   /** the run's next step (state.md's last line) */
   next: string;
+  /** plan 22, goal mode: whether anything in this run is the coordinator's to do now, and why (not) */
+  actionable: boolean;
+  reason: string;
+}
+
+/**
+ * Plan 22, goal mode: whether the run holds anything for the coordinator. An unread record is its to read; with
+ * roles live, a protocol step one of them is doing (lanes running, the reviewer or verifier step with that role
+ * live, the plan while an architect or researcher runs) or the owner's question is nobody's to act on, so the
+ * coordinator ends its turn with no tool call and the next catherd message wakes it.
+ */
+export function actionability(
+  live: { name: string; role: string }[],
+  unread: { name: string }[],
+  protocolNext: string,
+): { actionable: boolean; reason: string } {
+  if (unread.length)
+    return {
+      actionable: true,
+      reason: `unread: ${unread.map((u) => `result(run, "${u.name}")`).join(", ")}`,
+    };
+  if (protocolNext.endsWith(" parked: wait for the owner"))
+    return {
+      actionable: false,
+      reason: `${protocolNext.replace(/: wait for the owner$/, "")}: the owner's answer comes first; end the turn with no tool call`,
+    };
+  const running = (role: string) => live.some((l) => l.role === role);
+  const covered =
+    /: lanes running \(/.test(protocolNext) ||
+    (protocolNext.endsWith(": reviewer") && running("reviewer")) ||
+    (protocolNext.endsWith(": verifier") && running("verifier")) ||
+    (protocolNext.startsWith("plan:") && (running("architect") || running("researcher"))) ||
+    (protocolNext.startsWith("finish:") && (running("verifier") || running("writer")));
+  if (live.length && covered)
+    return {
+      actionable: false,
+      reason: `only roles are live (${live.map((l) => l.name).join(", ")}): their results arrive as catherd messages; end the turn with no tool call`,
+    };
+  return { actionable: true, reason: protocolNext };
 }
 
 function peekRun(deps: Deps, run: Run, name: string | undefined): PeekRun {
@@ -57,23 +96,31 @@ function peekRun(deps: Deps, run: Run, name: string | undefined): PeekRun {
   const records = new Map(readRecords(run).records.map((r) => [r.dispatchId, r]));
   const agents = readAgentRuns(run).filter((a) => name === undefined || a.name === name);
   const native = agents.at(-1);
-  const r = reentry(run, now);
+  const notes = readNotes(run);
+  const re = reentry(run, now, notes);
+  const live = liveDispatches(run, now);
+  // the whole run decides it, whatever `name` narrows the view to
+  const act = actionability(
+    live.map((d) => ({ name: d.admit.name, role: d.admit.role })),
+    listDispatches(run).flatMap((d) =>
+      records.has(d.admit.dispatchId) && awaitsCollect(d.dir) ? [{ name: d.admit.name }] : [],
+    ),
+    re.protocol.next,
+  );
   return {
-    questions: r.questions,
+    questions: re.questions,
     run: run.id,
     title: run.meta.title,
     owner: runOwner(run)?.sessionId ?? null,
     ownerHost: runOwner(run)?.host ?? null,
-    live: liveDispatches(run, now)
-      .filter(mine)
-      .map((d) => ({
-        name: d.admit.name,
-        role: d.admit.role,
-        rung: d.admit.rung,
-        state: d.state,
-        secs: Math.max(0, Math.round((now - Date.parse(d.admit.admittedAt)) / 1000)),
-        lastEvent: lastActivity(d),
-      })),
+    live: live.filter(mine).map((d) => ({
+      name: d.admit.name,
+      role: d.admit.role,
+      rung: d.admit.rung,
+      state: d.state,
+      secs: Math.max(0, Math.round((now - Date.parse(d.admit.admittedAt)) / 1000)),
+      lastEvent: lastActivity(d),
+    })),
     delivery: listDispatches(run)
       .filter(mine)
       .flatMap((d) =>
@@ -103,9 +150,10 @@ function peekRun(deps: Deps, run: Run, name: string | undefined): PeekRun {
     native: native
       ? { name: native.name, role: native.role, rung: native.rung, status: native.status, at: native.at }
       : null,
-    next: readNotes(run).next,
-    protocol: r.protocol,
-    verifier: r.verifier,
+    next: notes.next,
+    protocol: re.protocol,
+    verifier: re.verifier,
+    ...act,
   };
 }
 
@@ -117,7 +165,15 @@ function peekRun(deps: Deps, run: Run, name: string | undefined): PeekRun {
 export async function peek(
   deps: Deps,
   i: { run?: string; name?: string },
-): Promise<{ runs: PeekRun[]; hints: string[]; host: HostContext; queue: QueueCapability | null }> {
+): Promise<{
+  /** plan 22, goal mode: false when no run holds anything for the coordinator; `reason` says why either way */
+  actionable: boolean;
+  reason: string;
+  runs: PeekRun[];
+  hints: string[];
+  host: HostContext;
+  queue: QueueCapability | null;
+}> {
   if (i.name !== undefined) assertId("role name", i.name);
   let runs: Run[];
   if (i.run) {
@@ -131,8 +187,14 @@ export async function peek(
     runs = owned.length ? owned : all.slice(0, 1);
   }
   const hints = runs.length === 0 ? ["no runs yet: run_start(repo, title, a_lines) starts one"] : [];
+  const views = runs.map((r) => peekRun(deps, r, i.name));
+  const doing = views.filter((v) => v.actionable);
+  const shown = (vs: PeekRun[]) =>
+    vs.map((v) => (views.length > 1 ? `${v.title}: ${v.reason}` : v.reason)).join("; ");
   return {
-    runs: runs.map((r) => peekRun(deps, r, i.name)),
+    actionable: views.length === 0 || doing.length > 0,
+    reason: views.length === 0 ? "no runs yet" : shown(doing.length ? doing : views),
+    runs: views,
     hints,
     host: inspectionHost(deps.host),
     queue: deps.host.host === "codex" && !deps.host.conflict ? knownQueueCapability(process.env) : null,

package/src/services/plan-input.ts

@@ -0,0 +1,151 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { CatherdError } from "../domain/errors.ts";
+import { parseLaneHeader } from "../domain/lane.ts";
+import {
+  coverageProblems,
+  depthProblems,
+  type PlanDoc,
+  type PlanTask,
+  parsePlanDoc,
+  planInputNames,
+  resolveTask,
+} from "../domain/plan-doc.ts";
+import type { Role } from "../domain/roles.ts";
+import { writeTextAtomic } from "../infra/store.ts";
+import { isDaemonRun, replayRun } from "./run-events-store.ts";
+import { type Run, runPaths } from "./run-store.ts";
+
+/** The run's copies of the owner's plan files: isolated roles read these, never the originals (plan 32). */
+export const PLAN_INPUT_DIR = "plan-input";
+/** Past this many characters of preambles, a role's `<context>` names the copies instead of repeating them. */
+export const PLAN_CONTEXT_MAX = 100_000;
+
+const invalid = (message: string, fix: string) => new CatherdError("E_INPUT_INVALID", message, { fix });
+
+/** The absolute, deduped plan paths of a `run_start`; a relative one resolves against the repo. */
+export function resolvePlanInputs(repo: string, paths: string[]): string[] {
+  const out: string[] = [];
+  for (const p of paths) {
+    const abs = isAbsolute(p) ? p : resolve(repo, p);
+    if (out.includes(abs)) continue;
+    if (!existsSync(abs))
+      throw invalid(`plan file ${abs} does not exist`, "pass the path of the reviewed plan file");
+    if (!statSync(abs).isFile())
+      throw invalid(`plan ${abs} is not a file`, "pass the path of the reviewed plan file");
+    out.push(abs);
+  }
+  if (out.length > 0 && !out.some((f) => parsePlanDoc(f, readFileSync(f, "utf8")).tasks.length > 0))
+    throw invalid(
+      `none of the plan files has a "### Task <n>:" heading: ${out.join(", ")}`,
+      "pass the reviewed plan, or no plan and the architect writes one",
+    );
+  return out;
+}
+
+/** The paths of an A-line `plan: a, b` (the label in any case). */
+export function planInputPaths(aLines: string[]): string[] {
+  return aLines.flatMap((l) =>
+    (/^\s*plan:\s*(.*?)\s*$/i.exec(l)?.[1] ?? "")
+      .split(",")
+      .map((p) => p.trim())
+      .filter(Boolean),
+  );
+}
+
+/** `<run>/plan-input/<name>`, 0600, for each path; a file that has vanished since keeps its earlier copy. */
+export function copyPlanInputs(run: Run, paths: string[]): void {
+  const names = planInputNames(paths);
+  for (const [i, p] of paths.entries())
+    if (existsSync(p))
+      writeTextAtomic(join(run.dir, PLAN_INPUT_DIR, names[i] as string), readFileSync(p, "utf8"));
+}
+
+const read = (file: string): string | null => {
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+};
+
+/** The plan files a role can read, by their path in the run folder: the copies, else plan.md. */
+function planFiles(run: Run): { path: string; doc: PlanDoc }[] {
+  const plan = replayRun(run).plan;
+  const files = plan.length
+    ? planInputNames(plan).map((n) => ({ path: `${PLAN_INPUT_DIR}/${n}`, name: n }))
+    : [{ path: "plan.md", name: "plan.md" }];
+  return files.flatMap((f) => {
+    const text = read(join(run.dir, f.path));
+    return text === null ? [] : [{ path: f.path, doc: parsePlanDoc(f.name, text) }];
+  });
+}
+
+/** The run's plan as documents: the copies in `run.started.plan` order; else plan.md; none when neither exists. */
+export const planDocs = (run: Run): PlanDoc[] => planFiles(run).map((f) => f.doc);
+
+/** Each plan file's preamble, which applies to every task, for every role but the architect and the judge. */
+export function planContext(run: Run, role: Role): string | null {
+  if (role === "architect" || role === "judge" || !isDaemonRun(run)) return null;
+  const files = planFiles(run);
+  const parts = files.flatMap(({ doc }) => {
+    if (doc.tasks.length === 0)
+      return [`The plan file ${doc.name}, which every task follows:\n\n${doc.text.trim()}`];
+    const pre = doc.preamble.trim();
+    return pre ? [`The plan's preamble (${doc.name}), which applies to every task:\n\n${pre}`] : [];
+  });
+  if (parts.length === 0) return null;
+  const text = parts.join("\n\n");
+  return text.length > PLAN_CONTEXT_MAX
+    ? `The run's plan files are too long to repeat here; read them before you start, with read_run_file: ${files.map((f) => f.path).join(", ")}`
+    : text;
+}
+
+const natural = (a: string, b: string): number => a.localeCompare(b, "en", { numeric: true });
+
+/** Every lane file's id, in lane order. */
+function laneIds(run: Run): string[] {
+  const dir = runPaths(run.dir).lanes;
+  return (existsSync(dir) ? readdirSync(dir) : [])
+    .filter((f) => f.endsWith(".md"))
+    .map((f) => f.slice(0, -3))
+    .sort(natural);
+}
+
+const laneRefs = (run: Run, lane: string): string[] =>
+  parseLaneHeader(read(join(runPaths(run.dir).lanes, `${lane}.md`)) ?? "").tasks;
+
+/** The plan tasks a lane's `Tasks:` line names; a ref that resolves to none is left out (planProblems names it). */
+export function laneTasks(run: Run, lane: string): PlanTask[] {
+  const docs = planDocs(run);
+  return laneRefs(run, lane).flatMap((ref) => {
+    const t = resolveTask(docs, ref);
+    return typeof t === "string" ? [] : [t];
+  });
+}
+
+/** A milestone's tasks: those of its lanes in lane order, each once. */
+export function milestoneTasks(run: Run, milestone: string): PlanTask[] {
+  const seen = new Map<string, PlanTask>();
+  for (const id of laneIds(run).filter((l) => l.startsWith(`${milestone}.`)))
+    for (const t of laneTasks(run, id)) seen.set(`${t.doc}#${t.id}`, t);
+  return [...seen.values()];
+}
+
+/**
+ * What the architect can fix: a lane that names no task or a missing one, and with no plan input plan.md's depth.
+ * A task of the owner's plan with neither a signature nor a test is the owner's, and preflight refuses it.
+ */
+export function planProblems(run: Run): string[] {
+  const docs = planDocs(run);
+  const lanes = laneIds(run).map((id) => ({ id, tasks: laneRefs(run, id) }));
+  const out = coverageProblems(docs, lanes)
+    .filter((p) => p.lane !== "")
+    .map((p) => p.note);
+  if (replayRun(run).plan.length === 0) out.push(...depthProblems(docs[0] ?? parsePlanDoc("plan.md", "")));
+  return out;
+}
+
+/** A plan task as a brief carries it: verbatim, in a tag naming its file and number. */
+export const taskBlock = (t: PlanTask): string =>
+  `<plan-task file="${t.doc}" id="${t.id}">\n${t.text.trimEnd()}\n</plan-task>`;