@phnx-labs/agents-cli 1.22.111 → 1.22.113

package/dist/lib/feed/activity.js

@@ -198,14 +198,67 @@ function readTail(file, maxBytes) {
 // sessions or directories a long-lived consumer visits. Never expose cached
 // objects: callers enrich and mutate returned events (including nested values).
 const ACTIVITY_CACHE_BYTES = 32 * 1024 * 1024;
-const ACTIVITY_CACHE_FILES = 1024;
 const activityTails = new Map();
+// A separate LRU of payload references lets pressure release parsed events
+// without repeatedly walking thousands of summaries that cannot shrink.
+const activityTailPayloads = new Map();
 let activityTailBytes = 0;
+let activityTailReads = 0;
+/** Read-only process-local diagnostics; no event content or file paths. */
+export function getActivityCacheStats() {
+    return {
+        entries: activityTails.size,
+        parsedTails: activityTailPayloads.size,
+        bytes: activityTailBytes,
+        maxBytes: ACTIVITY_CACHE_BYTES,
+        tailReads: activityTailReads,
+    };
+}
 function forgetActivityTail(key) {
     const old = activityTails.get(key);
     if (old)
         activityTailBytes -= old.weight;
     activityTails.delete(key);
+    activityTailPayloads.delete(key);
+}
+function activitySummaryWeight(key, stamp) {
+    return (key.length + stamp.length) * 2 + 256;
+}
+function retainActivityTail(key, result, sinceMs) {
+    const summaryWeight = activitySummaryWeight(key, result.stamp);
+    // Even metadata is byte-bounded. A tail whose summary cannot fit still
+    // returns normally, but must not evict the cache or be retained over budget.
+    if (summaryWeight > ACTIVITY_CACHE_BYTES)
+        return;
+    const retained = { ...result };
+    if (result.newestMs < sinceMs || result.weight > ACTIVITY_CACHE_BYTES / 2) {
+        retained.events = undefined;
+        retained.weight = summaryWeight;
+    }
+    // Prefer compact history over payloads, retaining all summaries that fit
+    // instead of imposing a file-count cap that thrashes on each directory scan.
+    for (const [oldKey, old] of activityTailPayloads) {
+        if (activityTailBytes + retained.weight <= ACTIVITY_CACHE_BYTES)
+            break;
+        const weight = activitySummaryWeight(oldKey, old.stamp);
+        activityTailBytes -= old.weight - weight;
+        old.events = undefined;
+        old.weight = weight;
+        activityTailPayloads.delete(oldKey);
+    }
+    // If all existing entries are summaries, sacrifice the incoming payload
+    // before evicting history. The current caller still receives result.events.
+    if (activityTailBytes + retained.weight > ACTIVITY_CACHE_BYTES) {
+        retained.events = undefined;
+        retained.weight = summaryWeight;
+    }
+    while (activityTailBytes + retained.weight > ACTIVITY_CACHE_BYTES) {
+        forgetActivityTail(activityTails.keys().next().value);
+    }
+    activityTails.set(key, retained);
+    if (retained.events)
+        activityTailPayloads.set(key, retained);
+    activityTailBytes += retained.weight;
 }
 function activityStamp(file) {
     // ctime catches same-size rewrites even when a producer restores mtime;
@@ -228,9 +281,14 @@ function readActivityTail(file, maxBytes, sinceMs = -Infinity) {
     if (cached?.stamp === stamp && (cached.events || cached.newestMs < sinceMs)) {
         activityTails.delete(key);
         activityTails.set(key, cached);
+        if (cached.events) {
+            activityTailPayloads.delete(key);
+            activityTailPayloads.set(key, cached);
+        }
         return cached;
     }
     forgetActivityTail(key);
+    activityTailReads++;
     const text = readTail(file, maxBytes);
     // Transient I/O failure is not an empty file snapshot; retry next read.
     if (text === undefined)
@@ -256,27 +314,12 @@ function readActivityTail(file, maxBytes, sinceMs = -Infinity) {
     }
     // Bound retained source-derived strings, objects, and entry overhead. Large
     // one-off tails still read normally, but cannot displace the entire cache.
-    const weight = text.length * 2 + events.length * 1024 + key.length * 2 + 256;
+    const weight = text.length * 2 + events.length * 1024 + activitySummaryWeight(key, stamp);
     const result = { stamp, events, newestMs, weight };
     try {
         // A writer racing the read must not pin a mixed snapshot as unchanged.
         if (activityStamp(file) === stamp) {
-            if (activityTails.size >= ACTIVITY_CACHE_FILES)
-                forgetActivityTail(activityTails.keys().next().value);
-            const summaryWeight = key.length * 2 + 256;
-            const retained = weight <= ACTIVITY_CACHE_BYTES / 2 ? { ...result } : { ...result, events: undefined, weight: summaryWeight };
-            // Retain timestamp summaries even when parsed tails exceed the budget:
-            // otherwise a large historical corpus thrashes on every cursor poll.
-            for (const [oldKey, old] of activityTails) {
-                if (activityTailBytes + retained.weight <= ACTIVITY_CACHE_BYTES)
-                    break;
-                const summary = oldKey.length * 2 + 256;
-                activityTailBytes -= old.weight - summary;
-                old.events = undefined;
-                old.weight = summary;
-            }
-            activityTails.set(key, retained);
-            activityTailBytes += retained.weight;
+            retainActivityTail(key, result, sinceMs);
         }
     }
     catch { /* Deleted during the read: return this snapshot without caching. */ }

package/dist/lib/feed/watch.d.ts

@@ -48,6 +48,15 @@ export declare class FeedWatchState {
     constructor(streamId?: `${string}-${string}-${string}-${string}-${string}`);
     emit(event: FeedWatchPayload): FeedWatchEnvelope;
 }
+/** Reuse session ownership reconciliation for the combined operator stream. */
+export declare class FeedSessionProjection {
+    private readonly state;
+    private readonly sessions;
+    private readonly observations;
+    private projectedAttention;
+    constructor(state?: FeedWatchState);
+    apply(event: FeedWatchEnvelope): FeedWatchEnvelope[];
+}
 export declare function projectSessionEnvelope(event: SessionWatchEnvelope, state: FeedWatchState, gh?: GhExec): Promise<FeedWatchEnvelope[]>;
 export interface WatchLocalFeedOptions {
     scope: string;

package/dist/lib/feed/watch.js

@@ -1,3 +1,4 @@
+import { SessionProjection } from '../session/projection.js';
 import { randomUUID } from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -21,6 +22,86 @@ export class FeedWatchState {
         return { v: 1, streamId: this.streamId, sequence: ++this.sequence, ...event };
     }
 }
+/** Reuse session ownership reconciliation for the combined operator stream. */
+export class FeedSessionProjection {
+    state;
+    sessions = new SessionProjection();
+    observations = new Map();
+    projectedAttention = new Map();
+    constructor(state = new FeedWatchState()) {
+        this.state = state;
+    }
+    apply(event) {
+        const scope = normalizeHost(event.scope);
+        const base = { version: 1, streamId: event.streamId, sequence: event.sequence, capturedAt: 'capturedAt' in event ? event.capturedAt : Date.now(), scope };
+        let sessionEvent;
+        if (event.type === 'reset') {
+            sessionEvent = { ...base, type: 'reset', rows: event.agents };
+            const attention = new Map();
+            for (const row of event.agents) {
+                const item = event.attention.find(item => item.sessionId === row.sessionId);
+                if (item && !row.previous)
+                    attention.set(row.rowKey, item);
+            }
+            this.observations.set(scope, attention);
+        }
+        else if (event.type === 'agent.upsert') {
+            sessionEvent = { ...base, type: 'upsert', rowKey: event.rowKey, row: event.agent };
+        }
+        else if (event.type === 'agent.remove') {
+            sessionEvent = { ...base, type: 'remove', rowKey: event.rowKey };
+            this.observations.get(scope)?.delete(event.rowKey);
+        }
+        else if (event.type === 'attention.upsert') {
+            if (!this.observations.has(scope))
+                this.observations.set(scope, new Map());
+            this.observations.get(scope).set(event.rowKey, event.attention);
+        }
+        else if (event.type === 'attention.remove') {
+            this.observations.get(scope)?.delete(event.rowKey);
+        }
+        else {
+            const { v: _v, streamId: _streamId, sequence: _sequence, ...payload } = event;
+            return [this.state.emit(payload)];
+        }
+        const projected = sessionEvent ? this.sessions.apply(sessionEvent) : [];
+        const next = new Map();
+        for (const [observer, items] of this.observations)
+            for (const [rowKey, item] of items) {
+                const row = this.sessions.rowForObservation(observer, rowKey);
+                if (row && !row.previous && row.sourceDevice === observer)
+                    next.set(item.key, { scope: observer, item });
+            }
+        const result = [];
+        const resetScopes = new Set();
+        for (const rowEvent of projected) {
+            if (rowEvent.type === 'reset') {
+                resetScopes.add(rowEvent.scope);
+                result.push(this.state.emit({ type: 'reset', scope: rowEvent.scope, capturedAt: rowEvent.capturedAt, agents: rowEvent.rows,
+                    attention: [...next.values()].filter(value => value.scope === rowEvent.scope).map(value => value.item) }));
+            }
+            else if (rowEvent.type === 'upsert') {
+                result.push(this.state.emit({ type: 'agent.upsert', scope: rowEvent.scope, rowKey: rowEvent.rowKey, agent: rowEvent.row }));
+            }
+            else if (rowEvent.type === 'remove') {
+                result.push(this.state.emit({ type: 'agent.remove', scope: rowEvent.scope, rowKey: rowEvent.rowKey }));
+            }
+        }
+        // Attention has its own stable generation key, also used by feed answer.
+        // Never substitute the projected agent row key: reset consumers key by item.key.
+        for (const [key, previous] of this.projectedAttention) {
+            if (!next.has(key) && !resetScopes.has(previous.scope))
+                result.push(this.state.emit({ type: 'attention.remove', scope: previous.scope, rowKey: key }));
+        }
+        for (const [key, value] of next) {
+            if (!resetScopes.has(value.scope) && JSON.stringify(this.projectedAttention.get(key)) !== JSON.stringify(value)) {
+                result.push(this.state.emit({ type: 'attention.upsert', scope: value.scope, rowKey: key, attention: value.item }));
+            }
+        }
+        this.projectedAttention = next;
+        return result;
+    }
+}
 /**
  * Live rows only: durable Previous rows share the operator stream for Sessions
  * history, but they are not live work and must never synthesize Needs-you
@@ -92,13 +173,19 @@ function watchAttentionStores(onChange) {
     const watchers = [];
     for (const dir of [feedDir, path.join(feedDir, 'resolutions')]) {
         try {
+            // `resolutions` is created lazily by the first `recordResolution` call, so
+            // a fresh feed dir has no directory to watch yet. Create it up front —
+            // otherwise fs.watch throws ENOENT here, is swallowed, and never retried,
+            // silently downgrading every resolution to the 45 s PR-status fallback
+            // instead of the event-driven reconcile this function exists to provide.
+            fs.mkdirSync(dir, { recursive: true });
             const watcher = fs.watch(dir, () => onChange());
             // A directory that disappears must not take the watcher process down; the
             // PR-status cadence below still reconciles on its own timer.
             watcher.on('error', () => watcher.close());
             watchers.push(watcher);
         }
-        catch { /* the dir appears with the first block; the timed pass covers it */ }
+        catch { /* best-effort: the timed pass still reconciles on its own cadence */ }
     }
     return () => { for (const watcher of watchers)
         watcher.close(); };
@@ -217,9 +304,10 @@ function remoteFeedWatchCommand(os) {
 }
 export async function watchFleetFeed(options) {
     const coordinator = new FeedWatchState();
+    const projection = new FeedSessionProjection(coordinator);
     const forward = (event) => {
-        const { v: _v, streamId: peerStreamId, sequence: peerSequence, ...payload } = event;
-        options.emit(coordinator.emit({ ...payload, peerStreamId, peerSequence }));
+        for (const projected of projection.apply(event))
+            options.emit(projected);
     };
     const local = watchLocalFeed({ scope: machineId(), signal: options.signal, emit: forward });
     let devices;

package/dist/lib/feed-post.js

@@ -21,7 +21,7 @@ import { resolveProjectNameForCwd, listProjectDefs } from './projects.js';
 import { getHistoryDir } from './state.js';
 import { machineId } from './machine-id.js';
 import { isValidMailboxId } from './mailbox.js';
-import { listPidSessionEntries, readPidSessionEntry, } from './session/pid-registry.js';
+import { listPidSessionEntries, readLivePidSessionEntry as readPidSessionEntry, } from './session/pid-registry.js';
 /** Soft cap so a runaway agent can't flood the activity lane with essays. */
 export const STATUS_POST_MAX_CHARS = 500;
 /** Title is a phone subject line - about four or five words, not a paragraph. */

package/dist/lib/hosts/dispatch.d.ts

@@ -1,13 +1,3 @@
-/**
- * Dispatch a headless `agents …` command onto a host over SSH.
- *
- * The command is launched detached (`nohup … &`) writing combined output to a
- * remote log and its exit code to a sibling `.exit` file, so progress survives a
- * dropped connection (followed via offset-tail in progress.ts). This is the
- * offload win: the process/thread/file fan-out happens on the host, not the
- * laptop. `agents run` uses it; `agents teams start --watch --device` reuses the
- * same core so a remote team supervisor keeps running after you disconnect.
- */
 import type { Host } from './types.js';
 import { type HostTask } from './tasks.js';
 import { type HostCredentials } from './credentials.js';

package/dist/lib/hosts/dispatch.js

@@ -1,3 +1,4 @@
+import { launchIdentityEnv } from '../launch-identity.js';
 /**
  * Dispatch a headless `agents …` command onto a host over SSH.
  *
@@ -63,7 +64,7 @@ const REMOTE_DIR = '$HOME/.agents/.cache/hosts';
  * collision, mirroring `buildExecEnv`'s `...options.env` precedence (exec.ts).
  */
 export function withActorEnv(env) {
-    return { ...actorEnv(resolveActor()), ...terminalIdEnv(), ...(env ?? {}) };
+    return { ...actorEnv(resolveActor()), ...launchIdentityEnv(), ...(env ?? {}) };
 }
 /**
  * The shell-export prelude prepended to EVERY remote `agents run` dispatch —
@@ -88,24 +89,6 @@ export function remoteRunShellPrelude(agent, extra = {}) {
     const exports = posixEnvExports(withActorEnv({ ...guard, ...extra }));
     return exports ? `${exports}; ` : '';
 }
-/**
- * Forward the launching editor tab's `AGENT_TERMINAL_ID` across the SSH hop.
- *
- * Factory stamps it on every terminal it spawns, and the remote `agents run`
- * records it in its pid registry (`writePidSessionEntry`) — which is what lets a
- * tab ask the device "which session is MY terminal running?" instead of guessing
- * from local state. Without the forward the remote registry has no terminal id,
- * that question is unanswerable, and the tab is stuck with its spawn-time id even
- * after the agent has moved to a different session (a `/clear`, or an exit and
- * rerun in the same tab).
- *
- * Same shape as the actor provenance above: absent when the launch did not come
- * from a tracked terminal, never fabricated.
- */
-function terminalIdEnv() {
-    const terminalId = process.env.AGENT_TERMINAL_ID?.trim();
-    return terminalId ? { AGENT_TERMINAL_ID: terminalId } : {};
-}
 /**
  * Launch a detached login-shell command in its own Unix session/process group.
  *

package/dist/lib/hosts/remote-session-id.d.ts

@@ -9,37 +9,15 @@
  *
  * The launcher forwards a launch id it controls (`--env AGENT_LAUNCH_ID=<id>`);
  * the remote `agents run` adopts it (exec.ts `resolveLaunchId`), so the remote
- * SessionStart hook records the agent's REAL session id under that exact key in
- * `~/.agents/.cache/terminals/sessions/<pid>.json`. After the stream returns we
- * do ONE ssh read of that dir and pick the record whose `launch_id` matches —
- * the same launch-id join `agents sessions --active` uses locally
- * (session/hook-sessions.ts), just across the SSH hop.
+ * SessionStart hook records the agent's REAL session id. After the stream
+ * returns we ask the owning CLI to join that hook with the durable launch
+ * registry, using the same index as local focus/session projection. This also
+ * supports the deployed legacy hook containing only session_id and pid.
  *
  * This gives the interactive path a real per-agent id to register in the local
  * session index and to reconnect against, for Codex/Kimi/Grok/Gemini — closing
  * the gap RUSH-2033 left for every non-Claude agent (Claude still forces its own
  * id up front and never reaches here).
  */
-/**
- * Pick the real session id for `launchId` from the remote hook records.
- *
- * `recordsJson` is the newline-delimited JSON the remote read emits — one record
- * per line (a `cat` of every `sessions/*.json`). Scan for the record whose
- * `launch_id` matches and return its `session_id`; when several match (pid reuse,
- * a lingering file) the NEWEST by `ts` wins, mirroring the local reader's
- * keep-newest tie-break (session/hook-sessions.ts). Pure so the correlation is
- * unit-testable from fixtures with no SSH. Returns undefined when no record
- * carries the launch id (the hook hasn't landed yet, or a hookless harness).
- */
-export declare function pickRemoteSessionId(recordsJson: string, launchId: string): string | undefined;
-/**
- * Read the remote hook-session dir over ssh and resolve the real session id the
- * remote run recorded under `launchId`. One round-trip, best-effort: any ssh
- * failure, a missing dir, or an absent record yields undefined — the caller then
- * keeps the un-mapped run rather than a fabricated id.
- *
- * `$HOME` expands on the REMOTE login shell (never the local box). The glob is a
- * literal path with no user input, so it is injection-safe; a `2>/dev/null` on a
- * globless dir keeps the command quiet when the dir is empty or absent.
- */
+/** Resolve on the execution owner through the canonical read-only CLI projection. */
 export declare function resolveRemoteSessionId(target: string, launchId: string, timeoutMs?: number): string | undefined;

package/dist/lib/hosts/remote-session-id.js

@@ -9,76 +9,33 @@
  *
  * The launcher forwards a launch id it controls (`--env AGENT_LAUNCH_ID=<id>`);
  * the remote `agents run` adopts it (exec.ts `resolveLaunchId`), so the remote
- * SessionStart hook records the agent's REAL session id under that exact key in
- * `~/.agents/.cache/terminals/sessions/<pid>.json`. After the stream returns we
- * do ONE ssh read of that dir and pick the record whose `launch_id` matches —
- * the same launch-id join `agents sessions --active` uses locally
- * (session/hook-sessions.ts), just across the SSH hop.
+ * SessionStart hook records the agent's REAL session id. After the stream
+ * returns we ask the owning CLI to join that hook with the durable launch
+ * registry, using the same index as local focus/session projection. This also
+ * supports the deployed legacy hook containing only session_id and pid.
  *
  * This gives the interactive path a real per-agent id to register in the local
  * session index and to reconnect against, for Codex/Kimi/Grok/Gemini — closing
  * the gap RUSH-2033 left for every non-Claude agent (Claude still forces its own
  * id up front and never reaches here).
  */
-import { sshExec } from '../ssh-exec.js';
-/**
- * Pick the real session id for `launchId` from the remote hook records.
- *
- * `recordsJson` is the newline-delimited JSON the remote read emits — one record
- * per line (a `cat` of every `sessions/*.json`). Scan for the record whose
- * `launch_id` matches and return its `session_id`; when several match (pid reuse,
- * a lingering file) the NEWEST by `ts` wins, mirroring the local reader's
- * keep-newest tie-break (session/hook-sessions.ts). Pure so the correlation is
- * unit-testable from fixtures with no SSH. Returns undefined when no record
- * carries the launch id (the hook hasn't landed yet, or a hookless harness).
- */
-export function pickRemoteSessionId(recordsJson, launchId) {
-    if (!launchId)
-        return undefined;
-    let best;
-    for (const line of recordsJson.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        let rec;
-        try {
-            rec = JSON.parse(trimmed);
-        }
-        catch {
-            continue; // a partial/garbled line — skip, never throw
-        }
-        if (rec.launch_id !== launchId)
-            continue;
-        if (typeof rec.session_id !== 'string' || !rec.session_id)
-            continue;
-        const ts = typeof rec.ts === 'number' ? rec.ts : 0;
-        // Strict `>` so the FIRST record wins a tie — matches keepNewest (hook-sessions.ts).
-        if (!best || ts > best.ts)
-            best = { sid: rec.session_id, ts };
-    }
-    return best?.sid;
-}
-/**
- * Read the remote hook-session dir over ssh and resolve the real session id the
- * remote run recorded under `launchId`. One round-trip, best-effort: any ssh
- * failure, a missing dir, or an absent record yields undefined — the caller then
- * keeps the un-mapped run rather than a fabricated id.
- *
- * `$HOME` expands on the REMOTE login shell (never the local box). The glob is a
- * literal path with no user input, so it is injection-safe; a `2>/dev/null` on a
- * globless dir keeps the command quiet when the dir is empty or absent.
- */
+import { sshExec, shellQuote } from '../ssh-exec.js';
+/** Resolve on the execution owner through the canonical read-only CLI projection. */
 export function resolveRemoteSessionId(target, launchId, timeoutMs = 6000) {
     if (!launchId)
         return undefined;
-    // `cat` every record onto its own line. `head -c` caps a runaway file; the
-    // trailing `true` keeps the pipeline's exit 0 even when the glob matches nothing.
-    const cmd = 'cat "$HOME"/.agents/.cache/terminals/sessions/*.json 2>/dev/null | head -c 1048576 || true';
+    // Let the owning CLI join its deployed hook and launch registry. A remote
+    // caller must not carry a second implementation of session identity rules.
+    const cmd = `agents sessions --resolve-launch-id ${shellQuote(launchId)} --json --local`;
     const res = sshExec(target, cmd, { timeoutMs, multiplex: true });
-    if (res.code !== 0 && !res.stdout)
+    if (res.code !== 0)
         return undefined;
-    // Each record is a single-line JSON object; `cat` may run them together, so
-    // normalise `}{` boundaries onto separate lines before scanning.
-    const normalised = res.stdout.replace(/\}\s*\{/g, '}\n{');
-    return pickRemoteSessionId(normalised, launchId);
+    try {
+        const record = JSON.parse(res.stdout);
+        return record.launchId === launchId && typeof record.sessionId === 'string' && record.sessionId
+            ? record.sessionId : undefined;
+    }
+    catch {
+        return undefined;
+    }
 }

package/dist/lib/launch-identity.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Editor identity belongs to the first launch attached to that terminal. The
+ * harness inherits it for its own tools, but another `agents run` is a new
+ * launch, not another owner of the parent's editor tab. AGENTS_RUNTIME is set
+ * by buildExecEnv, whereas an editor's initial launch sets AGENT_TERMINAL_ID
+ * (and may already set AGENT_SESSION_ID) without that runtime marker.
+ */
+export declare function launchIdentityEnv(env?: NodeJS.ProcessEnv): Record<string, string>;
+/** Identity absent from a new launch must not leak back in from a tmux server. */
+export declare const LAUNCH_IDENTITY_KEYS: readonly ["AGENT_TERMINAL_ID", "AGENT_SESSION_ID", "AGENTS_SESSION_ID", "AGENTS_MAILBOX_DIR", "AGENT_LAUNCH_ID", "AGENTS_PARENT_SESSION_ID", "AGENTS_PARENT_LAUNCH_ID", "AGENTS_ORIGIN_TERMINAL_ID"];

package/dist/lib/launch-identity.js

@@ -0,0 +1,31 @@
+/**
+ * Editor identity belongs to the first launch attached to that terminal. The
+ * harness inherits it for its own tools, but another `agents run` is a new
+ * launch, not another owner of the parent's editor tab. AGENTS_RUNTIME is set
+ * by buildExecEnv, whereas an editor's initial launch sets AGENT_TERMINAL_ID
+ * (and may already set AGENT_SESSION_ID) without that runtime marker.
+ */
+export function launchIdentityEnv(env = process.env) {
+    const result = {};
+    const terminal = env.AGENT_TERMINAL_ID?.trim();
+    const nested = env.AGENTS_RUNTIME === 'terminal' || env.AGENTS_RUNTIME === 'headless' || env.AGENTS_RUNTIME === 'teams';
+    if (terminal && !nested)
+        result.AGENT_TERMINAL_ID = terminal;
+    const originTerminal = env.AGENTS_ORIGIN_TERMINAL_ID?.trim() || terminal;
+    if (originTerminal)
+        result.AGENTS_ORIGIN_TERMINAL_ID = originTerminal;
+    const parentLaunch = nested ? env.AGENT_LAUNCH_ID : env.AGENTS_PARENT_LAUNCH_ID;
+    const parentSession = nested
+        ? env.AGENTS_SESSION_ID || env.AGENT_SESSION_ID
+        : env.AGENTS_PARENT_SESSION_ID;
+    if (parentLaunch)
+        result.AGENTS_PARENT_LAUNCH_ID = parentLaunch;
+    if (parentSession)
+        result.AGENTS_PARENT_SESSION_ID = parentSession;
+    return result;
+}
+/** Identity absent from a new launch must not leak back in from a tmux server. */
+export const LAUNCH_IDENTITY_KEYS = [
+    'AGENT_TERMINAL_ID', 'AGENT_SESSION_ID', 'AGENTS_SESSION_ID', 'AGENTS_MAILBOX_DIR',
+    'AGENT_LAUNCH_ID', 'AGENTS_PARENT_SESSION_ID', 'AGENTS_PARENT_LAUNCH_ID', 'AGENTS_ORIGIN_TERMINAL_ID',
+];

package/dist/lib/session/active.js

@@ -1,3 +1,4 @@
+import { writerProcessView } from './process-view.js';
 /**
  * Active-session detection across every context an agent can run in:
  *
@@ -24,7 +25,7 @@ import { promisify } from 'util';
 import { listActiveTasks } from '../cloud/store.js';
 import { AgentManager } from '../teams/agents.js';
 import { getTerminalsDir } from '../state.js';
-import { readPidSessionEntry, listPidSessionEntries, prunePidSessionRegistry, sessionIdFromLivePid, isSessionIdShape, } from './pid-registry.js';
+import { readLivePidSessionEntry as readPidSessionEntry, listPidSessionEntries, prunePidSessionRegistry, sessionIdFromLivePid, isSessionIdShape, } from './pid-registry.js';
 import { readSessionActorRecord, writeSessionAliasRecord } from './actor-sidecar.js';
 import { loadHookSessionIndex, resolveHookSessionRecord, readStateSessionRecord } from './hook-sessions.js';
 import { buildClaudeLabelMap, getAgentSessionDirs } from './discover.js';
@@ -1696,8 +1697,9 @@ export async function listTmuxAgentSessions() {
     // split) resolves to its own agent. Newest launch wins a pane (pid reuse), and
     // only live pids count — a dead agent's stale entry can't light up its old pane.
     const liveByPane = new Map();
-    for (const e of listPidSessionEntries()) {
-        if (!e.tmuxPane || !isPidAlive(e.pid, e.startedAtMs))
+    for (const recorded of listPidSessionEntries()) {
+        const e = readPidSessionEntry(recorded.pid);
+        if (!e?.tmuxPane)
             continue;
         const prev = liveByPane.get(e.tmuxPane);
         if (!prev || e.startedAtMs > prev.startedAtMs)
@@ -1824,6 +1826,10 @@ export async function listTmuxAgentSessions() {
  * terminal/headless row for the same session id.
  */
 export async function getActiveSessions(opts = {}) {
+    if (!writerProcessView()) {
+        const { loadLocalActiveSessions } = await import('./session-cache.js');
+        return (await loadLocalActiveSessions()).sessions;
+    }
     const [tmuxAgents, teams, terminals, cloud] = await Promise.all([
         listTmuxAgentSessions().catch(() => []),
         listTeamsActive({ localOnly: opts.localOnly }).catch(() => []),

package/dist/lib/session/db.d.ts

@@ -30,8 +30,9 @@ export declare const SCHEMA_VERSION = 50;
  * genuine first-user-turn extractor was added.
  * v4 (PHNX-3621 leftover) invalidates Grok rows stamped before the bounded
  * chat_history.jsonl prefix read filled firstUserMessage.
+ * v5 (PHNX-3939) restores first-meta Codex fork ownership, including cold files.
  */
-export declare const CONTENT_INDEX_VERSION = 4;
+export declare const CONTENT_INDEX_VERSION = 5;
 /**
  * Bumping this invalidates every cached facet row without touching the schema
  * version, so a change to the extraction logic (a new metric, a corrected bucket)

package/dist/lib/session/db.js

@@ -16,7 +16,7 @@ import { query as queryEvents, queryToolUsageForSessions } from '../feed/events.
 import { machineForSessionFile } from '../origin-machine.js';
 import { loadSessionActorIndex, readSessionActorRecord } from './actor-sidecar.js';
 import { scanEventToolCalls } from './tool-calls.js';
-import { persistToolCalls, planEventToolResume, toolEvidenceSourcePath } from './tool-store.js';
+import { persistToolCalls, planEventToolResume, purgeToolCalls, toolEvidenceSourcePath } from './tool-store.js';
 import { buildClaudeAccountIndex, resolveClaudeAccount } from './claude-accounts.js';
 import { extractBackgroundShells, extractSkills, extractSlashCommands, harnessTracksBackgroundShells, isSubAgentTool, } from './highlights.js';
 import { resolveResource } from '../resources.js';
@@ -45,8 +45,9 @@ export const SCHEMA_VERSION = 50;
  * genuine first-user-turn extractor was added.
  * v4 (PHNX-3621 leftover) invalidates Grok rows stamped before the bounded
  * chat_history.jsonl prefix read filled firstUserMessage.
+ * v5 (PHNX-3939) restores first-meta Codex fork ownership, including cold files.
  */
-export const CONTENT_INDEX_VERSION = 4;
+export const CONTENT_INDEX_VERSION = 5;
 /**
  * Bump to force `agents sessions backfill resources` to re-derive every
  * session's skill/slash-command tallies on its next run (resource_scan_ledger
@@ -1452,8 +1453,17 @@ export function getDB() {
     db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_mirror_synced ON sessions(mirror_synced_at)`);
     db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_routine_run_id ON sessions(routine_run_id)`);
     const sessionColumns = db.prepare('PRAGMA table_info(sessions)').all();
-    if (!sessionColumns.some(column => column.name === 'account_id'))
-        db.exec('ALTER TABLE sessions ADD COLUMN account_id TEXT');
+    if (['account_id', 'phoenix_id'].some(name => !sessionColumns.some(column => column.name === name))) {
+        // Partial upgrades can stamp the current version before every column exists.
+        // Recheck under the writer lock so concurrent openers cannot add it twice.
+        db.transaction(() => {
+            const columns = db.prepare('PRAGMA table_info(sessions)').all();
+            if (!columns.some(column => column.name === 'account_id'))
+                db.exec('ALTER TABLE sessions ADD COLUMN account_id TEXT');
+            if (!columns.some(column => column.name === 'phoenix_id'))
+                db.exec('ALTER TABLE sessions ADD COLUMN phoenix_id TEXT');
+        })();
+    }
     // Account attribution repair. Two ways a Claude row ends up wrong even at v33:
     // an older CLI (whose INSERT does not name the column) writes NULL, and a DB
     // migrated by a build that predates the "clear the stale email on a dark row" fix
@@ -2333,6 +2343,30 @@ export function upsertSession(meta, content, scan, assistantContent = '') {
     });
     txn();
 }
+/** A verified Codex rollout has one native owner. An older last-meta scan may
+ * have indexed its child bytes under the parent id. Reconcile only paths that
+ * were successfully written, after the whole batch, so a real parent rollout
+ * repaired in the same transaction keeps its own row regardless of scan order. */
+function reconcileCodexFileOwners(db, metas) {
+    const owners = new Map(metas.filter(meta => meta.agent === 'codex' && meta.filePath).map(meta => [meta.filePath, meta.id]));
+    const paths = [...owners.keys()];
+    for (let i = 0; i < paths.length; i += 500) {
+        const chunk = paths.slice(i, i + 500);
+        const rows = db.prepare(`SELECT id, file_path FROM sessions WHERE agent = 'codex' AND file_path IN (${chunk.map(() => '?').join(',')})`)
+            .all(...chunk);
+        for (const row of rows) {
+            if (owners.get(row.file_path) === row.id)
+                continue;
+            db.prepare('DELETE FROM sessions WHERE id = ?').run(row.id);
+            for (const table of ['session_text', 'session_preview_cache', 'session_summaries', 'session_insights', 'session_topics', 'session_phenotypes', 'session_resource_usage', 'resource_scan_ledger']) {
+                db.prepare(`DELETE FROM ${table} WHERE session_id = ?`).run(row.id);
+            }
+            // The tool ledger has a unique file path too; release the wrong binding
+            // before the child evidence is persisted below. Transcript files stay put.
+            purgeToolCalls(db, row.id);
+        }
+    }
+}
 /** Batch-upsert sessions with their FTS5 content and scan stamps in a single transaction. */
 export function upsertSessionsBatch(entries) {
     if (entries.length === 0)
@@ -2582,6 +2616,7 @@ export function upsertSessionsBatch(entries) {
                 }
             }
         }
+        reconcileCodexFileOwners(db, writtenEntries.map(entry => entry.meta));
     });
     txn(enrichedEntries);
     // Tool evidence shares the transcript parse above but owns an independent