viber-channel 0.8.40 → 0.8.41

package/lib/claude_runtime_publisher.ts

@@ -0,0 +1,86 @@
+/**
+ * claude_runtime_publisher.ts — a claude agent's model, effort and context, left for
+ * the runner after each reply (#708 step-04).
+ *
+ * JP's rule (2026-10-17): the figures move on a round trip — a message in, the
+ * agent's answer out — and are pushed only if they changed. So nothing watches the
+ * session log: when the agent replies on the channel (`send_message`, or
+ * `message_agent` for an agent that only talks in DMs), the channel reads its own
+ * claude's log once and rewrites `<presenceDir>/<id>.runtime.json` if what the chip
+ * shows changed. The runner then pushes it, like a codex agent's file.
+ *
+ * The read waits `delayMs`: the assistant entry carrying the reply's tool call lands
+ * in the log within 200 ms of the call starting (measured, plan 708 step-01). Replies
+ * within that window are coalesced into one read.
+ */
+import { readClaudeRuntime } from "./claude_session_log.js";
+import { runtimeFilePath, writeRuntimeFile } from "./codex_runtime.js";
+import { processStartTimeAsync } from "./process_start.js";
+import { type RuntimeV1, sameRuntime } from "./runtime_info.js";
+
+export const PUBLISH_DELAY_MS = 500;
+
+export interface ClaudeRuntimePublisherOptions {
+  /** The claude process this channel serves (parent watchdog); null = none found. */
+  getClaudePid: () => number | null;
+  identityBaseUrl: string;
+  /** Read at publish time: the instance registers after the channel starts. */
+  getInstanceId: () => string;
+  lockDir?: string;
+  delayMs?: number;
+  probeStartTime?: (pid: number) => Promise<number | undefined>;
+  read?: (q: { pid: number; startTimeMs: number }) => RuntimeV1 | undefined;
+  write?: (path: string, instanceId: string, r: RuntimeV1) => void;
+  setTimer?: (fn: () => void, ms: number) => unknown;
+  log?: (line: string) => void;
+}
+
+export class ClaudeRuntimePublisher {
+  private startTime: number | undefined;
+  private startPid: number | null = null;
+  private pending = false;
+  private last: RuntimeV1 | undefined;
+  private lastInstance = "";
+
+  constructor(private readonly opts: ClaudeRuntimePublisherOptions) {}
+
+  /** The agent just replied on the channel. Never throws, never blocks the reply. */
+  afterReply(): void {
+    if (this.opts.getClaudePid() === null || this.pending) return;
+    this.pending = true;
+    const setTimer =
+      this.opts.setTimer ??
+      ((fn: () => void, ms: number) => {
+        const t = setTimeout(fn, ms);
+        (t as { unref?: () => void }).unref?.();
+        return t;
+      });
+    setTimer(() => {
+      this.pending = false;
+      void this.publish().catch((err) => this.log(`[runtime] publish failed: ${String(err)}\n`));
+    }, this.opts.delayMs ?? PUBLISH_DELAY_MS);
+  }
+
+  /** One read and, if what the chip shows changed, one write. Exposed for tests. */
+  async publish(): Promise<void> {
+    const pid = this.opts.getClaudePid();
+    const instanceId = this.opts.getInstanceId();
+    if (pid === null || instanceId === "") return;
+    if (this.startTime === undefined || this.startPid !== pid) {
+      this.startPid = pid;
+      this.startTime = await (this.opts.probeStartTime ?? ((p: number) => processStartTimeAsync(p)))(pid);
+      if (this.startTime === undefined) return; // retried on the next reply
+    }
+    const r = (this.opts.read ?? readClaudeRuntime)({ pid, startTimeMs: this.startTime });
+    // Unknown: keep the file as it is — a torn read is not a reason to clear the chip.
+    if (r === undefined) return;
+    if (instanceId === this.lastInstance && sameRuntime(this.last, r)) return;
+    (this.opts.write ?? writeRuntimeFile)(runtimeFilePath(this.opts.identityBaseUrl, instanceId, this.opts.lockDir), instanceId, r);
+    this.last = r;
+    this.lastInstance = instanceId;
+  }
+
+  private log(line: string): void {
+    (this.opts.log ?? ((l: string) => process.stderr.write(l)))(line);
+  }
+}

package/lib/claude_session_log.ts

@@ -0,0 +1,186 @@
+/**
+ * claude_session_log.ts — read a Claude agent's model, effort and context from its
+ * session log (#708 step-02).
+ *
+ * Two files, both internal to Claude Code (undocumented, may change between
+ * versions — every field is optional here, and a miss yields "unknown", never 0):
+ *
+ * - `~/.claude/sessions/<pid>.json`: the live registry of a claude process. It
+ *   names the CURRENT session (it follows `/clear` and resume), so it is re-read
+ *   on every call, never cached. Its `procStart` (Windows FILETIME) equals the
+ *   process start time measured by `process_start.ts` to the millisecond
+ *   (measured, plan 708 step-01): a pid recycled by another process is refused.
+ * - `~/.claude/projects/<slug(cwd)>/<sessionId>.jsonl`: one entry per event. The
+ *   last `assistant` entry carries `message.model`, `effort` and `message.usage`;
+ *   occupation = input + cache_creation + cache_read of that LAST call (the status
+ *   line's formula). It is written within 200 ms of a tool call starting.
+ *
+ * Known lag, by construction: after `/compact` or `/model`, the figures stay those of
+ * the last call until the next one is logged.
+ */
+import { closeSync, existsSync, fstatSync, openSync, readFileSync, readSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { CLAUDE_CONTEXT_WINDOW, type RuntimeV1, buildRuntime, isEmptyRuntime } from "./runtime_info.js";
+
+/** FILETIME epoch (1601-01-01) to Unix epoch, in ms. */
+const FILETIME_UNIX_OFFSET_MS = 11_644_473_600_000;
+/** `procStart` and the CIM probe agree to the ms today (measured); the slack absorbs a
+ *  rounding change between versions — a recycled pid never starts within 5 ms. */
+const START_TOLERANCE_MS = 5;
+/** Tail windows, tried in order: an assistant entry carrying a big tool input can be large. */
+export const TAIL_BYTES: readonly number[] = [256 * 1024, 4 * 1024 * 1024];
+
+export interface LiveSession {
+  sessionId: string;
+  cwd: string;
+}
+
+/** The `/resume` bucket of a working directory: every non-alphanumeric char → '-'. */
+export function projectSlug(cwd: string): string {
+  return cwd.replace(/[^A-Za-z0-9]/g, "-");
+}
+
+/** FILETIME string (100 ns ticks since 1601) → Unix ms, or undefined. */
+export function fileTimeToMs(raw: unknown): number | undefined {
+  if (typeof raw !== "string" || !/^\d{1,20}$/.test(raw)) return undefined;
+  // Rounded like the CIM probe (`[int64]` of a fractional ms rounds), measured equal.
+  const ms = Number((BigInt(raw) + 5_000n) / 10_000n) - FILETIME_UNIX_OFFSET_MS;
+  return ms > 0 ? ms : undefined;
+}
+
+/**
+ * The live session of claude process `pid`, or undefined when the registry is
+ * missing, unreadable, or belongs to another process (pid recycled).
+ */
+export function readLiveSession(home: string, pid: number, startTimeMs: number): LiveSession | undefined {
+  let d: Record<string, unknown>;
+  try {
+    d = JSON.parse(readFileSync(join(home, ".claude", "sessions", `${pid}.json`), "utf8"));
+  } catch {
+    return undefined;
+  }
+  if (typeof d !== "object" || d === null || d.pid !== pid) return undefined;
+  const started = fileTimeToMs(d.procStart);
+  if (started === undefined || Math.abs(started - startTimeMs) > START_TOLERANCE_MS) return undefined;
+  if (typeof d.sessionId !== "string" || !/^[0-9a-f-]{36}$/i.test(d.sessionId)) return undefined;
+  if (typeof d.cwd !== "string" || d.cwd === "") return undefined;
+  return { sessionId: d.sessionId, cwd: d.cwd };
+}
+
+/** The session log path: the cwd's bucket first, then any bucket holding that id. */
+export function resolveSessionLog(home: string, live: LiveSession): string | undefined {
+  const projects = join(home, ".claude", "projects");
+  const file = `${live.sessionId}.jsonl`;
+  const direct = join(projects, projectSlug(live.cwd), file);
+  if (existsSync(direct)) return direct;
+  try {
+    for (const bucket of readdirSync(projects)) {
+      const p = join(projects, bucket, file);
+      if (existsSync(p)) return p;
+    }
+  } catch {
+    // no projects directory: unknown
+  }
+  return undefined;
+}
+
+function readTail(path: string, bytes: number): { text: string; whole: boolean } | undefined {
+  let fd: number | undefined;
+  try {
+    fd = openSync(path, "r");
+    const size = fstatSync(fd).size;
+    const len = Math.min(size, bytes);
+    const buf = Buffer.alloc(len);
+    readSync(fd, buf, 0, len, size - len);
+    return { text: buf.toString("utf8"), whole: len === size };
+  } catch {
+    return undefined;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+export interface LastTurn {
+  model?: string;
+  effort?: string;
+  contextTokens?: number;
+}
+
+const count = (n: unknown): number | undefined =>
+  typeof n === "number" && Number.isInteger(n) && n >= 0 ? n : undefined;
+
+/** The last real main-thread assistant call in a chunk of log, or undefined. */
+export function lastTurnOf(text: string, whole: boolean): LastTurn | undefined {
+  const lines = text.split("\n");
+  // A tail cut mid-line: the first line is a fragment. The last may be a write in progress.
+  const start = whole ? 0 : 1;
+  for (let i = lines.length - 1; i >= start; i--) {
+    const line = lines[i]?.trim();
+    if (!line || !line.includes('"assistant"')) continue;
+    let e: Record<string, unknown>;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (e.type !== "assistant" || e.isSidechain === true) continue;
+    const m = e.message as Record<string, unknown> | undefined;
+    // An API error is logged as a "<synthetic>" assistant entry with zero usage: not a call.
+    if (!m || m.model === "<synthetic>") continue;
+    const u = m.usage as Record<string, unknown> | undefined;
+    const parts = u ? [count(u.input_tokens), count(u.cache_creation_input_tokens), count(u.cache_read_input_tokens)] : [];
+    return {
+      model: typeof m.model === "string" ? m.model : undefined,
+      effort: typeof e.effort === "string" ? e.effort : undefined,
+      contextTokens: parts.length === 3 && parts.every((p) => p !== undefined)
+        ? (parts as number[]).reduce((a, b) => a + b, 0)
+        : undefined,
+    };
+  }
+  return undefined;
+}
+
+/** The last turn of a session log, widening the tail once if the first window holds none. */
+export function readLastTurn(path: string, tails: readonly number[] = TAIL_BYTES): LastTurn | undefined {
+  for (const bytes of tails) {
+    const tail = readTail(path, bytes);
+    if (!tail) return undefined;
+    const turn = lastTurnOf(tail.text, tail.whole);
+    if (turn || tail.whole) return turn;
+  }
+  return undefined;
+}
+
+export interface ClaudeRuntimeQuery {
+  pid: number;
+  startTimeMs: number;
+  home?: string;
+  now?: () => number;
+}
+
+/** The runtime of a claude agent, or undefined when nothing about it is known. */
+export function readClaudeRuntime(q: ClaudeRuntimeQuery): RuntimeV1 | undefined {
+  const home = q.home ?? homedir();
+  const live = readLiveSession(home, q.pid, q.startTimeMs);
+  if (!live) return undefined;
+  const log = resolveSessionLog(home, live);
+  if (!log) return undefined;
+  const turn = readLastTurn(log);
+  return turn ? runtimeOfTurn(turn, (q.now ?? Date.now)()) : undefined;
+}
+
+/** A claude turn as a runtime, on the fixed 1 M window; undefined when nothing is known. */
+export function runtimeOfTurn(turn: LastTurn, observedAt: number): RuntimeV1 | undefined {
+  const r = buildRuntime(
+    {
+      model: turn.model,
+      effort: turn.effort,
+      contextTokens: turn.contextTokens,
+      // A window alone says nothing about this agent.
+      contextWindow: turn.contextTokens === undefined ? undefined : CLAUDE_CONTEXT_WINDOW,
+    },
+    observedAt,
+  );
+  return isEmptyRuntime(r) ? undefined : r;
+}

package/lib/codex_runtime.ts

@@ -0,0 +1,123 @@
+/**
+ * codex_runtime.ts — model, effort and context of a codex agent, left for the
+ * runner in `<presenceDir>/<instance_id>.runtime.json` (#708 step-03).
+ *
+ * Sources, measured on codex-cli 0.163.0 (plan 708 step-01):
+ * - `thread/start` / `thread/resume` answer the EFFECTIVE `model` and
+ *   `reasoningEffort` (null = not reported) — the template's pair is only what was
+ *   asked;
+ * - `thread/tokenUsage/updated` carries `tokenUsage.last.totalTokens` (occupation of
+ *   the last call, right after a compaction too) and `tokenUsage.modelContextWindow`.
+ *   `total` is cumulative over the thread's life and `last.inputTokens` drops to a
+ *   false 0 right after a compaction: neither is read.
+ *
+ * The file is rewritten only when a business field changes (`observed_at` excluded),
+ * atomically, so the runner never reads half of it.
+ */
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { isInstanceId, presenceDir } from "./presence_record.js";
+import { type RuntimeV1, buildRuntime, isEmptyRuntime, parseRuntime, sameRuntime } from "./runtime_info.js";
+
+/** A runtime file name — never a presence record (`<id>.json`) nor a temp file. */
+export const RUNTIME_FILE_RE = /^[0-9a-f]{32}\.runtime\.json$/;
+
+export function runtimeFilePath(identityBaseUrl: string, instanceId: string, lockDir?: string): string {
+  if (!isInstanceId(instanceId)) {
+    throw new Error(`runtimeFilePath: not an instance id: ${JSON.stringify(instanceId)}`);
+  }
+  return join(presenceDir(identityBaseUrl, lockDir), `${instanceId.toLowerCase()}.runtime.json`);
+}
+
+export interface RuntimeFile extends RuntimeV1 {
+  instance_id: string;
+}
+
+/** Atomic write: a reader sees the old file or the new one, never half of one. */
+export function writeRuntimeFile(path: string, instanceId: string, runtime: RuntimeV1): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  const body: RuntimeFile = { ...runtime, instance_id: instanceId.toLowerCase() };
+  writeFileSync(tmp, JSON.stringify(body), "utf8");
+  try {
+    renameSync(tmp, path);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+      // the tmp may already be gone; the rename error is the one that matters
+    }
+    throw err;
+  }
+}
+
+/** The runtime in a file, or undefined when absent, torn or for another instance. */
+export function readRuntimeFile(path: string, instanceId: string): RuntimeV1 | undefined {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+  if (typeof parsed !== "object" || parsed === null) return undefined;
+  const { instance_id, ...rest } = parsed as Record<string, unknown>;
+  if (instance_id !== instanceId.toLowerCase()) return undefined;
+  return parseRuntime(rest);
+}
+
+const count = (n: unknown): number | undefined =>
+  typeof n === "number" && Number.isInteger(n) && n >= 0 ? n : undefined;
+
+/** Collects what codex says and writes the file when it changes. */
+export class CodexRuntimeWriter {
+  private model?: string;
+  private effort?: string;
+  private contextTokens?: number;
+  private contextWindow?: number;
+  private last: RuntimeV1 | undefined;
+
+  constructor(
+    private readonly path: string,
+    private readonly instanceId: string,
+    private readonly now: () => number = Date.now,
+    private readonly write: (path: string, id: string, r: RuntimeV1) => void = writeRuntimeFile,
+    private readonly log: (line: string) => void = (l) => process.stderr.write(l),
+  ) {}
+
+  /** The answer to `thread/start` or `thread/resume`. */
+  onThread(result: unknown): void {
+    const r = (typeof result === "object" && result !== null ? result : {}) as Record<string, unknown>;
+    if (typeof r.model === "string") this.model = r.model;
+    // null = "not reported": keep what we knew rather than forget it.
+    if (typeof r.reasoningEffort === "string") this.effort = r.reasoningEffort;
+    this.flush();
+  }
+
+  /** The params of `thread/tokenUsage/updated`. */
+  onTokenUsage(params: unknown): void {
+    const usage = (params as { tokenUsage?: { last?: { totalTokens?: unknown }; modelContextWindow?: unknown } } | null)
+      ?.tokenUsage;
+    const tokens = count(usage?.last?.totalTokens);
+    const window = count(usage?.modelContextWindow);
+    // Both terms or neither: a percent from a stale numerator and a fresh window is a guess.
+    if (tokens === undefined || window === undefined || window === 0) return;
+    this.contextTokens = tokens;
+    this.contextWindow = window;
+    this.flush();
+  }
+
+  private flush(): void {
+    const next = buildRuntime(
+      { model: this.model, effort: this.effort, contextTokens: this.contextTokens, contextWindow: this.contextWindow },
+      this.now(),
+    );
+    if (isEmptyRuntime(next) || sameRuntime(this.last, next)) return;
+    try {
+      this.write(this.path, this.instanceId, next);
+      this.last = next;
+    } catch (err) {
+      // The file serves the web only: an agent never dies of it. Retried on the next change.
+      this.log(`[codex-runtime] write failed (${this.path}): ${String(err)}\n`);
+    }
+  }
+}

package/lib/parent_watchdog.ts

@@ -164,6 +164,8 @@ export interface ParentWatchdogOptions {
 
 export interface ParentWatchdogHandle {
   stop: () => void;
+  /** The agent ancestor resolved at startup (#708: the runner reads its session log). */
+  agent: AgentIdentity | null;
 }
 
 const DEFAULT_INTERVAL_MS = 5000;
@@ -233,7 +235,7 @@ export function startParentWatchdog(
 
   if (!identity) {
     log("[viber-channel] parent watchdog disabled (no resolvable agent ancestor)\n");
-    return { stop: () => {} };
+    return { stop: () => {}, agent: null };
   }
 
   const watched = identity;
@@ -272,5 +274,6 @@ export function startParentWatchdog(
       stopped = true;
       clearTimer(handle);
     },
+    agent: watched,
   };
 }

package/lib/presence_trigger.ts

@@ -47,7 +47,7 @@ export interface PresenceTrigger {
   stop: () => void;
 }
 
-/** The agent records of a presence folder: `<instance_id>.json`, never `*.coverage.json`. */
+/** The agent records of a presence folder: `<instance_id>.json`, never `*.coverage.json` nor `*.runtime.json`. */
 export function listPresenceRecords(dir: string): Map<string, number> | null {
   let names: string[];
   try {
@@ -57,7 +57,9 @@ export function listPresenceRecords(dir: string): Map<string, number> | null {
   }
   const out = new Map<string, number>();
   for (const name of names) {
-    if (!name.endsWith(".json") || name.endsWith(".coverage.json")) continue;
+    // #708: runtime files have their own trigger (runner_runtime.ts) — counted twice they would
+    // queue a second beat for one change.
+    if (!name.endsWith(".json") || name.endsWith(".coverage.json") || name.endsWith(".runtime.json")) continue;
     try {
       out.set(name, statSync(join(dir, name)).mtimeMs);
     } catch {

package/lib/runner_roster.ts

@@ -30,6 +30,8 @@ import {
   readPresenceRecord,
 } from "./presence_record.js";
 import { enumerateStartTimes } from "./process_start.js";
+import { runtimeFilePath } from "./codex_runtime.js";
+import { type RuntimeDelta, type RuntimeSource, type RuntimeTracker } from "./runner_runtime.js";
 import { announcedCapabilitiesVersion } from "./gateway_features.js";
 import { runnerIdentity } from "./runner_exec.js";
 import * as reg from "./runner_registry.js";
@@ -92,6 +94,8 @@ export interface CollectedRoster {
   notes: string[];
   /** #687: one line per ended agent OBSERVED (logged even if `capRoster` defers its report), for the runner's log (`endLine`). */
   ends: string[];
+  /** #708: where to read what each PRESENT agent runs on — exactly the present this beat carries. */
+  runtimeSources: RuntimeSource[];
 }
 
 /** The process table: pid → start time, or `undefined` when the instrument did not see. */
@@ -111,6 +115,7 @@ function emptyCollected(note?: string): CollectedRoster {
     endedFiles: new Map(),
     notes: note === undefined ? [] : [note],
     ends: [],
+    runtimeSources: [],
   };
 }
 
@@ -204,6 +209,7 @@ export async function collectRoster(deps: CollectDeps): Promise<CollectedRoster>
         created_at: record.created_at,
         job_name: record.job_name,
       });
+      out.runtimeSources.push({ instance_id: record.instance_id });
     } else {
       out.roster[c.kind].push(record.instance_id);
       out.endedFiles.set(record.instance_id, { path, content: JSON.stringify(record) });
@@ -229,6 +235,7 @@ function capRoster(c: CollectedRoster): CollectedRoster {
   // The registry must only learn what this beat actually told the server (Codex).
   const sentPresent = new Set(keptPresent.map((p) => p.instance_id));
   c.seen = c.seen.filter((s) => sentPresent.has(s.instance_id));
+  c.runtimeSources = c.runtimeSources.filter((s) => sentPresent.has(s.instance_id));
   c.roster = { present: keptPresent, closed: keptClosed, down: keptDown };
   c.notes.push(`roster capped at ${ROSTER_MAX} (had ${total}); the rest goes next beat`);
   return c;
@@ -349,6 +356,11 @@ export function applyAck(collected: CollectedRoster, ack: RosterAck, deps: Apply
     } catch {
       // no coverage for it: nothing to clean
     }
+    try {
+      unlinkSync(runtimeFilePath(deps.identityBaseUrl, id, deps.lockDir));
+    } catch {
+      // #708: no runtime file for it (an agent that never reported)
+    }
   }
   return removed;
 }
@@ -369,6 +381,8 @@ export interface RosterBeatDeps {
   headers?: () => Record<string, string>;
   /** #647: the announced capabilities version (default: the cached gateway probe). */
   capabilitiesVersion?: () => 1 | 2;
+  /** #708: what each present agent runs on; absent = the beat carries no `runtime`. */
+  runtime?: RuntimeTracker;
 }
 
 /**
@@ -444,6 +458,16 @@ async function rosterBeatOnce(auth: RosterBeatAuth, deps: RosterBeatDeps): Promi
   const { closes: pendingCloses, replaced } = pendingClosesOf(identity, deps.lockDir, collected.roster);
   collected.roster.closed.push(...pendingCloses);
 
+  const beatBody: Record<string, unknown> = {
+    capabilities: { runtimes: ["claude-code", "codex", "gemma"], platform: process.platform, version: (deps.capabilitiesVersion ?? announcedCapabilitiesVersion)() },
+    // #627 (JP, decision A): the new instance of each pair takes the old one's
+    // conversations — the server re-invites it once it is online.
+    roster: replaced.length > 0 ? { ...collected.roster, replaced } : collected.roster,
+  };
+  // #708: the roster first; runtime entries only take the room it leaves under the cap.
+  const runtimeSent = withRuntime(beatBody, collected.runtimeSources, deps.runtime);
+  const body = JSON.stringify(beatBody);
+
   let resp: Response;
   try {
     resp = await (deps.fetchImpl ?? fetch)(`${auth.base_url}/api/runners/${auth.runner_id}/heartbeat`, {
@@ -455,12 +479,7 @@ async function rosterBeatOnce(auth: RosterBeatAuth, deps: RosterBeatDeps): Promi
         "Content-Type": "application/json",
         ...(deps.headers?.() ?? {}),
       },
-      body: JSON.stringify({
-        capabilities: { runtimes: ["claude-code", "codex", "gemma"], platform: process.platform, version: (deps.capabilitiesVersion ?? announcedCapabilitiesVersion)() },
-        // #627 (JP, decision A): the new instance of each pair takes the old one's
-        // conversations — the server re-invites it once it is online.
-        roster: replaced.length > 0 ? { ...collected.roster, replaced } : collected.roster,
-      }),
+      body,
     });
   } catch {
     return "ok"; // best-effort: nothing acknowledged, nothing changed
@@ -473,7 +492,10 @@ async function rosterBeatOnce(auth: RosterBeatAuth, deps: RosterBeatDeps): Promi
     return "ok";
   }
 
-  const ack = parseRosterAck(await resp.json().catch(() => null));
+  const ackBody: unknown = await resp.json().catch(() => null);
+  const ack = parseRosterAck(ackBody);
+  // #708: an entry counts as sent only once the server names it as stored.
+  if (runtimeSent) deps.runtime?.ack(storedRuntime(runtimeSent, ackBody));
   // A beat whose ended records are never acknowledged is not dangerous (coverage and
   // leases are still served) but it is SILENT: say it once it lasts (Opus, step-05).
   if (collected.endedFiles.size > 0 && !ack.presence_applied) {
@@ -584,3 +606,35 @@ export function pendingClosesOf(
   }
   return { closes, replaced };
 }
+
+/** `,"runtime":{}` — what the field costs before its first entry. */
+const RUNTIME_FIELD_BYTES = Buffer.byteLength(',"runtime":{}', "utf8");
+
+/**
+ * #708: add the runtime delta to a beat body, in the room the rest leaves under
+ * `HEARTBEAT_MAX_BODY_BYTES`. Returns what was added (to acknowledge on success), or
+ * undefined when nothing was.
+ */
+export function withRuntime(
+  body: Record<string, unknown>,
+  sources: readonly RuntimeSource[],
+  tracker: RuntimeTracker | undefined,
+): RuntimeDelta | undefined {
+  if (!tracker) return undefined;
+  tracker.setSources(sources);
+  tracker.poll();
+  const room = HEARTBEAT_MAX_BODY_BYTES - Buffer.byteLength(JSON.stringify(body), "utf8") - RUNTIME_FIELD_BYTES;
+  const delta = room > 0 ? tracker.delta(room) : {};
+  if (Object.keys(delta).length === 0) return undefined;
+  body.runtime = delta;
+  return delta;
+}
+
+/** #708: the entries of `sent` the server answered as stored (`runtime_applied: [ids]`). */
+export function storedRuntime(sent: RuntimeDelta, ackBody: unknown): RuntimeDelta {
+  const ids = (ackBody as { runtime_applied?: unknown } | null)?.runtime_applied;
+  if (!Array.isArray(ids)) return {};
+  const out: RuntimeDelta = {};
+  for (const id of ids) if (typeof id === "string" && id in sent) out[id] = sent[id] as RuntimeDelta[string];
+  return out;
+}

package/lib/runner_runtime.ts

@@ -0,0 +1,187 @@
+/**
+ * runner_runtime.ts — the runner's side of #708: what each present agent runs on,
+ * sent to the server ONLY when it changes.
+ *
+ * Source: `<presenceDir>/<id>.runtime.json`, written by the agent's own process — the
+ * codex bridge on each turn, the claude channel after each reply (JP's rule, a round
+ * trip: claude_runtime_publisher.ts). The runner never reads a session log: it stats
+ * these small files and re-reads one only when its size or mtime moved.
+ *
+ * On the wire, `runtime` sits NEXT TO the roster, as a delta: an instance absent
+ * from it means "no opinion", `null` means "clear it", an object is the value. The
+ * roster is serialized first; runtime entries only take the room that is left under
+ * the body cap — presence is never lost to metadata. An entry counts as sent only once
+ * the server names it in `runtime_applied: [ids]`; until then it rides the next beat.
+ *
+ * "Changed" means what the chip shows changed (`sameRuntime`): `observed_at` and the
+ * raw token count are never compared.
+ */
+import { statSync } from "node:fs";
+import { readRuntimeFile, runtimeFilePath } from "./codex_runtime.js";
+import { type RuntimeV1, sameRuntime } from "./runtime_info.js";
+
+export interface RuntimeSource {
+  instance_id: string;
+}
+
+export type RuntimeDelta = Record<string, RuntimeV1 | null>;
+
+export interface RuntimeTrackerDeps {
+  identityBaseUrl: string;
+  lockDir?: string;
+  /** File signature (size + mtime), or undefined when the file is absent. */
+  signature?: (path: string) => string | undefined;
+}
+
+function fileSignature(path: string): string | undefined {
+  try {
+    const s = statSync(path);
+    return `${s.size}:${s.mtimeMs}`;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Bytes `"id":<value>,` adds to a JSON object. */
+function entryBytes(id: string, value: RuntimeV1 | null): number {
+  return Buffer.byteLength(`${JSON.stringify(id)}:${JSON.stringify(value)},`, "utf8");
+}
+
+interface Observed {
+  value: RuntimeV1 | undefined;
+  /** What was read, so an unchanged file is not read again. */
+  key: string | undefined;
+}
+
+export class RuntimeTracker {
+  private sources = new Map<string, RuntimeSource>();
+  private observed = new Map<string, Observed>();
+  /** Acknowledged by the server. Absent = never sent by this runner life. */
+  private sent = new Map<string, RuntimeV1 | null>();
+  private readonly signature: (path: string) => string | undefined;
+
+  constructor(private readonly deps: RuntimeTrackerDeps) {
+    this.signature = deps.signature ?? fileSignature;
+  }
+
+  /** The present agents of the last roster. An agent gone is forgotten: the server clears it on its end. */
+  setSources(list: readonly RuntimeSource[]): void {
+    const next = new Map(list.map((s) => [s.instance_id, s]));
+    for (const id of this.sources.keys()) {
+      if (!next.has(id)) {
+        this.observed.delete(id);
+        this.sent.delete(id);
+      }
+    }
+    this.sources = next;
+  }
+
+  /** Re-observe every source; true when some value changed since the last observation. */
+  poll(): boolean {
+    let changed = false;
+    for (const id of this.sources.keys()) {
+      const before = this.observed.get(id);
+      const after = this.observe(id, before);
+      this.observed.set(id, after);
+      if (!sameRuntime(before?.value, after.value)) changed = true;
+    }
+    return changed;
+  }
+
+  /** The entries the server does not hold yet, by instance id, within `budgetBytes`. */
+  delta(budgetBytes: number): RuntimeDelta {
+    const out: RuntimeDelta = {};
+    let room = budgetBytes;
+    for (const id of [...this.sources.keys()].sort()) {
+      const value = this.observed.get(id)?.value ?? null;
+      // Never sent: say it once, `null` included — a previous runner life may have left a value.
+      if (this.sent.has(id) && sameRuntime(this.sent.get(id), value)) continue;
+      const cost = entryBytes(id, value);
+      if (cost > room) break; // deterministic: the rest, in id order, goes next beat
+      out[id] = value;
+      room -= cost;
+    }
+    return out;
+  }
+
+  /** The server stored these entries. */
+  ack(sent: RuntimeDelta): void {
+    for (const [id, value] of Object.entries(sent)) {
+      if (this.sources.has(id)) this.sent.set(id, value);
+    }
+  }
+
+  private observe(id: string, before: Observed | undefined): Observed {
+    let path: string;
+    try {
+      path = runtimeFilePath(this.deps.identityBaseUrl, id, this.deps.lockDir);
+    } catch {
+      return { value: undefined, key: undefined };
+    }
+    const sig = this.signature(path);
+    if (sig === undefined) return { value: undefined, key: undefined };
+    const key = `${path}|${sig}`;
+    if (before && before.key === key) return before;
+    const value = readRuntimeFile(path, id);
+    // Present but unreadable (a read racing a rename, an antivirus holding it): keep what was
+    // known — only an ABSENT file clears the chip. The key is not advanced, so it is read again.
+    if (value === undefined) return before ?? { value: undefined, key: undefined };
+    // Same thing shown: keep the earlier observation, `observed_at` included.
+    if (before && sameRuntime(before.value, value)) return { value: before.value, key };
+    return { value, key };
+  }
+}
+
+export const RUNTIME_SCAN_MS = 2_000;
+export const RUNTIME_DEBOUNCE_MS = 500;
+
+export interface RuntimeTriggerOptions {
+  tracker: RuntimeTracker;
+  onChange: () => void;
+  intervalMs?: number;
+  debounceMs?: number;
+  setInterval?: (fn: () => void, ms: number) => unknown;
+  clearInterval?: (handle: unknown) => void;
+  setTimeout?: (fn: () => void, ms: number) => unknown;
+  clearTimeout?: (handle: unknown) => void;
+}
+
+/**
+ * Beat when what an agent runs on CHANGES — a local poll, no request otherwise. Only a
+ * fresh local change triggers: a value the server has not acknowledged yet (a failed
+ * beat) rides the next periodic beat instead of hammering a failing server. The first
+ * poll is the BASELINE, covered by the runner's start-up beat.
+ */
+export function startRuntimeTrigger(opts: RuntimeTriggerOptions): { scan: () => void; stop: () => void } {
+  const setIv = opts.setInterval ?? ((fn: () => void, ms: number) => unrefd(setInterval(fn, ms)));
+  const clearIv = opts.clearInterval ?? ((h: unknown) => clearInterval(h as ReturnType<typeof setInterval>));
+  const setTo = opts.setTimeout ?? ((fn: () => void, ms: number) => unrefd(setTimeout(fn, ms)));
+  const clearTo = opts.clearTimeout ?? ((h: unknown) => clearTimeout(h as ReturnType<typeof setTimeout>));
+  const debounceMs = opts.debounceMs ?? RUNTIME_DEBOUNCE_MS;
+  let pending: unknown = null;
+  let stopped = false;
+  opts.tracker.poll();
+  const scan = (): void => {
+    if (stopped) return;
+    if (!opts.tracker.poll() || pending !== null) return;
+    pending = setTo(() => {
+      pending = null;
+      if (!stopped) opts.onChange();
+    }, debounceMs);
+  };
+  const timer = setIv(scan, opts.intervalMs ?? RUNTIME_SCAN_MS);
+  return {
+    scan,
+    stop: () => {
+      stopped = true;
+      clearIv(timer);
+      if (pending !== null) clearTo(pending);
+      pending = null;
+    },
+  };
+}
+
+function unrefd<T>(h: T): T {
+  (h as { unref?: () => void }).unref?.();
+  return h;
+}

package/lib/runner_stream.ts

@@ -23,6 +23,7 @@ import { type ExecDeps, reconcileOnce, runnerIdentity } from "./runner_exec.js";
 import { runRosterBeat } from "./runner_roster.js";
 import { presenceDir } from "./presence_record.js";
 import { startPresenceTrigger } from "./presence_trigger.js";
+import { RuntimeTracker, startRuntimeTrigger } from "./runner_runtime.js";
 
 /** Remove leftover temp spec files (`.viber/runner-specs/`) from a prior crash
  *  at daemon start — they may hold sensitive rolePrompts (Codex P1-1). The
@@ -129,8 +130,8 @@ async function safeReconcile(auth: RunnerAuth, deps: ExecDeps = {}): Promise<voi
  *
  *  #627: the beat now carries the machine's ROSTER — the only presence signal of
  *  the agents this runner vouches for (`runner_roster.ts`). */
-async function sendHeartbeat(auth: RunnerAuth, queueIfBusy = false): Promise<"ok" | "revoked"> {
-  return runRosterBeat(auth, { headers: cfAccessHeaders }, { queueIfBusy });
+async function sendHeartbeat(auth: RunnerAuth, queueIfBusy = false, runtime?: RuntimeTracker): Promise<"ok" | "revoked"> {
+  return runRosterBeat(auth, { headers: cfAccessHeaders, runtime }, { queueIfBusy });
 }
 
 export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
@@ -174,8 +175,10 @@ export async function runPersistentRunnerStream(
   // Shared abort so a heartbeat-detected revocation tears down the live SSE now,
   // instead of waiting for the next reconnect.
   let currentAbort: AbortController | null = null;
+  // #708: what each present agent runs on, pushed with the beat when it changes.
+  const runtime = new RuntimeTracker({ identityBaseUrl: runnerIdentity(auth) });
   const beat = (queueIfBusy: boolean): void => {
-    void sendHeartbeat(auth, queueIfBusy)
+    void sendHeartbeat(auth, queueIfBusy, runtime)
       .then((r) => {
         if (r === "revoked") {
           revoked = true;
@@ -196,6 +199,8 @@ export async function runPersistentRunnerStream(
     dir: presenceDir(runnerIdentity(auth)),
     onChange: () => beat(true),
   });
+  // #708: and one more when what an agent runs on changes (a local poll, same request).
+  const runtimeTrigger = startRuntimeTrigger({ tracker: runtime, onChange: () => beat(true) });
   // Reconcile timer is a RE-JITTERED recursive setTimeout (not setInterval): each
   // tick draws a fresh crypto jitter so a fleet never re-synchronizes (Codex C6).
   let reconcileTimer: ReturnType<typeof setTimeout>;
@@ -247,6 +252,7 @@ export async function runPersistentRunnerStream(
   } finally {
     clearInterval(heartbeatTimer);
     presenceTrigger.stop();
+    runtimeTrigger.stop();
     clearTimeout(reconcileTimer!);
   }
 }

package/lib/runtime_info.ts

@@ -0,0 +1,102 @@
+/**
+ * runtime_info.ts — what an agent is running on, as the web shows it (#708).
+ *
+ * `RuntimeV1` is the contract of plan 708 step-01: model, effort and context
+ * occupation of ONE agent, observed locally (Claude's session log, Codex's
+ * token-usage notifications) and pushed by the runner when it changes.
+ *
+ * Two rules every producer and consumer shares:
+ * - an unknown field is OMITTED, never 0 — a 0 % looks plausible;
+ * - "changed" means what the chip shows changed: `observed_at` and the raw token
+ *   count are excluded from every comparison (`sameRuntime`), otherwise each re-read
+ *   or each call would beat the runner (#627 rule).
+ */
+
+/** JP's decision (2026-10-17): every Claude model he runs has a 1 M window. */
+export const CLAUDE_CONTEXT_WINDOW = 1_000_000;
+
+export const RUNTIME_SCHEMA_VERSION = 1;
+export const RUNTIME_MAX_BYTES = 512;
+const MODEL_MAX = 64;
+const EFFORT_MAX = 16;
+
+export interface RuntimeV1 {
+  v: 1;
+  model?: string;
+  effort?: string;
+  /** Input-side tokens of the LAST call — never a sum over the session. */
+  context_tokens?: number;
+  context_window?: number;
+  /** Integer 0..100. */
+  context_percent?: number;
+  /** Epoch ms of the observation; moves only with a business field. */
+  observed_at: number;
+}
+
+export interface RuntimeFields {
+  model?: string;
+  effort?: string;
+  contextTokens?: number;
+  contextWindow?: number;
+}
+
+const isCount = (n: unknown): n is number => typeof n === "number" && Number.isInteger(n) && n >= 0;
+
+/**
+ * Build a runtime from what is known. Anything missing or out of bounds is left
+ * out; the percent exists only when both its terms do, and is capped at 100.
+ */
+export function buildRuntime(fields: RuntimeFields, observedAt: number): RuntimeV1 {
+  const r: RuntimeV1 = { v: 1, observed_at: observedAt };
+  if (typeof fields.model === "string" && fields.model !== "" && fields.model.length <= MODEL_MAX) r.model = fields.model;
+  if (typeof fields.effort === "string" && fields.effort !== "" && fields.effort.length <= EFFORT_MAX) r.effort = fields.effort;
+  if (isCount(fields.contextTokens)) r.context_tokens = fields.contextTokens;
+  if (isCount(fields.contextWindow) && fields.contextWindow > 0) r.context_window = fields.contextWindow;
+  if (r.context_tokens !== undefined && r.context_window !== undefined) {
+    r.context_percent = Math.min(100, Math.round((r.context_tokens / r.context_window) * 100));
+  }
+  return r;
+}
+
+/**
+ * True when two observations show the same thing: model, effort, window and percent.
+ * `observed_at` is ignored, and so is `context_tokens`: it moves on every call of a
+ * working agent, and comparing it would beat the runner — and write D1 — at that pace.
+ * The token count travels with the value; a change is a change of what the chip shows.
+ */
+export function sameRuntime(a: RuntimeV1 | null | undefined, b: RuntimeV1 | null | undefined): boolean {
+  if (!a || !b) return !a && !b;
+  return (
+    a.model === b.model &&
+    a.effort === b.effort &&
+    a.context_window === b.context_window &&
+    a.context_percent === b.context_percent &&
+    // A count appearing or vanishing is a change; only its value is not compared.
+    (a.context_tokens === undefined) === (b.context_tokens === undefined)
+  );
+}
+
+/** True when nothing but the version and the timestamp is known. */
+export function isEmptyRuntime(r: RuntimeV1): boolean {
+  return Object.keys(r).every((k) => k === "v" || k === "observed_at");
+}
+
+/**
+ * Strict check of a received value: the WHOLE entry is rejected on any violation,
+ * never one field — no half-trusted value (plan 708, step-01 contract).
+ */
+export function parseRuntime(value: unknown): RuntimeV1 | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+  const v = value as Record<string, unknown>;
+  if (v.v !== RUNTIME_SCHEMA_VERSION) return undefined;
+  if (typeof v.observed_at !== "number" || !Number.isFinite(v.observed_at) || v.observed_at <= 0) return undefined;
+  const allowed = new Set(["v", "model", "effort", "context_tokens", "context_window", "context_percent", "observed_at"]);
+  if (Object.keys(v).some((k) => !allowed.has(k))) return undefined;
+  const str = (x: unknown, max: number): boolean => x === undefined || (typeof x === "string" && x !== "" && x.length <= max);
+  if (!str(v.model, MODEL_MAX) || !str(v.effort, EFFORT_MAX)) return undefined;
+  if (v.context_tokens !== undefined && !isCount(v.context_tokens)) return undefined;
+  if (v.context_window !== undefined && !(isCount(v.context_window) && v.context_window > 0)) return undefined;
+  if (v.context_percent !== undefined && !(isCount(v.context_percent) && v.context_percent <= 100)) return undefined;
+  if (Buffer.byteLength(JSON.stringify(v), "utf8") > RUNTIME_MAX_BYTES) return undefined;
+  return v as unknown as RuntimeV1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viber-channel",
-  "version": "0.8.40",
+  "version": "0.8.41",
   "description": "Voice + text MCP channel between a Claude Code session and the Viber UI (https://viber.dgypx.dev). Push transcripts to Claude; send_message tool delivers text back to the UI.",
   "type": "module",
   "bin": {

package/viber-channel.ts

@@ -54,6 +54,7 @@ import {
 import { channelPauseReason, type PresenceGate, startCoverageWatch } from "./lib/coverage_watch.ts";
 import { type PresenceEndReason, type PresenceRecordHandle, startPresenceRecord } from "./lib/presence_record.ts";
 import { startParentWatchdog } from "./lib/parent_watchdog.ts";
+import { ClaudeRuntimePublisher } from "./lib/claude_runtime_publisher.ts";
 import { acquireInstance, maybeAttachTeam, registerInstance } from "./lib/instance.ts";
 import { runPersistentControlStream } from "./lib/control_stream.ts";
 import { type DmWatermark, runDmStream } from "./lib/dm_stream.ts";
@@ -557,7 +558,22 @@ async function handleCallTool(
   }
 }
 
-mcp.setRequestHandler(CallToolRequestSchema, async (request) => toMcpToolResult(await handleCallTool(request)));
+// #708: after each reply on the channel, the agent's model, effort and context are
+// re-read from its claude's session log and left for the runner (JP: a round trip,
+// not a watch). Created here; the instance id is read when it publishes.
+const runtimePublisher = new ClaudeRuntimePublisher({
+  // Read at reply time: the watchdog starts after mcp.connect(), below.
+  getClaudePid: () => parentWatchdog.agent?.pid ?? null,
+  identityBaseUrl: WEB_URL,
+  getInstanceId: () => OWN_INSTANCE_ID,
+});
+
+mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const result = await handleCallTool(request);
+  const name = request.params.name;
+  if ((name === "send_message" || name === "message_agent") && !result.isError) runtimePublisher.afterReply();
+  return toMcpToolResult(result);
+});
 
 // Prevent duplicate instances (#166); fingerprint namespacing for different
 // projects (#267); session-id namespacing for concurrent launches of the same
@@ -603,7 +619,7 @@ if (blockingPid !== null) {
 // the cmd.exe/bunx spawn chain), it becomes a zombie that keeps beating and shows
 // "online" with no one answering. The watchdog watches the agent PID+identity and
 // exits the instant it's gone — the reliable backstop to the stdin "end" handler.
-startParentWatchdog({
+const parentWatchdog = startParentWatchdog({
   onParentGone: () => {
     scheduler?.cancel();
     releaseLock();

package/viber-codex-bridge.ts

@@ -119,6 +119,7 @@ import {
 import { startInstanceHeartbeat } from "./lib/heartbeat.ts";
 import { type PresenceGate, REASON_NO_RUNNER as REASON_STARTING, startCoverageWatch } from "./lib/coverage_watch.ts";
 import { startPresenceRecord } from "./lib/presence_record.ts";
+import { CodexRuntimeWriter, runtimeFilePath } from "./lib/codex_runtime.ts";
 import { startBridgeToolHost, type BridgeToolHost } from "./lib/bridge_tool_host.ts";
 import type { AgentToolsContext } from "./lib/agent_tools.ts";
 import type { OpenDmResult } from "./lib/peers.ts";
@@ -693,6 +694,14 @@ export class CodexAppServer {
   /** Set true once we intentionally `close()` so the exit handler can tell a
    * deliberate shutdown from an unexpected child death (#298). */
   private closing = false;
+  /** #708: model, effort and context left for the runner. Unset = not recorded. */
+  private runtime?: CodexRuntimeWriter;
+  /** #708: threads this bridge opened — a usage for any other thread is not this agent's. */
+  private readonly ownThreads = new Set<string>();
+
+  setRuntime(writer: CodexRuntimeWriter): void {
+    this.runtime = writer;
+  }
 
   /**
    * @param onUnexpectedExit fired ONLY when the Codex child dies on its own (not
@@ -840,6 +849,8 @@ export class CodexAppServer {
         // leaves this try (it must not fall back to a fresh thread and hide the problem).
         resumeMismatch = pairMismatch(this.pair, resumed, "thread/resume");
         if (resumeMismatch === undefined) {
+          this.ownThreads.add(resumedId);
+          this.runtime?.onThread(resumed);
           logTiming("ensureThread", nowMs() - t0, "outcome=resume");
           return resumedId;
         }
@@ -873,6 +884,8 @@ export class CodexAppServer {
     // #665: same check on a fresh thread — what codex SAYS it runs, not what we asked.
     const startMismatch = pairMismatch(this.pair, started, "thread/start");
     if (startMismatch !== undefined) this.stopOnPairMismatch(startMismatch);
+    this.ownThreads.add(threadId);
+    this.runtime?.onThread(started);
     state.threads[key] = {
       thread_id: threadId,
       conversation_id: options.conversationId,
@@ -998,6 +1011,12 @@ export class CodexAppServer {
       return;
     }
 
+    if (msg.method === "thread/tokenUsage/updated") {
+      const threadId = (msg.params as { threadId?: unknown } | undefined)?.threadId;
+      if (typeof threadId === "string" && this.ownThreads.has(threadId)) this.runtime?.onTokenUsage(msg.params);
+      return;
+    }
+
     if (msg.method === "turn/completed") {
       const params = msg.params as { threadId?: string; turn?: { id?: string; status?: unknown; error?: unknown } };
       const turnId = params.turn?.id;
@@ -1444,6 +1463,8 @@ function setupCodexRuntime(deps: {
   pauseReason: () => string | null;
   /** #665: the template's model/effort, or undefined. */
   pair: CodexPair | undefined;
+  /** #708: this instance's id — the runtime file the runner reads is keyed on it. */
+  instanceKey: string;
 }): { codex: CodexAppServer; toolHost: BridgeToolHost } {
   const { tracker } = deps;
   const bridgeToolsCtx: AgentToolsContext = {
@@ -1481,6 +1502,12 @@ function setupCodexRuntime(deps: {
     { url: toolHost.url, bearerEnvVar: "VIBER_MCP_TOKEN", bearerValue: toolHost.bearerToken },
     deps.pair,
   );
+  try {
+    codex.setRuntime(new CodexRuntimeWriter(runtimeFilePath(IDENTITY_URL, deps.instanceKey, LOCK_DIR()), deps.instanceKey));
+  } catch (err) {
+    process.stderr.write(`${LOG_PREFIX} runtime info disabled: ${safeErrorMessage(err)}
+`);
+  }
   return { codex, toolHost };
 }
 
@@ -1606,6 +1633,7 @@ export async function main(argv: string[] = process.argv.slice(2)): Promise<void
           requestShutdown: helpers.requestShutdown,
           pauseReason: helpers.pauseReason,
           pair,
+          instanceKey: identity.instanceKey,
         });
         codex = rt.codex;
         toolHost = rt.toolHost;
@@ -1674,6 +1702,7 @@ export async function main(argv: string[] = process.argv.slice(2)): Promise<void
       },
       pauseReason: () => gateRef.gate?.reason() ?? REASON_STARTING,
       pair,
+      instanceKey: res.instanceKey,
     });
     codex = rt.codex;
     toolHost = rt.toolHost;