catherd-cli 1.3.0 → 1.4.0

package/src/services/profile-service.ts

@@ -1,3 +1,5 @@
+import type { HostContext, OrchestrationHost } from "../domain/host.ts";
+import { agentFiles } from "../domain/agents.ts";
 import { existsSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
@@ -9,18 +11,19 @@ import {
   assertProfileName,
   type Change,
   defaultProfileDoc,
+  hostDefaultsDoc,
   diffProfiles,
   type Profile,
   type ProfileDoc,
   type ProfilePatch,
   resolveProfile,
 } from "../domain/profile.ts";
-import { repairs, type Validation } from "../domain/profile-rules.ts";
+import { nativeClaudeIssue, repairs, type Validation } from "../domain/profile-rules.ts";
 import { ROLES } from "../domain/roles.ts";
 import { withFileLockSync } from "../infra/filelock.ts";
 import { configDir } from "../infra/paths.ts";
 import { ensurePrivateDir, writeJsonAtomic, writeTextAtomic } from "../infra/store.ts";
-import { apply, plan, type Synced } from "./agent-links.ts";
+import { apply, plan, pruneProfileAgents, type Synced } from "./agent-links.ts";
 import { loadCatalog } from "./catalog-service.ts";
 import type { ProfilePort, ProfileSaved, ProfileView } from "./ports.ts";
 import {
@@ -54,11 +57,18 @@ const locked = withProfilesLock;
 const writeDoc = (name: string, doc: ProfileDoc) => writeJsonAtomic(profileFile(name), { ...doc, name });
 
 /** Writes `doc` as profile `name` and relinks; when the relink refuses, puts the profile back as it was. */
-function saveAndLink(name: string, doc: ProfileDoc): Synced {
+/** `repairing`: a saved repair with errors still open, whose remaining native roles are among those errors. */
+function saveAndLink(name: string, doc: ProfileDoc, host: OrchestrationHost, repairing = false): Synced {
   const before = existsSync(profileFile(name)) ? readFileSync(profileFile(name), "utf8") : null;
+  const nativeOn = (h: OrchestrationHost) => agentFiles(getProfile(name, h), "").length > 0;
+  const hadNative = before !== null && nativeOn(host);
+  // omitted defaults are native only on claude-code: the artifacts that resolution made count too
+  const hadClaudeNative = before !== null && host !== "claude-code" && nativeOn("claude-code");
   writeDoc(name, doc);
   try {
-    return apply(plan([name]));
+    // a profile left with no native role on any host owns no agents; one still native there keeps them
+    const allowPrune = host === "claude-code" || hadNative || (hadClaudeNative && !nativeOn("claude-code"));
+    return syncFor(name, host, [name], allowPrune, repairing);
   } catch (e) {
     if (before === null) rmSync(profileFile(name), { force: true });
     else writeTextAtomic(profileFile(name), before);
@@ -66,8 +76,34 @@ function saveAndLink(name: string, doc: ProfileDoc): Synced {
   }
 }
 
-const validate = (doc: ProfileDoc, name: string): Validation =>
-  validateHere(resolveProfile(doc, name), loadCatalog({ timings: false }), doc);
+const validate = (doc: ProfileDoc, name: string, host: OrchestrationHost): Validation => {
+  try {
+    return validateHere(resolveProfile(doc, name, host), loadCatalog({ timings: false }), doc, host);
+  } catch (e) {
+    if (!(e instanceof CatherdError)) throw e;
+    return { errors: [{ path: "roles", message: e.message, fix: e.fix }], warnings: [] };
+  }
+};
+function nativeAgents(name: string, host: OrchestrationHost) {
+  const files = agentFiles(getProfile(name, host), "");
+  const first = files[0];
+  const issue = first && nativeClaudeIssue(first.rung, host, `roles.${first.role}.rungs`);
+  if (issue) throw new CatherdError("E_CONFIG_INVALID", issue.message, { fix: issue.fix });
+  return files;
+}
+function syncFor(
+  name: string,
+  host: OrchestrationHost,
+  extra: string[] = [],
+  allowPrune = host === "claude-code",
+  repairing = false,
+): Synced {
+  // a partial repair keeps its open native-role errors: link and prune nothing until they are fixed
+  if (repairing && agentFiles(getProfile(name, host), "").some((f) => nativeClaudeIssue(f.rung, host, "")))
+    return { linked: [], pruned: [], newSessionNeededFor: [] };
+  if (nativeAgents(name, host).length) return apply(plan(host, extra));
+  return allowPrune ? pruneProfileAgents(name) : { linked: [], pruned: [], newSessionNeededFor: [] };
+}
 
 /** What a save returns: the port's ProfileSaved (one type for the CLI, the TUI and the MCP tools). */
 export type Saved = ProfileSaved;
@@ -95,7 +131,7 @@ export const CHANGED_ON_DISK = "profile";
 export function patchProfile(
   name: string | undefined,
   patch: ProfilePatch,
-  opts: { expect?: ProfileDoc } = {},
+  opts: { host: OrchestrationHost; expect?: ProfileDoc },
 ): Saved {
   return locked(() => {
     const n = assertProfileName(name ?? activeName());
@@ -111,17 +147,18 @@ export function patchProfile(
         ],
         warnings: [],
       });
+    const host = opts.host;
     const after = applyPatch(before, patch);
-    const resolved = resolveProfile(after, n);
-    const v = validate(after, n);
-    if (v.errors.length && !repairs(profileExists(n) ? validate(before, n) : null, v)) return unsaved(v);
-    const diff = diffProfiles(resolveProfile(before, n), resolved);
-    return { saved: true, ...v, diff, ...saveAndLink(n, after) };
+    const v = validate(after, n, host);
+    if (v.errors.length && !repairs(profileExists(n) ? validate(before, n, host) : null, v))
+      return unsaved(v);
+    const diff = diffProfiles(resolveProfile(before, n, host), resolveProfile(after, n, host));
+    return { saved: true, ...v, diff, ...saveAndLink(n, after, host, v.errors.length > 0) };
   });
 }
 
 /** Spec §7.3 `create` and `copy`: a new profile from `from` (default: the default profile). */
-export function createProfile(name: string, from?: string): Saved {
+export function createProfile(name: string, from: string | undefined, host: OrchestrationHost): Saved {
   return locked(() => {
     // `default` exists without a file: resetProfile is the only way to write it
     if (profileExists(assertProfileName(name)))
@@ -133,20 +170,20 @@ export function createProfile(name: string, from?: string): Saved {
         fix: "catherd profile list",
       });
     const doc = from === undefined ? defaultProfileDoc(name) : readProfileDoc(from);
-    const v = validate(doc, name);
+    const v = validate(doc, name, host);
     if (v.errors.length) return unsaved(v);
-    return { saved: true, ...v, diff: [], ...saveAndLink(name, doc) };
+    return { saved: true, ...v, diff: [], ...saveAndLink(name, doc, host) };
   });
 }
 
 /** Writes the default profile under `name`, replacing what is there (`catherd init` when asked to). */
-export function resetProfile(name: string): Saved {
+export function resetProfile(name: string, host: OrchestrationHost): Saved {
   return locked(() => {
     assertProfileName(name);
     const doc = defaultProfileDoc(name);
-    const v = validate(doc, name);
+    const v = validate(doc, name, host);
     if (v.errors.length) return unsaved(v);
-    return { saved: true, ...v, diff: [], ...saveAndLink(name, doc) };
+    return { saved: true, ...v, diff: [], ...saveAndLink(name, doc, host) };
   });
 }
 
@@ -181,7 +218,7 @@ export function deleteProfile(name: string): Synced {
         bindings: Object.fromEntries(Object.entries(projects.bindings).filter(([r]) => !gone.has(r))),
       });
     try {
-      return apply(plan(), [name]);
+      return pruneProfileAgents(name);
     } catch (e) {
       writeTextAtomic(profileFile(name), text);
       if (gone.size) writeJsonAtomic(projectsFile(), projects);
@@ -193,7 +230,8 @@ export function deleteProfile(name: string): Synced {
 /** Spec §7.3 `activate(name, repo?)`: the active profile, or the one bound to a repo; relinks the agents. */
 export function activate(
   name: string,
-  repo: string | null = null,
+  repo: string | null,
+  host: OrchestrationHost,
 ): Synced & { active: string; repo: string | null } {
   return locked(() => {
     assertProfileName(name);
@@ -201,6 +239,7 @@ export function activate(
       throw new CatherdError("E_INPUT_INVALID", `no profile named "${name}"`, {
         fix: "catherd profile list",
       });
+    nativeAgents(name, host);
     const config = readConfig();
     const projects = readProjects();
     const write = () =>
@@ -213,7 +252,7 @@ export function activate(
           });
     write();
     try {
-      return { active: name, repo, ...apply(plan([name])) };
+      return { active: name, repo, ...syncFor(name, host, [name]) };
     } catch (e) {
       if (repo === null) writeJsonAtomic(configFile(), config);
       else writeJsonAtomic(projectsFile(), projects);
@@ -223,7 +262,7 @@ export function activate(
 }
 
 /** `catherd profile use --repo --clear`: removes `repo`'s binding, so it runs on the active profile again. */
-export function unbind(repo: string): Synced & { repo: string; was: string } {
+export function unbind(repo: string, host: OrchestrationHost): Synced & { repo: string; was: string } {
   return locked(() => {
     const projects = readProjects();
     const was = projects.bindings[repo];
@@ -235,7 +274,11 @@ export function unbind(repo: string): Synced & { repo: string; was: string } {
     delete bindings[repo];
     writeJsonAtomic(projectsFile(), { ...projects, schema: 1, bindings });
     try {
-      return { repo, was, ...apply(plan()) };
+      // a binding to a deleted profile is what doctor sends here to clear: there is nothing of it to relink
+      const synced = profileExists(was)
+        ? syncFor(was, host)
+        : { linked: [], pruned: [], newSessionNeededFor: [] };
+      return { repo, was, ...synced };
     } catch (e) {
       writeJsonAtomic(projectsFile(), projects);
       throw e;
@@ -243,8 +286,8 @@ export function unbind(repo: string): Synced & { repo: string; was: string } {
   });
 }
 
-export function diffNamed(a: string, b: string): Change[] {
-  return diffProfiles(getProfile(a), getProfile(b));
+export function diffNamed(a: string, b: string, host: OrchestrationHost): Change[] {
+  return diffProfiles(getProfile(a, host), getProfile(b, host));
 }
 
 function viewOf(p: Profile): ProfileView {
@@ -267,13 +310,16 @@ function viewOf(p: Profile): ProfileView {
 }
 
 /** The ProfilePort the run engine and the MCP tools use (spec §7.3: the single writer). */
-export function profileService(): ProfilePort {
+export function profileService(host: () => HostContext): ProfilePort {
   // without a name, each tool acts on the profile `repo` runs on (the active one outside a repo)
   return {
-    forRepo: (repo) => viewOf(profileFor(repo)),
+    withHost: profileService,
+    raw: (name, repo = null) => readProfileDoc(name ?? activeName(repo)),
+    budgetFor: (repo) => readProfileDoc(activeName(repo)).budget ?? {},
+    forRepo: (repo) => viewOf(profileFor(repo, host().host)),
     get(name, repo = null) {
       const here = activeName(repo);
-      const p = getProfile(name === undefined ? here : requireProfile(name));
+      const p = getProfile(name === undefined ? here : requireProfile(name), host().host);
       return {
         active: activeName(),
         here,
@@ -283,12 +329,52 @@ export function profileService(): ProfilePort {
       };
     },
     validate(name, repo = null) {
-      const v = validateNamed(name === undefined ? activeName(repo) : requireProfile(name), repo);
+      const v = validateNamed(
+        name === undefined ? activeName(repo) : requireProfile(name),
+        repo,
+        host().host,
+      );
       return { valid: v.errors.length === 0, ...v };
     },
     // a name that does not exist yet starts from the default profile
-    set: (name, patch, repo = null) => patchProfile(name ?? activeName(repo), patch),
+    set: (name, patch, repo = null) => patchProfile(name ?? activeName(repo), patch, { host: host().host }),
     agentFor: (repo, role, rung) =>
       parseRung(rung).backend === "claude" ? agentName(activeName(repo), role, rung) : null,
   };
 }
+
+export function resetHostDefaults(
+  name: string,
+  host: OrchestrationHost,
+  opts:
+    | { preview: true; expect?: ProfileDoc }
+    | { preview: false; expect: ProfileDoc; reviewed: { profile: string; host: OrchestrationHost } },
+): Saved & { expect: ProfileDoc; profile: string; host: OrchestrationHost } {
+  return locked(() => {
+    const refuse = (message: string, expect: ProfileDoc) => ({
+      ...unsaved({
+        errors: [{ path: CHANGED_ON_DISK, message, fix: "preview again and review the changes" }],
+        warnings: [],
+      }),
+      expect,
+      profile: name,
+      host,
+    });
+    // the reset is host-specific: a preview approves one profile on one host, never another
+    if (!opts.preview && (opts.reviewed.profile !== name || opts.reviewed.host !== host))
+      return refuse(
+        `the preview was for profile "${opts.reviewed.profile}" on host ${opts.reviewed.host}, not "${name}" on ${host}`,
+        opts.expect,
+      );
+    const before = readProfileDoc(name);
+    if (!opts.preview && !isDeepStrictEqual(before, opts.expect))
+      return refuse(`profile "${name}" changed on disk since it was shown`, before);
+    const after = hostDefaultsDoc(before);
+    const v = validate(after, name, host);
+    if (v.errors.length) return { ...unsaved(v), expect: before, profile: name, host };
+    const diff = diffProfiles(resolveProfile(before, name, host), resolveProfile(after, name, host));
+    return opts.preview
+      ? { ...unsaved(v), diff, expect: before, profile: name, host }
+      : { saved: true, ...v, diff, ...saveAndLink(name, after, host), expect: before, profile: name, host };
+  });
+}

package/src/services/profile-store.ts

@@ -1,3 +1,4 @@
+import type { OrchestrationHost } from "../domain/host.ts";
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
@@ -94,7 +95,8 @@ export function readProfileDoc(name: string): ProfileDoc {
   throw new CatherdError("E_CONFIG_INVALID", `no profile named "${name}"`, { fix: "catherd profile list" });
 }
 
-export const getProfile = (name: string): Profile => resolveProfile(readProfileDoc(name), name);
+export const getProfile = (name: string, host: OrchestrationHost): Profile =>
+  resolveProfile(readProfileDoc(name), name, host);
 
 /** A profile name the user typed: refused as bad input (exit 2) when no such profile exists. */
 export function requireProfile(name: string): string {
@@ -109,7 +111,8 @@ export function activeName(repo: string | null = null): string {
   return bound ?? readConfig().activeProfile ?? "default";
 }
 
-export const profileFor = (repo: string | null): Profile => getProfile(activeName(repo));
+export const profileFor = (repo: string | null, host: OrchestrationHost): Profile =>
+  getProfile(activeName(repo), host);
 
 /** The backends catherd can run: every registered adapter, and the native `claude` path. */
 export const runnableBackends = (): string[] => ["claude", ...ADAPTER_IDS.filter((id) => adapterFor(id))];
@@ -212,8 +215,13 @@ export function budgetUsdWarnings(p: Profile): Issue[] {
  * Spec §7.1 validation on this machine: the backends catherd can run here, the keys isolation needs, the
  * accesses a backend holds only when isolated, and the backends a dollar budget cannot see.
  */
-export function validateHere(p: Profile, c: Catalog, doc?: ProfileDoc): Validation {
-  const v = validateProfile(p, c, runnableBackends(), doc);
+export function validateHere(
+  p: Profile,
+  c: Catalog,
+  doc?: ProfileDoc,
+  host: OrchestrationHost = "unknown",
+): Validation {
+  const v = validateProfile(p, c, runnableBackends(), doc, host);
   return {
     errors: [...v.errors, ...isolationKeyErrors(p), ...isolatedOnlyErrors(p)],
     warnings: [...v.warnings, ...budgetUsdWarnings(p)],
@@ -221,11 +229,20 @@ export function validateHere(p: Profile, c: Catalog, doc?: ProfileDoc): Validati
 }
 
 /** `repo`: the git toplevel whose listing route reads (opencode lists its models per repository). */
-export function validateNamed(name?: string, repo: string | null = null): Validation {
+export function validateNamed(
+  name: string | undefined,
+  repo: string | null,
+  host: OrchestrationHost,
+): Validation {
   const n = name ?? activeName(repo);
   const doc = readProfileDoc(n);
   const catalog = loadCatalog({ timings: false, ...(repo === null ? {} : { repo }) });
-  return validateHere(resolveProfile(doc, n), catalog, doc);
+  try {
+    return validateHere(resolveProfile(doc, n, host), catalog, doc, host);
+  } catch (e) {
+    if (!(e instanceof CatherdError)) throw e;
+    return { errors: [{ path: "roles", message: e.message, fix: e.fix }], warnings: [] };
+  }
 }
 
 /** Spec D10: how strongly the backend holds a role to its access mode. */

package/src/services/routing-service.ts

@@ -1,3 +1,4 @@
+import { assertNativeHost } from "./backends.ts";
 import { BUDGET_CHEAP_AT } from "../domain/budget.ts";
 import { errorMessage } from "../domain/errors.ts";
 import {
@@ -171,7 +172,11 @@ async function verdict<T extends string>(
 /** The routing port over the 1.0 catalog and Jev (spec §5); `o` lets tests inject Jev's transport. */
 export function routingService(o: RoutingOpts = {}): RoutingPort {
   return {
-    route: (req) => route(req, o),
+    route: async (req) => {
+      const result = await route(req, o);
+      assertNativeHost(result.rung, req.host ?? "unknown");
+      return result;
+    },
     finding: (runDir, laneText, finding, use) =>
       verdict(
         runDir,

package/src/services/run-debug.ts

@@ -1,15 +1,107 @@
-import { closeSync, fstatSync, openSync, readSync } from "node:fs";
+import { closeSync, existsSync, fstatSync, openSync, readSync } from "node:fs";
+import { sessionKey, type HostContext, type HostSessionRef } from "../domain/host.ts";
+import { deliveryState, readDelivery, type DeliveryState } from "../infra/delivery.ts";
 import type { ExitInfo, RunRecord } from "../domain/record.ts";
-import { dispatchPaths, readExit } from "../infra/dispatch-dir.ts";
+import { awaitsCollect, dispatchPaths, readExit } from "../infra/dispatch-dir.ts";
 import { redact } from "../infra/log.ts";
-import { listDispatches } from "./dispatches.ts";
+import { type Dispatch, listDispatches } from "./dispatches.ts";
 import { registerSavedSecrets } from "./jev-service.ts";
+import { runOwner } from "./sessions.ts";
 import { readRecords, type Run } from "./run-store.ts";
 
 /** How many trailing lines of stderr, events and the supervisor log `runs show --debug` prints. */
 export const TAIL_LINES = 20;
 
-export interface DispatchDebug {
+export function inspectionHost(host: HostContext): HostContext {
+  const target = host.session;
+  return {
+    host: host.host,
+    conflict: host.conflict,
+    session: target
+      ? {
+          host: target.host,
+          sessionId: target.sessionId,
+          hostSessionId: target.hostSessionId,
+          name: target.name,
+        }
+      : null,
+  };
+}
+
+export interface DeliveryInspection {
+  eventId: string;
+  delivery: DeliveryState;
+  receipt: { msgId: string; target: HostSessionRef; at: string } | null;
+}
+
+export function inspectDelivery(
+  run: Run,
+  d: Dispatch,
+  recorded: boolean,
+  eventId = JSON.stringify([
+    run.id,
+    d.admit.dispatchId,
+    !recorded && existsSync(dispatchPaths(d.dir).stall) ? "stalled" : "finished",
+  ]),
+): DeliveryInspection {
+  const owner = runOwner(run);
+  const target = owner
+    ? { host: owner.host, sessionId: owner.sessionId, hostSessionId: null, name: null }
+    : null;
+  const finished = eventId === JSON.stringify([run.id, d.admit.dispatchId, "finished"]);
+  const collected = finished && recorded && !awaitsCollect(d.dir);
+  try {
+    const receipt = target
+      ? readDelivery(d.dir).findLast(
+          (a) =>
+            a.status === "accepted" &&
+            a.eventIds.includes(eventId) &&
+            sessionKey(a.target) === sessionKey(target),
+        )
+      : undefined;
+    return {
+      eventId,
+      delivery: collected
+        ? "collected"
+        : (recorded || !finished) && target
+          ? deliveryState(d.dir, target, eventId)
+          : "pending",
+      receipt: receipt?.msgId
+        ? {
+            msgId: receipt.msgId,
+            at: receipt.at,
+            target: {
+              host: receipt.target.host,
+              sessionId: receipt.target.sessionId,
+              hostSessionId: receipt.target.hostSessionId,
+              name: receipt.target.name,
+            },
+          }
+        : null,
+    };
+  } catch {
+    return { eventId, delivery: collected ? "collected" : "ambiguous", receipt: null };
+  }
+}
+
+/**
+ * Stored stalled and finished events are separate; only finished records can be collected. A stall the role
+ * outlived that is still pending for the current owner can never go out (the notifier drops it and retry
+ * refuses it), so it is not shown; one with an outcome for this owner (accepted, ambiguous) still is.
+ */
+export function inspectDeliveries(run: Run, d: Dispatch, recorded: boolean): DeliveryInspection[] {
+  const exited = existsSync(dispatchPaths(d.dir).exit);
+  return [...(recorded ? ["finished"] : []), ...(existsSync(dispatchPaths(d.dir).stall) ? ["stalled"] : [])]
+    .map((kind) => ({
+      kind,
+      ...inspectDelivery(run, d, recorded, JSON.stringify([run.id, d.admit.dispatchId, kind])),
+    }))
+    .filter((e) => !(e.kind === "stalled" && exited && e.delivery === "pending"))
+    .map(({ kind: _kind, ...e }) => e);
+}
+
+export interface DispatchDebug extends DeliveryInspection {
+  deliveries: DeliveryInspection[];
   name: string;
   dispatchId: string;
   rung: string;
@@ -65,6 +157,8 @@ export function runDebug(run: Run, name?: string): DispatchDebug[] {
     .map((d) => {
       const p = dispatchPaths(d.dir);
       return redact({
+        ...inspectDelivery(run, d, records.has(d.admit.dispatchId)),
+        deliveries: inspectDeliveries(run, d, records.has(d.admit.dispatchId)),
         name: d.admit.name,
         dispatchId: d.admit.dispatchId,
         rung: d.admit.rung,

package/src/services/run-service.ts

@@ -15,6 +15,7 @@ import {
   recordHints,
 } from "./dispatches.ts";
 import type { Deps } from "./ports.ts";
+import { assertNativeHost } from "./backends.ts";
 import {
   type AgentRun,
   appendAgentRun,
@@ -167,6 +168,7 @@ export function recordAgentRun(
     throw new CatherdError("E_ADMIT_RUNG", `${i.rung} is not a native Claude rung`, {
       fix: "record_agent_run is for Agent subagents; dispatch records every other run itself",
     });
+  assertNativeHost(i.rung, deps.host.conflict ? "unknown" : deps.host.host);
   const row: AgentRun = {
     at: new Date(deps.now()).toISOString(),
     name: i.name,

package/src/services/run-store.ts

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

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