borgmcp 5.2.0 → 5.4.0

package/src/codex-wake-resolve.ts

@@ -1,10 +1,9 @@
 /**
  * gh#855 — pure helpers for FRESH codex wake-target re-resolution.
  *
- * Root cause of codex deaf-when-idle: the wake target (socket + thread) was
- * resolved once at launch and never refreshed, so a missed/stale launch probe
- * left the drone permanently deaf. Phase 1 makes the waking borg-mcp child
- * authoritative about its OWN live app-server socket — the socket is injected
+ * Root cause of codex deaf-when-idle: stale thread selection could leave the
+ * drone permanently deaf. The waking borg-mcp child is authoritative about its
+ * OWN live app-server socket — the socket is injected
  * into the child's pinned env at spawn (codex-remote.ts, via the #851 `-c
  * mcp_servers.borg.env.X` channel) — and re-resolves the loaded thread FRESH on
  * every wake (loadedThreadIds is a re-runnable RPC).
@@ -15,7 +14,7 @@
 /** Pinned-env var carrying THIS drone's live app-server socket (set at spawn). */
 export const BORG_CODEX_APP_SERVER_SOCKET_ENV = 'BORG_CODEX_APP_SERVER_SOCKET';
 
-/** The live app-server socket for this borg-mcp child, or null (un-upgraded launch). */
+/** The live app-server socket for this borg-mcp child. */
 export function codexAppServerSocketFromEnv(env: NodeJS.ProcessEnv = process.env): string | null {
   const v = env[BORG_CODEX_APP_SERVER_SOCKET_ENV];
   return v && v.length > 0 ? v : null;
@@ -37,6 +36,16 @@ export interface CodexThreadInfo {
   id: string;
   cwd?: string;
   updatedAt?: number;
+  source?: unknown;
+  ephemeral?: boolean;
+  threadSource?: string;
+  preview?: string;
+  turns?: unknown[];
+}
+
+export function isCodexSubagentSource(source: unknown): boolean {
+  if (!source || typeof source !== 'object' || Array.isArray(source)) return false;
+  return 'subagent' in source || 'subAgent' in source;
 }
 
 /**
@@ -44,15 +53,22 @@ export interface CodexThreadInfo {
  * is fresh-per-launch / single-session, so the common case is exactly one loaded
  * thread. When more than one is loaded, prefer the thread whose cwd matches this
  * drone's working directory (sibling worktrees have distinct cwds), then the
- * newest by updatedAt — always deterministic. No loaded thread → null (no wake
+ * newest by updatedAt, without preferring an empty thread over one with turns.
+ * System, ephemeral and subagent threads are never candidates. No loaded thread → null (no wake
  * this cycle; the next wake retries, so a transient empty list never causes
  * permanent deafness).
  */
 export function pickFreshThread(threads: CodexThreadInfo[], opts: { cwd: string }): string | null {
-  if (threads.length === 0) return null;
-  if (threads.length === 1) return threads[0].id;
-  const cwdMatches = threads.filter((t) => t.cwd === opts.cwd);
-  const pool = cwdMatches.length > 0 ? cwdMatches : threads;
+  const rootThreads = threads.filter((thread) =>
+    !isCodexSubagentSource(thread.source) && thread.ephemeral !== true &&
+    (thread.threadSource === undefined || thread.threadSource === 'user'));
+  if (rootThreads.length === 0) return null;
+  if (rootThreads.length === 1) return rootThreads[0].id;
+  const cwdMatches = rootThreads.filter((t) => t.cwd === opts.cwd);
+  let pool = cwdMatches.length > 0 ? cwdMatches : rootThreads;
+  if (pool.some((thread) => (thread.turns?.length ?? 0) > 0)) {
+    pool = pool.filter((thread) => (thread.turns?.length ?? 0) > 0 || !!thread.preview);
+  }
   let best = pool[0];
   for (const t of pool) {
     if ((t.updatedAt ?? 0) > (best.updatedAt ?? 0)) best = t;
@@ -60,43 +76,6 @@ export function pickFreshThread(threads: CodexThreadInfo[], opts: { cwd: string
   return best.id;
 }
 
-/**
- * Pure prune: drop wake-target entries whose app-server socket is positively
- * dead (liveness === false), so the file self-heals. Keeps alive (true) and
- * indeterminate (null) entries — false-deaf-avoidance, mirroring
- * checkCodexBridgeHealthy's tri-state. Returns the surviving map + whether
- * anything changed (so the caller writes only on change).
- */
-export function pruneDeadWakeTargets<T extends { socketPath: string }>(
-  targets: Record<string, T>,
-  socketLiveness: (socketPath: string) => boolean | null
-): { targets: Record<string, T>; changed: boolean } {
-  const out: Record<string, T> = {};
-  let changed = false;
-  for (const [key, t] of Object.entries(targets)) {
-    if (socketLiveness(t.socketPath) === false) {
-      changed = true;
-      continue;
-    }
-    out[key] = t;
-  }
-  return { targets: out, changed };
-}
-
-/**
- * Whether the freshly-resolved target differs from what's already recorded —
- * so the self-healing cache write happens only on change (no file thrash on a
- * busy cube re-resolving the same socket+thread every wake).
- */
-export function wakeTargetChanged(
-  existing: { socketPath: string; threadId: string } | null,
-  fresh: { socketPath: string; threadId: string }
-): boolean {
-  return (
-    !existing || existing.socketPath !== fresh.socketPath || existing.threadId !== fresh.threadId
-  );
-}
-
 // ─── gh#857 Phase 2: durable retry + heartbeat (pure helpers) ───────────────
 
 /** Base backoff for the first retry of a dropped/deferred wake. */

package/src/config-utils.ts

@@ -1293,8 +1293,8 @@ export function addCodexMcpServer(): void {
     // Codex MCP config when the operator has explicitly set it.
     const apiUrl = process.env.BORG_API_URL;
     // Identity is durable configuration; remote wake is a per-launch
-    // transport capability. Do not persist a transport marker here: a future
-    // Codex child may launch without a live --remote socket.
+    // transport capability pinned by the Borg-owned app-server. Do not persist
+    // that transport marker in the user's static Codex configuration.
     const apiUrlEnvArg = apiUrl ? ` --env BORG_API_URL=${shellQuote(apiUrl)}` : '';
     const stateRoot = process.env[BORG_STATE_ROOT_ENV];
     const stateRootEnvArg = stateRoot

package/src/cubes.ts

@@ -18,7 +18,6 @@
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
-import { pruneDeadWakeTargets } from './codex-wake-resolve.js';
 import { borgConfigRoot } from './private-root.js';
 import {
   getActiveSeatCredential,
@@ -38,15 +37,14 @@ import {
 // The unified 0600 seat store (seats.ts / seats.json) is now the SOLE home of the
 // per-worktree ACTIVE-CUBE seat map: each seat = credential + worktree binding +
 // display as ONE atomic record. cubes.json no longer holds a seat map — the
-// functions below are thin adapters over seats.ts. Only launch.json,
-// codex-wake-targets.json, and the inbox tree remain owned by this module.
+// functions below are thin adapters over seats.ts. Only launch.json and the
+// inbox tree remain owned by this module.
 
 /** Re-exported from seats.ts for call-site parity (the retired cross-store name). */
 export type { SeatExpectation as ExpectedBinding } from './seats.js';
 
 const CUBES_DIR = borgConfigRoot();
 const LAUNCH_FILE = join(CUBES_DIR, 'launch.json');
-const CODEX_WAKE_TARGETS_FILE = join(CUBES_DIR, 'codex-wake-targets.json');
 const INBOX_DIR = join(CUBES_DIR, 'inboxes');
 
 export type BorgCli = 'claude' | 'codex' | 'opencode';
@@ -206,16 +204,6 @@ function unreadableStateError(filePath: string): Error {
   return new Error(`Borg state file is unreadable; refusing to overwrite it: ${filePath}`);
 }
 
-export interface CodexWakeTargetRecord {
-  threadId: string;
-  socketPath: string;
-  updatedAt: string;
-}
-
-interface CodexWakeTargetsFile {
-  targets: Record<string, CodexWakeTargetRecord>;
-}
-
 /**
  * Walk up from cwd looking for a .git directory. If found, return that
  * directory. If not found by filesystem root, return the original cwd.
@@ -369,44 +357,6 @@ async function writeLaunchFile(data: LaunchFile): Promise<void> {
   await atomicWriteFile(LAUNCH_FILE, JSON.stringify(data, null, 2) + '\n');
 }
 
-function codexWakeTargetKey(cubeId: string, droneId: string): string {
-  if (!UUID_RE.test(cubeId)) throw new Error(`Invalid cubeId: ${cubeId}`);
-  if (!UUID_RE.test(droneId)) throw new Error(`Invalid droneId: ${droneId}`);
-  return `${cubeId}:${droneId}`;
-}
-
-function isCodexWakeTargetsFile(data: any): data is CodexWakeTargetsFile {
-  return (
-    data !== null &&
-    typeof data === 'object' &&
-    typeof data.targets === 'object' &&
-    data.targets !== null &&
-    !Array.isArray(data.targets)
-  );
-}
-
-async function readCodexWakeTargetsFile(): Promise<StateFileRead<CodexWakeTargetsFile>> {
-  let raw: string;
-  try {
-    raw = await readFile(CODEX_WAKE_TARGETS_FILE, 'utf8');
-  } catch (error: any) {
-    if (error?.code === 'ENOENT') return null;
-    throw error;
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    return isCodexWakeTargetsFile(parsed) ? parsed : UNREADABLE_STATE;
-  } catch {
-    return UNREADABLE_STATE;
-  }
-}
-
-async function writeCodexWakeTargetsFile(data: CodexWakeTargetsFile): Promise<void> {
-  // atomicWriteFile handles the mkdir + 0o600 mode, and the temp+rename keeps
-  // a concurrent reader from seeing a half-written file (gh#894, gh#901).
-  await atomicWriteFile(CODEX_WAKE_TARGETS_FILE, JSON.stringify(data, null, 2) + '\n');
-}
-
 /**
  * Get the currently-active cube for the current project, or null if not
  * assimilated in this project. Entries written by older client versions
@@ -749,51 +699,3 @@ export async function setProjectCliPreference(cli: BorgCli, dir?: string): Promi
   next.projects[findProjectRoot(dir)] = { cli };
   await writeLaunchFile(next);
 }
-
-export async function setCodexWakeTarget(
-  cubeId: string,
-  droneId: string,
-  target: Omit<CodexWakeTargetRecord, 'updatedAt'>
-): Promise<void> {
-  const existing = await readCodexWakeTargetsFile();
-  if (existing === UNREADABLE_STATE) throw unreadableStateError(CODEX_WAKE_TARGETS_FILE);
-  const next = existing ?? { targets: {} };
-  next.targets[codexWakeTargetKey(cubeId, droneId)] = {
-    ...target,
-    updatedAt: new Date().toISOString(),
-  };
-  await writeCodexWakeTargetsFile(next);
-}
-
-export async function getCodexWakeTarget(
-  cubeId: string,
-  droneId: string
-): Promise<CodexWakeTargetRecord | null> {
-  const existing = await readCodexWakeTargetsFile();
-  if (existing === UNREADABLE_STATE) throw unreadableStateError(CODEX_WAKE_TARGETS_FILE);
-  if (!existing) return null;
-  const target = existing.targets[codexWakeTargetKey(cubeId, droneId)];
-  if (!target || typeof target.threadId !== 'string' || typeof target.socketPath !== 'string') {
-    return null;
-  }
-  return target;
-}
-
-/**
- * gh#855: drop wake-target entries whose app-server socket is positively dead,
- * so the file self-heals (stale dead-socket entries from crashed prior launches
- * don't linger and mislead probeCodexBridgeArmed / health-beat). Pure prune
- * decision lives in codex-wake-resolve.ts (false-deaf-avoidance: keeps alive +
- * indeterminate); this is the thin read → prune → write-only-on-change glue.
- * The liveness check is injected (claude.ts wires checkCodexBridgeHealthy) so
- * cubes.ts stays free of the codex-remote dependency.
- */
-export async function pruneDeadCodexWakeTargets(
-  socketLiveness: (socketPath: string) => boolean | null
-): Promise<void> {
-  const existing = await readCodexWakeTargetsFile();
-  if (existing === UNREADABLE_STATE) throw unreadableStateError(CODEX_WAKE_TARGETS_FILE);
-  if (!existing) return;
-  const { targets, changed } = pruneDeadWakeTargets(existing.targets, socketLiveness);
-  if (changed) await writeCodexWakeTargetsFile({ ...existing, targets });
-}

package/src/index.ts

@@ -100,6 +100,7 @@ import {
   regenWakePathDroneLabel,
 } from './regen-format.js';
 import { startLogStream, getStreamStatus } from './log-stream.js';
+import { resolveAgentSessionIdentity } from './agent-session-identity.js';
 import { isMcpReadinessProbe } from './readiness-probe.js';
 import { runMcpStartupServices } from './startup-services.js';
 import { TOOL_MANIFEST, type ToolManifestEntry } from './tool-manifest.js';
@@ -913,8 +914,12 @@ export async function main() {
             cubeName: active?.name ?? null,
             humanAgo,
           });
+          const agentSession = await resolveAgentSessionIdentity();
+          const identityText = agentSession.kind === 'known'
+            ? `\n\nAgent session source: ${agentSession.source}\nSession id: ${JSON.stringify(agentSession.id)}\nIdentity age: ${Math.max(0, Date.now() - Date.parse(agentSession.observedAt))} ms (observed ${agentSession.observedAt})`
+            : `\n\nAgent session: unknown (${agentSession.reason}); ARRIVAL is not suppressed across reconnects.`;
           return {
-            content: [{ type: 'text', text: silentInertWarning + text }],
+            content: [{ type: 'text', text: silentInertWarning + text + identityText }],
             structuredContent: {
               status,
               wake_path: wakePath,
@@ -1076,16 +1081,16 @@ export async function main() {
           seedDisplayIdentity(active);
           const displayIdentity = renderDisplayIdentity(active);
           const lifecycleSignal = lifecycleSignalForMessage(finalMessage);
+          const agentSession = lifecycleSignal === 'arrival' ? await resolveAgentSessionIdentity() : undefined;
           if (lifecycleSignal) {
-            const decision = await shouldSuppressLifecycleLog(active, finalMessage);
+            const decision = await shouldSuppressLifecycleLog(active, finalMessage, agentSession);
             if (decision.suppress) {
-              await recordLifecycleLog(active, finalMessage);
               if (lifecycleSignal === 'arrival') markArrivalAnnouncedThisProcess();
               return {
                 content: [
                   {
                     type: 'text',
-                    text: `Suppressed duplicate ${decision.signal?.toUpperCase()} lifecycle log for ${displayIdentity.droneLabel}; recent cube log already contains this signal.`,
+                    text: `Suppressed duplicate ${decision.signal?.toUpperCase()} lifecycle log for ${displayIdentity.droneLabel}; this signal is already recorded locally for the current ${decision.signal === 'arrival' ? 'agent session' : 'idle period'}.`,
                   },
                 ],
                 structuredContent: {
@@ -1110,7 +1115,7 @@ export async function main() {
             serverTrustIdentity: active.serverTrustIdentity,
           };
           const result = await appendLog(active.sessionToken, active.apiUrl, finalMessage, appendOpts);
-          await recordLifecycleLog(active, finalMessage);
+          await recordLifecycleLog(active, finalMessage, agentSession);
           if (lifecycleSignal === 'arrival') markArrivalAnnouncedThisProcess();
           let recipientDrones: any[] = [];
           if (result.entry.visibility === 'direct' && result.entry.recipient_drone_ids.length > 0) {

package/src/lifecycle-log-guard.ts

@@ -1,9 +1,12 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
+import { mkdir, open, readFile, rename, stat, unlink, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { borgConfigRoot } from './private-root.js';
+import type { AgentSessionIdentity } from './agent-session-identity.js';
 
 const STATE_FILE = join(borgConfigRoot(), 'lifecycle-log-state.json');
-const ARRIVAL_DUPLICATE_WINDOW_MS = 10 * 60 * 1000;
+const STATE_LOCK = `${STATE_FILE}.lock`;
+const UNKNOWN_SESSION: AgentSessionIdentity = { kind: 'unknown', reason: 'identity-not-resolved' };
 
 export type LifecycleSignal = 'arrival' | 'ready';
 
@@ -13,10 +16,7 @@ export interface LifecycleLogSubject {
 }
 
 interface LifecycleStateEntry {
-  lastArrival?: {
-    message: string;
-    at: string;
-  };
+  arrivedSessionIds?: string[];
   idleReady?: {
     message: string;
     open: boolean;
@@ -74,27 +74,62 @@ async function readState(): Promise<LifecycleStateRead> {
 }
 
 async function writeState(state: LifecycleStateFile): Promise<void> {
-  await mkdir(dirname(STATE_FILE), { recursive: true });
-  await writeFile(STATE_FILE, JSON.stringify(state, null, 2) + '\n', { mode: 0o600 });
+  const temporary = `${STATE_FILE}.${randomBytes(16).toString('hex')}.tmp`;
+  try {
+    await writeFile(temporary, JSON.stringify(state, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
+    await rename(temporary, STATE_FILE);
+  } finally {
+    await unlink(temporary).catch((error: NodeJS.ErrnoException) => { if (error.code !== 'ENOENT') throw error; });
+  }
+}
+
+// Same bounded exclusive-lock and stale-reclaim pattern as local-server-cursor.
+async function withLock<T>(operation: () => Promise<T>): Promise<T> {
+  await mkdir(dirname(STATE_LOCK), { recursive: true });
+  for (let attempt = 0; attempt < 200; attempt += 1) {
+    let handle;
+    try {
+      handle = await open(STATE_LOCK, 'wx', 0o600);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+      try {
+        const metadata = await stat(STATE_LOCK);
+        if (Date.now() - metadata.mtimeMs > 30_000) {
+          await unlink(STATE_LOCK);
+          continue;
+        }
+      } catch (inspectionError) {
+        if ((inspectionError as NodeJS.ErrnoException).code === 'ENOENT') continue;
+        throw inspectionError;
+      }
+      await new Promise((resolvePromise) => setTimeout(resolvePromise, 10));
+      continue;
+    }
+    try {
+      return await operation();
+    } finally {
+      await handle.close();
+      try {
+        await unlink(STATE_LOCK);
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+      }
+    }
+  }
+  throw new Error('Lifecycle log state is busy');
 }
 
 export function shouldSuppressLifecycleLogFromState(
   message: string,
   state: LifecycleStateEntry | undefined,
-  nowMs: number = Date.now()
+  identity: AgentSessionIdentity = UNKNOWN_SESSION
 ): { suppress: boolean; signal: LifecycleSignal | null } {
   const signal = lifecycleSignalForMessage(message);
   if (!signal) return { suppress: false, signal: null };
 
   if (signal === 'arrival') {
-    const lastArrivalAt = state?.lastArrival?.at
-      ? new Date(state.lastArrival.at).getTime()
-      : NaN;
-    const isRecent =
-      Number.isFinite(lastArrivalAt) &&
-      nowMs - lastArrivalAt < ARRIVAL_DUPLICATE_WINDOW_MS;
     return {
-      suppress: state?.lastArrival?.message === message && isRecent,
+      suppress: identity.kind === 'known' && state?.arrivedSessionIds?.includes(identity.id) === true,
       signal,
     };
   }
@@ -107,26 +142,32 @@ export function shouldSuppressLifecycleLogFromState(
 
 export async function shouldSuppressLifecycleLog(
   subject: LifecycleLogSubject,
-  message: string
+  message: string,
+  identity: AgentSessionIdentity = UNKNOWN_SESSION
 ): Promise<{ suppress: boolean; signal: LifecycleSignal | null }> {
   const state = await readState();
   if (state === UNREADABLE_STATE) throw unreadableStateError();
   return shouldSuppressLifecycleLogFromState(
     message,
-    state.entries[stateKey(subject)]
+    state.entries[stateKey(subject)],
+    identity
   );
 }
 
 export function nextLifecycleStateAfterLog(
   message: string,
   current: LifecycleStateEntry | undefined,
-  nowIso: string = new Date().toISOString()
+  nowIso: string = new Date().toISOString(),
+  identity: AgentSessionIdentity = UNKNOWN_SESSION
 ): LifecycleStateEntry {
   const signal = lifecycleSignalForMessage(message);
   if (signal === 'arrival') {
+    if (identity.kind === 'unknown' || current?.arrivedSessionIds?.includes(identity.id)) return current ?? {};
     return {
       ...current,
-      lastArrival: { message, at: nowIso },
+      // Retain one opaque id per announced session so resuming an older session
+      // also deduplicates. Pruning needs an explicit history-retention contract.
+      arrivedSessionIds: [...(current?.arrivedSessionIds ?? []), identity.id],
     };
   }
   if (signal === 'ready') {
@@ -146,11 +187,14 @@ export function nextLifecycleStateAfterLog(
 
 export async function recordLifecycleLog(
   subject: LifecycleLogSubject,
-  message: string
+  message: string,
+  identity: AgentSessionIdentity = UNKNOWN_SESSION
 ): Promise<void> {
-  const state = await readState();
-  if (state === UNREADABLE_STATE) throw unreadableStateError();
-  const key = stateKey(subject);
-  state.entries[key] = nextLifecycleStateAfterLog(message, state.entries[key]);
-  await writeState(state);
+  await withLock(async () => {
+    const state = await readState();
+    if (state === UNREADABLE_STATE) throw unreadableStateError();
+    const key = stateKey(subject);
+    state.entries[key] = nextLifecycleStateAfterLog(message, state.entries[key], undefined, identity);
+    await writeState(state);
+  });
 }

package/src/log-stream.ts

@@ -906,10 +906,13 @@ export async function streamOnce(
       // OpenCode queue. A still-unread re-ping may reconcile the prior attempt;
       // its source entry ID prevents a new nonce from resubmitting that prompt.
       if (isReping) {
-        await injectOpenCode(
+        const openCodeDelivered = await injectOpenCode(
           formatOpenCodeWakePrompt(line), deliveryId, true, ev.id,
           () => hasPendingWakeEntry(active, ev.id),
         );
+        if (!openCodeDelivered) {
+          wakeCodex(formatCodexWakePrompt(line), ev.wake_nonce, ev.id);
+        }
       }
       markEventPersisted(ev.id, ev.data?.created_at ?? '');
       return 'persisted-skip';

package/src/opencode-drone.ts

@@ -1568,6 +1568,20 @@ export function settleOpenCodeEntry(sourceEntryId: string): void {
   if (bindingChanged) persistCurrentBinding();
 }
 
+/** Read the launch-selected identity without changing the injection binding. */
+export async function resolveOpenCodeAgentSessionId(): Promise<string | null> {
+  const owner = state;
+  if (!owner?.connected) return null;
+  const binding = readBinding();
+  if (!binding) return null;
+  // The launch marker, unlike the injection binding, does not follow /new.
+  const launch = await findLaunchSession(owner.launchIdentity);
+  if (state !== owner || launch.kind !== 'found' || launch.session.id !== binding.sessionId ||
+      launch.knownRootSessionIds.some((id) => !binding.knownRootSessionIds.includes(id))) return null;
+  const current = readBinding();
+  return current?.sessionId === binding.sessionId ? binding.sessionId : null;
+}
+
 export async function probeOpenCodeDroneArmed(): Promise<boolean | null> {
   const owner = state;
   if (!owner?.connected) return null;

package/src/regen-format.ts

@@ -251,7 +251,7 @@ export function markArrivalAnnouncedThisProcess(): void {
 export function getDronePlaybook(handoverMode: HandoverMode = 'origin'): string {
   const arrivalInstruction = arrivalAnnouncedThisProcess
     ? ''
-    : `\n**Required one-time startup setup:** If this instruction is visible, immediately call \`borg_log message="ARRIVAL: <your-label> (<your-role>) online on ${osHostname()}" to="broadcast"\` before unread-log triage. This is the sole exception to no-work log silence. Do not infer your startup state from peers' \`ARRIVAL:\` entries. After the post succeeds, the client suppresses this instruction until the MCP process restarts; an explicit \`/mcp\` reconnect may show it again.\n`;
+    : `\n**Required one-time startup setup:** If this instruction is visible, immediately call \`borg_log message="ARRIVAL: <your-label> (<your-role>) online on ${osHostname()}" to="broadcast"\` before unread-log triage. This is the sole exception to no-work log silence. Do not infer your startup state from peers' \`ARRIVAL:\` entries. After the post succeeds, the client suppresses this instruction until the MCP process restarts; an explicit \`/mcp\` reconnect may show it again. The log call suppresses repeat ARRIVAL for a known agent session across reconnects; unknown identity announces. Claude identity can be stale after a resume whose SessionStart hook failed. Inspect \`borg_stream-status\` for the identity source and observation age.\n`;
   const reviewReadyRefs = handoverMode === 'local'
     ? '["HEAD"]'
     : '["HEAD","origin/<branch>","origin/main"]';

package/src/regen.ts

@@ -28,6 +28,7 @@ import {
 import { resolveSessionAgentKind } from './codex-app-wake.js';
 import { resolveReportableSessionAgentKind, type AgentKind } from './agent-runtime.js';
 import { handleVersionFlag } from './version.js';
+import { recordClaudeSessionStart } from './agent-session-identity.js';
 import {
   BORG_LAUNCH_REMINDER_DISABLED_ENV,
   BORG_SESSION_ENV,
@@ -61,7 +62,8 @@ async function readStdin(): Promise<string> {
 
 async function main(): Promise<void> {
   handleVersionFlag();
-  const hookSource = parseHookSource(await readStdin());
+  const hookPayload = await readStdin();
+  const hookSource = parseHookSource(hookPayload);
   // gh#673 P1 (WI-4): the SessionStart orientation only activates in
   // borg-launched sessions — a vanilla `claude` anywhere (including an
   // assimilated repo) stays vanilla. Exit-0 no-op: a hook must never
@@ -95,6 +97,10 @@ async function main(): Promise<void> {
   // session-scoped `/loop` + `ScheduleWakeup`, and the kickoff prompt is
   // gone, so the lean orientation adds a "re-establish your wake path" note.
   const source = hookSource;
+  if (resolveSessionAgentKind() === 'claude') {
+    try { await recordClaudeSessionStart(hookPayload); }
+    catch { process.stderr.write('Borg could not record the Claude SessionStart identity.\n'); }
+  }
 
   const active = await getActiveCube();
   if (!active) {