catherd-cli 1.5.0 → 2.0.0-beta.20261022113309

package/src/services/milestones.ts

@@ -97,6 +97,10 @@ export function partialReviewer(
   return last ? { name: last.name, at: last.at, record: last.record } : null;
 }
 
+/** Plan 28: the milestone's full reviewer passes since its lanes started (a partial pass is not a round). */
+export const reviewRounds = (run: Run, m: string): number =>
+  reviewerAttempts(run, m, milestoneStart(run, m)).filter((a) => !a.partial).length;
+
 export const FINDING = /^\s*(?:[-*]\s*)?(BLOCKER|BUG|NIT)\b/;
 
 /** A reviewer reply's findings by severity; null when there is no reply to read. */
@@ -185,6 +189,8 @@ export interface MilestoneVerifier {
   verdict: string;
   /** plan 23: the probe of a `VERDICT: BLOCKED: environment` attempt ("" when it named none); null otherwise */
   blocked: string | null;
+  /** plan 30b: the commit the verdict says it checked (a headless reply's `HEAD:` line); null for a native row */
+  head: string | null;
 }
 
 /** The one name a milestone's verifier is counted under (spec 1.5 "The ledger"): verifier-<m>, exactly. */
@@ -216,6 +222,7 @@ export function milestoneVerifier(
           passed: a.status === "ok",
           verdict: blocked === null ? a.status : (a.verdict ?? a.status),
           blocked,
+          head: null,
         };
       }),
     ...readRecords(run)
@@ -231,6 +238,7 @@ export function milestoneVerifier(
           passed,
           verdict: r.status === "ok" ? said : `${r.status}, ${said}`,
           blocked: r.status === "ok" ? blockedByEnvironment(first) : null,
+          head: r.head ?? null,
         };
       }),
   ];
@@ -250,6 +258,16 @@ export function landedCommits(run: Run): string[] {
     .filter((c) => /^[0-9a-f]{7,40}$/.test(c));
 }
 
+/** The commit the ledger holds for `m`, its latest landing; null when it never landed or the row has no commit. */
+export function landedCommitOf(run: Run, m: string): string | null {
+  const rows = nonBlankLines(runPaths(run.dir).ledger)
+    .slice(1)
+    .map((row) => row.split(" | "))
+    .filter((cells) => cells[0]?.trim() === m);
+  const commit = rows.at(-1)?.[2]?.trim() ?? "";
+  return /^[0-9a-f]{7,40}$/.test(commit) ? commit : null;
+}
+
 /** The milestones the ledger holds, in landing order. */
 export function landedMilestones(run: Run): string[] {
   return nonBlankLines(runPaths(run.dir).ledger)
@@ -258,20 +276,29 @@ export function landedMilestones(run: Run): string[] {
     .filter(Boolean);
 }
 
-/**
- * The files the milestone's commit range changed: from the previous landed commit, else the HEAD the run
- * started on (meta.json `startHead`, when that commit is still there), else the commit's own parent, to
- * `commit`. Throws E_IO_UNEXPECTED when git cannot say.
- */
-export async function milestoneFiles(run: Run, commit: string): Promise<string[]> {
+/** The 1.5 range: see milestoneFiles. */
+async function oneFiveFiles(run: Run, commit: string): ReturnType<typeof git> {
   const repo = run.meta.repo;
   const start = run.meta.startHead;
   const base =
     landedCommits(run).at(-1) ??
     (start && (await commitExists(repo, start).catch(() => false)) ? start : undefined);
-  const r = base
+  return base
     ? await git(repo, ["diff", "--name-only", base, commit])
     : await git(repo, ["show", "--name-only", "--format=", "--first-parent", commit]);
+}
+
+/**
+ * The files the milestone's commit range changed: from the previous landed commit, else the HEAD the run
+ * started on (meta.json `startHead`, when that commit is still there), else the commit's own parent, to
+ * `commit`. A base run's milestone is its branch since origin's base (plan 35). Throws E_IO_UNEXPECTED when git cannot say.
+ */
+export async function milestoneFiles(run: Run, commit: string): Promise<string[]> {
+  const repo = run.meta.repo;
+  const r = run.meta.base
+    ? // plan 35: a base run's milestone is its branch since origin's base; three dots, since other milestones land on the base meanwhile
+      await git(repo, ["diff", "--name-only", `origin/${run.meta.base}...${commit}`])
+    : await oneFiveFiles(run, commit);
   if (r.kind !== "ok")
     throw new CatherdError("E_IO_UNEXPECTED", `git could not list the files ${commit} changed`, {
       fix: `check that git works in ${repo}`,
@@ -287,7 +314,7 @@ const DIGEST_COMMITS = 20;
  * (else the commit alone) to `commit`. Just the hash when git cannot say: a digest never fails a landing.
  */
 export async function milestoneCommits(run: Run, commit: string): Promise<string[]> {
-  const base = landedCommits(run).at(-1);
+  const base = run.meta.base ? `origin/${run.meta.base}` : landedCommits(run).at(-1);
   const range = base ? [`${base}..${commit}`] : ["-1", commit];
   const r = await git(run.meta.repo, ["log", "--reverse", "--format=%h %s", ...range]);
   if (r.kind !== "ok") return [commit.slice(0, 7)];

package/src/services/notifier.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { adapterFor } from "../adapters/registry.ts";
 import "../adapters/all.ts";
@@ -14,11 +14,12 @@ import {
   type DeliveryAttempt,
 } from "../infra/delivery.ts";
 import type { RunRecord } from "../domain/record.ts";
+import type { RunEvent } from "../domain/run-events.ts";
 import { awaitsCollect, dispatchPaths } from "../infra/dispatch-dir.ts";
 import { tryLock } from "../infra/filelock.ts";
 import { log } from "../infra/log.ts";
 import { type SendResult, sendToInbox } from "../infra/peer-inbox.ts";
-import { nonBlankLines, writeJsonAtomic } from "../infra/store.ts";
+import { ensurePrivateDir, nonBlankLines, writeJsonAtomic } from "../infra/store.ts";
 import {
   readStallQuietMs,
   type Settled,
@@ -28,6 +29,7 @@ import {
 } from "./dispatch-service.ts";
 import { type Dispatch, listDispatches, readFailover, roleThreadOf } from "./dispatches.ts";
 import type { Deps } from "./ports.ts";
+import { eventsFile, isDaemonRun, readEvents } from "./run-events-store.ts";
 import { listRuns, readRecords, type Run } from "./run-store.ts";
 import { currentSession, ownsRun, readSessionRows, runOwner } from "./sessions.ts";
 
@@ -35,6 +37,8 @@ export interface NotifierOptions {
   /** notices this close to each other go as one message (spec: 3 s); tests shorten it */
   coalesceMs?: number;
   sendCodex?: (target: HostSessionRef, content: string) => Promise<QueueSendResult>;
+  /** how often the reports of the session's 2.0 runs are looked for between scans; 0 (the default) never */
+  reportPollMs?: number;
   /** the sender; tests may replace it */
   send?: (
     target: { socketPath: string | null; token: string | null },
@@ -134,6 +138,28 @@ export function finishedNotice(run: Run, d: Dispatch, r: RunRecord): Notice {
   };
 }
 
+/** One report of a 2.0 run, as the session is told of it: the unit, what kind it is, its text. */
+export function reportNotice(run: Run, e: Extract<RunEvent, { type: "report.posted" }>): Notice {
+  return {
+    kind: "report",
+    eventId: JSON.stringify([run.id, `report-${e.seq}`, "report"]),
+    runId: run.id,
+    runTitle: run.meta.title,
+    dispatchId: `report-${e.seq}`,
+    name: e.unit,
+    role: "run",
+    lane: null,
+    thread: null,
+    rung: "",
+    status: e.kind,
+    replyStatus: null,
+    secs: 0,
+    changedOwned: 0,
+    reply: e.text,
+    priority: e.kind === "parked" || e.kind === "failed" ? "next" : "later",
+  };
+}
+
 /** A live fresh role's thread, as its CLI named it early in its stream; null before it did. */
 function streamThread(d: Dispatch): string | null {
   const a = adapterFor(d.admit.backend);
@@ -483,7 +509,35 @@ function notifierFor(deps: Deps, o: NotifierOptions, retryEvent?: string): Notif
     }
   };
 
+  /** The reports of a 2.0 run this session owns: queued once each, under `<run>/reports/<seq>/`. */
+  const reportSizes = new Map<string, number>();
+  const enqueueReports = (run: Run, force: boolean): void => {
+    const size = statSync(eventsFile(run)).size;
+    if (!force && reportSizes.get(run.id) === size) return;
+    reportSizes.set(run.id, size);
+    for (const e of readEvents(run)) {
+      if (e.type !== "report.posted") continue;
+      const dir = join(run.dir, "reports", String(e.seq));
+      ensurePrivateDir(dir);
+      const notice = reportNotice(run, e);
+      queueNotice({ key: notice.eventId, run, dir, notice, mark: join(dir, "notified"), due: () => true });
+    }
+  };
+
+  const scanReports = (force: boolean): void => {
+    if (stopped || !currentSession(deps)) return;
+    for (const run of listRuns().runs) {
+      try {
+        if (isDaemonRun(run) && owned(run)) enqueueReports(run, force);
+      } catch (e) {
+        log("warn", "notify", { run: run.id, error: errorMessage(e) });
+      }
+    }
+  };
+
   const onSettled = (s: Settled): void => {
+    // the run's reports tell the session of a 2.0 run, not each role's finish
+    if (isDaemonRun(s.run)) return;
     try {
       enqueue(s.run, s.d, s.record);
     } catch (e) {
@@ -499,6 +553,10 @@ function notifierFor(deps: Deps, o: NotifierOptions, retryEvent?: string): Notif
       for (const run of listRuns().runs) {
         try {
           if (!owned(run)) continue;
+          if (isDaemonRun(run)) {
+            enqueueReports(run, true);
+            continue;
+          }
           const records = new Map(readRecords(run).records.map((r) => [r.dispatchId, r]));
           for (const d of listDispatches(run)) {
             // one dispatch's damaged evidence stays ambiguous for it alone: the rest of the run is still scanned
@@ -552,6 +610,15 @@ function notifierFor(deps: Deps, o: NotifierOptions, retryEvent?: string): Notif
     settledHooks.add(onSettled);
     stallHooks.add(onStall);
   }
+  if (!retryEvent && o.reportPollMs) {
+    const poll = setInterval(() => scanReports(false), o.reportPollMs);
+    poll.unref();
+    const stopRest = n.stop;
+    n.stop = () => {
+      clearInterval(poll);
+      stopRest();
+    };
+  }
   return n;
 }
 

package/src/services/notify-service.ts

@@ -0,0 +1,26 @@
+import { notifyMessage } from "../domain/notify.ts";
+import type { NotifyMoment } from "../domain/profile.ts";
+import { postNotify } from "../infra/ntfy.ts";
+import type { Deps } from "./ports.ts";
+import { runProfile } from "./run-pin.ts";
+import type { Run } from "./run-store.ts";
+
+/**
+ * Tells the owner's phone about a moment of a run, when the run's profile lists that moment. False when it is
+ * not listed, or the message did not go out; it never throws.
+ */
+export async function sendRunNotice(
+  deps: Deps,
+  run: Run,
+  i: { unit: string; moment: NotifyMoment },
+  o: { fetch?: typeof fetch; timeoutMs?: number } = {},
+): Promise<boolean> {
+  if (!runProfile(deps, run).notify.includes(i.moment)) return false;
+  // CATHERD_NO_END_PUSH=1 (the test preload sets it) keeps every real send off; a test's own fetch still goes
+  if (process.env.CATHERD_NO_END_PUSH === "1" && !o.fetch) return false;
+  return postNotify(
+    deps.profiles.notifyUrl(),
+    notifyMessage({ runId: run.id, runTitle: run.meta.title, unit: i.unit, moment: i.moment }),
+    o,
+  );
+}

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/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>`;

package/src/services/ports.ts

@@ -1,5 +1,7 @@
+import type { BlockedReason } from "../domain/blocked.ts";
 import type { HostContext } from "../domain/host.ts";
 import type { Provenance } from "./provenance.ts";
+import type { Bars } from "../domain/bars.ts";
 import type { Budget } from "../domain/budget.ts";
 import type { SessionEnv } from "../infra/claude-session.ts";
 import type { BillingMode } from "../domain/cost.ts";
@@ -11,7 +13,8 @@ import type { RoleScope } from "../domain/role-scope.ts";
 import type { Change, ProfileDoc, ProfilePatch } from "../domain/profile.ts";
 import type { Issue } from "../domain/profile-rules.ts";
 import type { RouteJev, RouteSource } from "../domain/route.ts";
-import type { SyncReport } from "./source-sync.ts";
+import type { IndexFile } from "../domain/slopalytics.ts";
+import type { IndexStatus } from "./catalog-service.ts";
 
 /** What the run lifecycle reads from a profile. Rungs are `backend:model#effort`; a role's in ladder order. */
 export interface ProfileView {
@@ -29,6 +32,8 @@ export interface ProfileView {
         network?: false;
         /** plan 23: the role's own timeouts over the profile's */
         timeouts?: { idleMin?: number; wallMin?: number };
+        /** plan 33: the role's own bar percentiles over the profile's */
+        bars?: Bars;
       }
     >
   >;
@@ -39,11 +44,17 @@ export interface ProfileView {
   isolated: Partial<Record<string, boolean>>;
   /** rung → its stand-in on a usage limit (spec §4.5) */
   failover: Record<string, string>;
+  /** `<backend>:<model>` → the highest effort routing starts it at (plan 33) */
+  maxEffort?: Record<string, string>;
+  /** plan 33: bar percentiles per difficulty (0 to 100) over the shipped ones */
+  bars?: Bars;
   budget: Budget;
   timeouts: { idleMin: number; wallMin: number };
   preflight: { confirm: boolean };
   heavy: number | "cpus/2";
   notify: string[];
+  /** plan 35: the memory numbers that cap milestones side by side, defaults filled */
+  limits: { memory: { reserveMb: number; perMilestoneMb: number; floorMb: number } };
 }
 
 /** What a profile write returns (spec §7.3): whether it saved, why not, what changed, and the agents it touched. */
@@ -82,6 +93,10 @@ export interface ProfilePort {
   set(name: string | undefined, patch: ProfilePatch, repo?: string | null): ProfileSaved;
   /** The native agent that runs `rung` for `role` under `repo`'s profile; null unless it is a `claude:` rung. */
   agentFor(repo: string | null, role: Role, rung: string): string | null;
+  /** The ntfy topic url of the phone messages: config's `notify.url`, a random ntfy.sh topic made once. */
+  notifyUrl(): string;
+  /** Replaces it; an http(s) url only. */
+  setNotifyUrl(url: string): void;
 }
 
 export interface RouteRequest {
@@ -125,7 +140,6 @@ export interface CatalogFilter {
   role?: Role;
   backend?: string;
   text?: string;
-  scoredOnly: boolean;
   limit: number;
   /** the git toplevel whose per-repository listings (opencode's) to read; none reads the global ones */
   repo?: string;
@@ -148,6 +162,18 @@ export interface RoutingPort {
     after: string,
     use: "auto" | "off",
   ): Promise<Verdict<"yes" | "no">>;
+  /** plan 30b: why a role stopped that gave no reason; `other` and an unsure answer are the rule's fallback */
+  stopCause(
+    runDir: string,
+    status: string,
+    reply: string,
+    use: "auto" | "off",
+  ): Promise<Verdict<BlockedReason | "other">>;
+  /**
+   * A run's start check: refreshes the index if it is due, reads it once, and names the enabled roles of `view`
+   * that no indexed pair can fill; `index` is what the run pins (null when there is none).
+   */
+  checkStart(view: ProfileView, repo: string): Promise<{ unusable: Role[]; index: IndexFile | null }>;
   /** `billing` prices the rungs (spec §5.3); absent keys bill as DEFAULT_BILLING */
   catalog(
     filter: CatalogFilter,
@@ -166,8 +192,8 @@ export interface Deps {
   /** Claude transport credentials and registry refresh; host identity lives in `host`. */
   session: SessionEnv | null;
   now: () => number;
-  /** spec 1.2 §3.2 `catalog_sync`; default: the real sync (tests inject one that never reaches the network) */
-  sync?: (o: { force: boolean; wait?: boolean }) => Promise<SyncReport>;
+  /** `catalog_sync`; default: the real refresh (tests inject one that never reaches the network) */
+  sync?: (o: { force: boolean }) => Promise<IndexStatus>;
   /**
    * Spec 1.5 plan 21: the role this process works for (CATHERD_ROLE, or a role's scratch TMPDIR); null or
    * absent for the orchestrator's own server. A role never claims a run and never reaches a coordinator tool.