catherd-cli 1.2.1 → 1.4.0

package/src/services/run-store.ts

@@ -5,7 +5,7 @@ import { CatherdError } from "../domain/errors.ts";
 import { assertId } from "../domain/ids.ts";
 import { type RunRecord, RunRecordSchema } from "../domain/record.ts";
 import type { OutcomeRow, RouteRow } from "../domain/route.ts";
-import { slug } from "../domain/util.ts";
+import { cell, slug } from "../domain/util.ts";
 import { withFileLock } from "../infra/filelock.ts";
 import { dataDir, repoDir, runsDir } from "../infra/paths.ts";
 import {
@@ -21,7 +21,8 @@ import {
 } from "../infra/store.ts";
 
 /** Spec §3.3: the Claude Code session that started a run; absent on 1.0 runs and outside Claude Code. */
-const StartedBySchema = z.object({
+const StartedBySchema = z.looseObject({
+  host: z.enum(["claude-code", "codex"]).default("claude-code"),
   sessionId: z.string(),
   hostSessionId: z.string().nullable(),
   name: z.string().nullable(),
@@ -82,7 +83,12 @@ export function createRun(o: {
   aLines: string[];
   version: string;
   now?: Date;
-  startedBy?: StartedBy | null;
+  startedBy?: {
+    host?: StartedBy["host"];
+    sessionId: string;
+    hostSessionId: string | null;
+    name: string | null;
+  } | null;
 }): Run {
   const now = o.now ?? new Date();
   const root = runsDir(o.repo);
@@ -123,7 +129,7 @@ export function createRun(o: {
     aLines: o.aLines,
     createdAt: now.toISOString(),
     catherdVersion: o.version,
-    ...(o.startedBy ? { startedBy: o.startedBy } : {}),
+    ...(o.startedBy ? { startedBy: StartedBySchema.parse(o.startedBy) } : {}),
   };
   writeJsonAtomic(p.meta, meta);
   return { id, dir, meta };
@@ -196,7 +202,7 @@ export function readRecords(run: Run): { records: RunRecord[]; corrupt: number }
     if (!r.success) bad++;
     else if (!seen.has(r.data.dispatchId)) {
       seen.add(r.data.dispatchId);
-      records.push(r.data);
+      records.push(r.data.sessionId && !r.data.host ? { ...r.data, host: "claude-code" } : r.data);
     }
   }
   return { records, corrupt: bad };
@@ -273,6 +279,16 @@ export function appendLedger(run: Run, row: string): void {
 /** Spec §4.7: what past runs of a repo learned, keyed by its git toplevel. */
 export const knowledgeFile = (toplevel: string): string => join(repoDir(toplevel), "knowledge.md");
 
+/**
+ * Appends one line to the repo's knowledge.md, `- <date> <source>: <text>` with `text` on one line, and returns
+ * it. The single writer of knowledge.md: `land`'s `learned` and `catherd knowledge add` both come through here.
+ */
+export function appendKnowledge(toplevel: string, at: Date, source: string, text: string): string {
+  const line = `- ${at.toISOString().slice(0, 10)} ${source}: ${cell(text)}`;
+  appendPrivate(knowledgeFile(toplevel), `${line}\n`);
+  return line;
+}
+
 const SERVER_OWNED = new Set([
   "meta.json",
   "state.md",

package/src/services/runs-page.ts

@@ -1,3 +1,4 @@
+import { sessionKey } from "../domain/host.ts";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { budgetStatus } from "../domain/budget.ts";
@@ -98,7 +99,7 @@ export interface MilestoneDetail {
   digest: string | null;
 }
 
-const keyOf = (g: SessionGroup): string | null => g.session?.sessionId ?? null;
+const keyOf = (g: SessionGroup): string | null => (g.session ? sessionKey(g.session) : null);
 
 /** The runs that live on in a session now (it owns them): each run's live roles and landings count once. */
 const ownRuns = (g: SessionGroup): Run[] => g.runs.filter((x) => x.current).map((x) => x.run);
@@ -174,7 +175,7 @@ function sessionRun(deps: Deps, x: SessionGroup["runs"][number]): SessionRun {
   try {
     const b = budgetStatus(
       spendOf(run, readRecords(run).records, liveDispatches(run, deps.now()), deps.now()),
-      deps.profiles.forRepo(run.meta.repo).budget,
+      deps.profiles.budgetFor?.(run.meta.repo) ?? deps.profiles.forRepo(run.meta.repo).budget,
     );
     budget = b?.fraction ?? null;
   } catch {

package/src/services/session-view.ts

@@ -1,3 +1,4 @@
+import { sessionKey, type KnownHost } from "../domain/host.ts";
 import { statSync } from "node:fs";
 import { liveSessionFile, readSessionFiles, type SessionFile } from "../infra/claude-session.ts";
 import { type Run, runPaths } from "./run-store.ts";
@@ -14,6 +15,7 @@ import { readSessionRows } from "./sessions.ts";
 
 /** A session as the runs page shows it: its name read live while it runs, else the last one recorded. */
 export interface RunSession {
+  host: KnownHost;
   sessionId: string;
   hostSessionId: string | null;
   name: string;
@@ -56,10 +58,11 @@ export function runActivity(run: Run): number {
 /** The sessions each run has had, oldest first: its starter, then each one that took it over. */
 function trailOf(
   run: Run,
-): { sessionId: string; hostSessionId: string | null; name: string | null; at: string }[] {
+): { host: KnownHost; sessionId: string; hostSessionId: string | null; name: string | null; at: string }[] {
   const rows = readSessionRows(run);
   const s = run.meta.startedBy;
-  if (s && !rows.some((r) => r.sessionId === s.sessionId)) return [{ ...s, at: run.meta.createdAt }, ...rows];
+  if (s && !rows.some((r) => sessionKey(r) === sessionKey(s)))
+    return [{ ...s, at: run.meta.createdAt }, ...rows];
   return rows;
 }
 
@@ -70,21 +73,23 @@ export function groupRuns(runs: Run[], files: SessionFile[] = readSessionFiles()
   const trails = new Map(runs.map((r) => [r.id, trailOf(r)]));
   for (const t of trails.values())
     for (const row of t) {
-      const was = recorded.get(row.sessionId);
+      const was = recorded.get(sessionKey(row));
       if (!was || row.at >= was.at)
-        recorded.set(row.sessionId, {
+        recorded.set(sessionKey(row), {
           name: row.name ?? was?.name ?? null,
           host: row.hostSessionId ?? was?.host ?? null,
           at: row.at,
         });
     }
   const sessionOf = (id: string): RunSession => {
-    const live = liveSessionFile(id, files);
+    const [host, sessionId] = JSON.parse(id) as [KnownHost, string];
+    const live = host === "claude-code" ? liveSessionFile(sessionId, files) : null;
     const rec = recorded.get(id);
     return {
-      sessionId: id,
+      host,
+      sessionId,
       hostSessionId: live?.hostSessionId ?? rec?.host ?? null,
-      name: live?.name ?? rec?.name ?? `session ${id.slice(0, 8)}`,
+      name: live?.name ?? rec?.name ?? `session ${sessionId.slice(0, 8)}`,
       live: live !== null,
     };
   };
@@ -101,13 +106,13 @@ export function groupRuns(runs: Run[], files: SessionFile[] = readSessionFiles()
   for (const run of runs) {
     const at = runActivity(run);
     const trail = trails.get(run.id) ?? [];
-    const starter = run.meta.startedBy?.sessionId ?? null;
+    const starter = run.meta.startedBy ? sessionKey(run.meta.startedBy) : null;
     // the run lives on in its current owner: the last session that took it (a run can come back to its starter)
-    const owner = trail.at(-1)?.sessionId ?? starter;
+    const owner = trail.at(-1) ? sessionKey(trail.at(-1)!) : starter;
     const moved = owner !== starter && owner !== null;
     // a run that lives on elsewhere counts, in a session it left, from when that session last took it
     const tookAt = (id: string | null): number =>
-      Date.parse(trail.findLast((t) => t.sessionId === id)?.at ?? run.meta.createdAt) || 0;
+      Date.parse(trail.findLast((t) => sessionKey(t) === id)?.at ?? run.meta.createdAt) || 0;
     add(
       starter,
       {
@@ -118,7 +123,7 @@ export function groupRuns(runs: Run[], files: SessionFile[] = readSessionFiles()
       },
       moved ? tookAt(starter) : at,
     );
-    for (const id of new Set(trail.map((t) => t.sessionId)))
+    for (const id of new Set(trail.map(sessionKey)))
       if (id !== starter)
         add(
           id,
@@ -146,7 +151,7 @@ export function sessionFacts(
   run: Run,
   files: SessionFile[] = readSessionFiles(),
 ): { session: RunSession | null; continuedIn: string | null } {
-  const starter = run.meta.startedBy?.sessionId ?? null;
-  const own = groupRuns([run], files).find((g) => (g.session?.sessionId ?? null) === starter);
+  const starter = run.meta.startedBy ? sessionKey(run.meta.startedBy) : null;
+  const own = groupRuns([run], files).find((g) => (g.session ? sessionKey(g.session) : null) === starter);
   return { session: own?.session ?? null, continuedIn: own?.runs[0]?.continuedIn ?? null };
 }

package/src/services/sessions.ts

@@ -1,3 +1,4 @@
+import { sessionKey, type HostSessionRef } from "../domain/host.ts";
 import { z } from "zod";
 import { sessionFileFor } from "../infra/claude-session.ts";
 import { withFileLock } from "../infra/filelock.ts";
@@ -6,27 +7,34 @@ import type { Deps } from "./ports.ts";
 import { type Run, runPaths } from "./run-store.ts";
 import { readNotes } from "./state.ts";
 
-/** Spec §4: a Claude Code session as catherd records it. */
-export interface SessionRef {
-  sessionId: string;
-  hostSessionId: string | null;
-  name: string | null;
-}
+/** Spec §4: a host session as catherd records it. */
+export type SessionRef = HostSessionRef;
 
 /**
  * The session this process serves (spec §3.3), read live: its registry file's id and name when it has one (the
- * id in the environment goes stale after /clear), else the environment's. Null outside Claude Code.
+ * id in the environment goes stale after /clear), else the environment's. Null without known, consistent host identity.
  */
 export function currentSession(deps: Deps): SessionRef | null {
+  if (deps.host.host === "unknown" || deps.host.conflict) return null;
+  if (deps.host.host === "codex") return deps.host.session;
   const env = deps.session;
-  if (!env) return null;
+  if (!env) return deps.host.session;
   const file = sessionFileFor(env);
   const sessionId = file?.sessionId ?? env.sessionId;
   if (!sessionId) return null;
-  return { sessionId, hostSessionId: file?.hostSessionId ?? env.hostSessionId, name: file?.name ?? null };
+  return {
+    host: "claude-code",
+    sessionId,
+    hostSessionId: file?.hostSessionId ?? env.hostSessionId,
+    name: file?.name ?? null,
+  };
 }
 
-const OwnerSchema = z.object({ sessionId: z.string(), since: z.string() });
+const OwnerSchema = z.looseObject({
+  host: z.enum(["claude-code", "codex"]).default("claude-code"),
+  sessionId: z.string(),
+  since: z.string(),
+});
 export type Owner = z.infer<typeof OwnerSchema>;
 
 /** The run's owner session (state.json `owner`), or null for a run no session has owned (1.0, a terminal). */
@@ -38,10 +46,12 @@ export function runOwner(run: Run): Owner | null {
 /** Whether this process serves a session and that session owns the run now. */
 export function ownsRun(deps: Deps, run: Run): boolean {
   const me = currentSession(deps);
-  return me !== null && runOwner(run)?.sessionId === me.sessionId;
+  const owner = runOwner(run);
+  return me !== null && owner !== null && sessionKey(owner) === sessionKey(me);
 }
 
 const SessionRowSchema = z.looseObject({
+  host: z.enum(["claude-code", "codex"]).default("claude-code"),
   sessionId: z.string(),
   hostSessionId: z.string().nullable(),
   name: z.string().nullable(),
@@ -59,8 +69,7 @@ export function readSessionRows(run: Run): SessionRow[] {
 
 /**
  * Spec §3.3: `run_start`, `dispatch` and `peek` make the calling session the run's owner when it is not, and
- * append it to `R/sessions.jsonl`: that is how a run moves when it is continued from another session. Outside
- * Claude Code it changes nothing. Returns whether the owner changed.
+ * append it to `R/sessions.jsonl`: that is how a run moves when it is continued from another session. Without host session identity it changes nothing. Returns whether the owner changed.
  */
 export async function claimRun(deps: Deps, run: Run): Promise<boolean> {
   const me = currentSession(deps);
@@ -70,6 +79,7 @@ export async function claimRun(deps: Deps, run: Run): Promise<boolean> {
   const row = (since: string): void => {
     ensureJsonlHeader(p.sessions, "sessions");
     appendJsonl(p.sessions, {
+      host: me.host,
       sessionId: me.sessionId,
       hostSessionId: me.hostSessionId,
       name: me.name,
@@ -78,14 +88,20 @@ export async function claimRun(deps: Deps, run: Run): Promise<boolean> {
   };
   // the trail row goes in under the same lock: the trail's last row is the owner (session-view reads it so)
   return withFileLock(p.stateJson, () => {
+    const live = currentSession(deps);
+    if (!live || sessionKey(live) !== sessionKey(me)) return false;
     const notes = readNotes(run);
     const owner = runOwner(run);
-    if (owner?.sessionId === me.sessionId) {
+    if (owner && sessionKey(owner) === sessionKey(me)) {
       // a crash between the state.json write and the append left the trail without its owner: repaired here
-      if (readSessionRows(run).at(-1)?.sessionId !== me.sessionId) row(owner.since);
+      const last = readSessionRows(run).at(-1);
+      if (!last || sessionKey(last) !== sessionKey(me)) row(owner.since);
       return false;
     }
-    writeJsonAtomic(p.stateJson, { ...notes, owner: { sessionId: me.sessionId, since: at } });
+    writeJsonAtomic(p.stateJson, {
+      ...notes,
+      owner: { ...owner, host: me.host, sessionId: me.sessionId, since: at },
+    });
     row(at);
     return true;
   });

package/src/services/setup.ts

@@ -1,3 +1,6 @@
+import { ADAPTER_IDS } from "../domain/ids.ts";
+import { usedBackends } from "./doctor-backends.ts";
+import type { HostContext } from "../domain/host.ts";
 import { existsSync, readdirSync, readFileSync, renameSync } from "node:fs";
 import { basename, join } from "node:path";
 import type { Issue } from "../domain/profile-rules.ts";
@@ -5,7 +8,14 @@ import { configDir } from "../infra/paths.ts";
 import { type Refreshed, refreshDiscovery } from "./catalog-service.ts";
 import type { Synced } from "./agent-links.ts";
 import { activate, resetProfile, withProfilesLock } from "./profile-service.ts";
-import { configFile, profilesDir, projectsFile } from "./profile-store.ts";
+import {
+  activeName,
+  configFile,
+  getProfile,
+  profilesDir,
+  projectsFile,
+  readProjects,
+} from "./profile-store.ts";
 import { ensurePrivateDir } from "../infra/store.ts";
 
 /** True when profile `name` has a file (`default` exists as a name even before it has one). */
@@ -65,23 +75,34 @@ export interface InitResult {
 /**
  * Spec §8 `catherd init`, the setup half: moves 0.x files aside, writes the default profile (spec §7.2)
  * unless a 1.0 one exists and `overwrite` is not set, makes it active and links its agents, and lists
- * every backend's models. It never throws for a default profile that does not validate here: it writes
- * nothing, returns the errors, and activates the profile only when it has a file.
+ * backend models, skipping unused headless Claude on a Codex host. Defaults that do not validate return
+ * errors without a write; the profile becomes active only when it has a file.
  */
-export async function initSetup(
-  o: { profile?: string; overwrite?: boolean; now?: Date } = {},
-): Promise<InitResult> {
+export async function initSetup(o: {
+  profile?: string;
+  repo?: string | null;
+  overwrite?: boolean;
+  now?: Date;
+  host: HostContext;
+}): Promise<InitResult> {
   const moved = moveLegacy(o.now);
-  const profile = o.profile ?? "default";
+  const profile = o.profile ?? activeName(o.repo);
   let created = false;
   let errors: Issue[] = [];
   if (!hasProfileFile(profile) || o.overwrite === true) {
-    const saved = resetProfile(profile);
+    const saved = resetProfile(profile, o.host.host);
     created = saved.saved;
     errors = saved.errors;
   }
   const active = hasProfileFile(profile);
-  const synced = active ? activate(profile) : null;
-  const refreshed = await refreshDiscovery();
+  const repo =
+    o.profile === undefined && o.repo && readProjects().bindings[o.repo] !== undefined ? o.repo : null;
+  const synced = active ? activate(profile, repo, o.host.host) : null;
+  const used = usedBackends(active ? [getProfile(profile, o.host.host)] : []);
+  const backends =
+    o.host.host === "codex" && !used.has("claude-code")
+      ? ADAPTER_IDS.filter((id) => id !== "claude-code")
+      : undefined;
+  const refreshed = await refreshDiscovery({ backends });
   return { moved, profile, created, errors, active, synced, refreshed };
 }

package/src/services/source-derive.ts

@@ -85,14 +85,22 @@ export function derive(raw: RawAnswers, ctx: DeriveContext): Derived {
       const { id, effort } = splitSourceRung(row.rung);
       const family = map.family(id);
       if (!family) (unmatched[source] ??= new Set()).add(id);
-      const e = effort ?? (family ? defaultEffortOf(ctx.sources, family) : "");
+      // spec 1.3 §7.1: a family with no effort (Composer) has one rung, #default, whatever effort a source names
+      const effortless = family !== null && familyEfforts(family).length === 0;
+      const e = effortless ? "default" : (effort ?? (family ? defaultEffortOf(ctx.sources, family) : ""));
       const key = `${map.key(family?.id ?? id)}#${e}`;
       const field = `${source}.${row.field}`;
       const at = table.get(field) ?? new Map<string, Keyed>();
       table.set(field, at);
       const had = at.get(key);
       if (!had || row.value > had.row.value)
-        at.set(key, { key, family, effort: e, assumed: effort === null && family !== null, row });
+        at.set(key, {
+          key,
+          family,
+          effort: e,
+          assumed: effort === null && family !== null && !effortless,
+          row,
+        });
     }
   const valuesOf = (f: FieldRef) =>
     new Map([...(table.get(`${f.source}.${f.field}`)?.values() ?? [])].map((k) => [k.key, k.row.value]));
@@ -163,7 +171,9 @@ export function derive(raw: RawAnswers, ctx: DeriveContext): Derived {
       const family = map.family(id);
       if (family && effort !== null) shipped.add(`${family.id}#${effort}|${s.dim}`);
     }
-  scores.push(...adjacent(ctx.models.families, scores, shipped, ctx.now));
+  scores.push(
+    ...adjacent(ctx.models.families, scores, shipped, ctx.now, (f) => defaultEffortOf(ctx.sources, f)),
+  );
 
   const { facts, warnings } = factsOf(raw, ctx, map);
   return {
@@ -203,13 +213,16 @@ function aaFeatures(table: Map<string, Map<string, Keyed>>): Derived["features"]
  * Spec 1.2 §4.3 `adjacent`: for each family effort a dimension has no value at (neither one in `direct` nor
  * one `shipped` names, as `<family>#<effort>|<dim>`), the best value in `direct` at the nearest effort that
  * has one (the weaker on a tie). A sync spreads only its own values, and never onto a value the shipped file
- * carries; `rebuildShipped` spreads the shipped file's published values, with an empty `shipped`.
+ * carries; `rebuildShipped` spreads the shipped file's published values, with an empty `shipped`. A family that
+ * one backend runs without an effort (Cursor's bare slug, spec 1.3 §7.1) also gets `#default`, carried from the
+ * value nearest `defaultEffort(family)`.
  */
 export function adjacent(
   families: Family[],
   direct: Score[],
   shipped: ReadonlySet<string>,
   now: number,
+  defaultEffort: (f: Family) => string = () => "high",
 ): Score[] {
   const out: Score[] = [];
   for (const f of families)
@@ -222,9 +235,11 @@ export function adjacent(
         if (!had || outranks(s, had, now)) byEffort.set(effort, s);
       }
       if (byEffort.size === 0) continue;
-      for (const e of familyEfforts(f)) {
+      const efforts = familyEfforts(f);
+      const bare = efforts.length > 0 && Object.values(f.on).some((o) => o && o.efforts.length === 0);
+      for (const e of bare ? [...efforts, "default"] : efforts) {
         if (byEffort.has(e) || shipped.has(`${f.id}#${e}|${dim}`)) continue;
-        const near = nearestEffort(e, [...byEffort.keys()]);
+        const near = nearestEffort(e === "default" ? defaultEffort(f) : e, [...byEffort.keys()]);
         const from = near ? byEffort.get(near) : undefined;
         if (!near || !from) continue;
         out.push({
@@ -261,7 +276,8 @@ function factsOf(
   for (const f of ctx.models.families) {
     const x: FamilyFacts = { on: {}, speed: {} };
     const vendor = (f as { vendor?: unknown }).vendor;
-    const own = md && typeof vendor === "string" ? modelsDevFacts(md, vendor, f.id) : null;
+    const own =
+      md && typeof vendor === "string" ? modelsDevFacts(md, vendor, modelsDevId(md, vendor, f, map)) : null;
     if (own?.price) x.price = own.price;
     if (own && own.toolUse !== null && own.imageIn !== null && own.reasoning !== null)
       x.capabilities = { toolUse: own.toolUse, imageIn: own.imageIn, reasoning: own.reasoning };
@@ -290,6 +306,15 @@ function factsOf(
   return { facts, warnings };
 }
 
+/**
+ * The id of `vendor`'s models.dev model that is `f`: its own id, else the first that maps to it (spec 1.3 §7.1:
+ * `gemini-3-8-flash` is Google's `gemini-3.8-flash`, `gemini-3-1-pro` its aliased `gemini-3.1-pro-preview`).
+ */
+function modelsDevId(md: unknown, vendor: string, f: Family, map: IdMapper): string {
+  const ids = Object.keys((md as Record<string, { models?: object }>)[vendor]?.models ?? {});
+  return ids.includes(f.id) ? f.id : (ids.find((id) => map.family(id) === f) ?? f.id);
+}
+
 /** The first entry of `list` whose id maps to `f` (OpenRouter's `:batch` variants never do). */
 const entryFor = <T extends { id: string }>(list: T[], f: Family, map: IdMapper): T | undefined =>
   list.find((m) => map.family(m.id) === f);

package/src/services/summary.ts

@@ -1,3 +1,6 @@
+import type { HostContext } from "../domain/host.ts";
+import type { QueueCapability } from "../infra/codex-queue.ts";
+import { inspectionHost, inspectDeliveries, type DeliveryInspection } from "./run-debug.ts";
 import { resolve } from "node:path";
 import { type BudgetStatus, budgetStatus } from "../domain/budget.ts";
 import { isCatherdError } from "../domain/errors.ts";
@@ -7,7 +10,7 @@ import { nonBlankLines, readJsonl } from "../infra/store.ts";
 import { spendOf } from "./budget.ts";
 import { latestVerifierStep, type VerifierStep } from "./gate-service.ts";
 import { type OpenQuestion, openQuestions } from "./questions.ts";
-import { type DispatchState, liveDispatches } from "./dispatches.ts";
+import { type DispatchState, listDispatches, liveDispatches } from "./dispatches.ts";
 import { type RunSession, sessionFacts } from "./session-view.ts";
 import type { Deps } from "./ports.ts";
 import {
@@ -21,6 +24,7 @@ import {
 } from "./run-store.ts";
 
 export interface RunSummary {
+  delivery: (DeliveryInspection & { name: string; dispatchId: string })[];
   id: string;
   /** spec 1.1 §8: the owner questions not answered yet, listed first */
   questions: OpenQuestion[];
@@ -51,17 +55,28 @@ export function summarizeRun(deps: Deps, run: Run): RunSummary {
   const now = deps.now();
   const { records, corrupt } = readRecords(run);
   const live = liveDispatches(run, now);
+  const recorded = new Set(records.map((r) => r.dispatchId));
   const agents = readAgentRuns(run);
   const jev = readJsonl<{ source?: string }>(runPaths(run.dir).jev).rows;
   const sum = (f: (t: Tokens) => number) => records.reduce((n, r) => n + f(r.tokens), 0);
   let budget: BudgetStatus | null = null;
   const warnings = corrupt ? [`runs.jsonl: skipped ${corrupt} unreadable row(s)`] : [];
   try {
-    budget = budgetStatus(spendOf(run, records, live, now), deps.profiles.forRepo(run.meta.repo).budget);
+    budget = budgetStatus(
+      spendOf(run, records, live, now),
+      deps.profiles.budgetFor?.(run.meta.repo) ?? deps.profiles.forRepo(run.meta.repo).budget,
+    );
   } catch (e) {
     warnings.push(`budget: ${isCatherdError(e) ? e.message : String(e)}`);
   }
   return {
+    delivery: listDispatches(run).flatMap((d) =>
+      inspectDeliveries(run, d, recorded.has(d.admit.dispatchId)).map((inspection) => ({
+        name: d.admit.name,
+        dispatchId: d.admit.dispatchId,
+        ...inspection,
+      })),
+    ),
     id: run.id,
     questions: openQuestions(run),
     title: run.meta.title,
@@ -110,13 +125,33 @@ export function summarizeRun(deps: Deps, run: Run): RunSummary {
 export function status(
   deps: Deps,
   runId?: string,
-): { version: string; runs: RunSummary[]; warnings: string[] } {
-  if (runId) return { version: deps.version, runs: [summarizeRun(deps, findRun(runId))], warnings: [] };
+  queue: QueueCapability | null = null,
+): {
+  version: string;
+  runs: RunSummary[];
+  warnings: string[];
+  host: HostContext;
+  queue: QueueCapability | null;
+} {
+  if (runId)
+    return {
+      host: inspectionHost(deps.host),
+      queue,
+      version: deps.version,
+      runs: [summarizeRun(deps, findRun(runId))],
+      warnings: [],
+    };
   const { runs, corrupt } = listRuns();
   const warnings = corrupt.map((c) => `skipped run ${c.id}: ${c.reason}`);
   const all = runs.map((r) => summarizeRun(deps, r));
   const live = all.filter((s) => s.live.length > 0);
-  return { version: deps.version, runs: live.length ? live : all.slice(0, 1), warnings };
+  return {
+    host: inspectionHost(deps.host),
+    queue,
+    version: deps.version,
+    runs: live.length ? live : all.slice(0, 1),
+    warnings,
+  };
 }
 
 export interface RungStats {

package/src/services/treat-likes.ts

@@ -1,3 +1,4 @@
+import type { OrchestrationHost } from "../domain/host.ts";
 import { type Dim, scoresOf, rungInfo } from "../domain/catalog.ts";
 import { CatherdError } from "../domain/errors.ts";
 import { tryParseRung } from "../domain/ids.ts";
@@ -21,7 +22,10 @@ export interface LeftOnStandIn {
  * inferred stand-in, or be left with no value at all, once the user's treat-likes for `removed` (canonical
  * rungs, or all of them) are gone. Never removed silently.
  */
-export function leftOnStandIns(removed: string[] | "all"): LeftOnStandIn[] {
+export function leftOnStandIns(
+  removed: string[] | "all",
+  host: OrchestrationHost = "unknown",
+): LeftOnStandIn[] {
   const cur = readOverride();
   const treatLike = Object.fromEntries(
     Object.entries(cur.treatLike).filter(([r]) => removed !== "all" && !removed.includes(r)),
@@ -29,12 +33,18 @@ export function leftOnStandIns(removed: string[] | "all"): LeftOnStandIn[] {
   const gone = removed === "all" ? Object.keys(cur.treatLike) : removed;
   const c = loadCatalog({ timings: false, override: { ...cur, treatLike } });
   const out: LeftOnStandIn[] = [];
+  // an unknown host resolves no omitted architect/verifier rungs: name what either host would run
+  const hosts: OrchestrationHost[] = host === "unknown" ? ["claude-code", "codex"] : [host];
   for (const profile of listProfiles()) {
-    const p = getProfile(profile);
-    const rungs = new Set([
-      ...ROLES.filter((r) => p.roles[r].enabled).flatMap((r) => p.roles[r].rungs),
-      ...Object.values(p.failover),
-    ]);
+    const rungs = new Set(
+      hosts.flatMap((h) => {
+        const p = getProfile(profile, h);
+        return [
+          ...ROLES.filter((r) => p.roles[r].enabled).flatMap((r) => p.roles[r].rungs),
+          ...Object.values(p.failover),
+        ];
+      }),
+    );
     for (const rung of rungs) {
       if (!tryParseRung(rung)) continue;
       const canonical = rungInfo(c, rung).canonical;
@@ -65,6 +75,7 @@ export function suggestFor(rung: string): { canonical: string; lacking: Dim[]; s
  */
 export async function clearTreatLike(
   rung: string,
+  host: OrchestrationHost = "unknown",
 ): Promise<{ rung: string; like: string; left: LeftOnStandIn[] }> {
   const canonical = canonicalRung(rung);
   const like = readOverride().treatLike[canonical];
@@ -72,13 +83,15 @@ export async function clearTreatLike(
     throw new CatherdError("E_INPUT_INVALID", `${canonical} has no treat-like of yours to clear`, {
       fix: "catherd catalog list shows each rung's treat-like; a shipped one is not yours to clear",
     });
-  const left = leftOnStandIns([canonical]);
+  const left = leftOnStandIns([canonical], host);
   await removeTreatLikes([canonical]);
   return { rung: canonical, like, left };
 }
 
 /** Spec 1.2 §6.4 `--reset`: removes every treat-like of the user's, naming first the rungs left on a stand-in. */
-export async function resetTreatLikes(): Promise<{ removed: [string, string][]; left: LeftOnStandIn[] }> {
-  const left = leftOnStandIns("all");
+export async function resetTreatLikes(
+  host: OrchestrationHost = "unknown",
+): Promise<{ removed: [string, string][]; left: LeftOnStandIn[] }> {
+  const left = leftOnStandIns("all", host);
   return { removed: await removeTreatLikes("all"), left };
 }