catherd-cli 1.3.0 → 1.4.0

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