@ours.network/fleet 1.2.0-nightly.63 → 1.2.0-nightly.64

package/dist/session/acp.d.ts

@@ -4,7 +4,7 @@ import * as acp from '@agentclientprotocol/sdk';
 import type { CommonPermissions } from '../config.js';
 import type { AcpMcpServer } from '../harness/types.js';
 import { ConversationEventStore } from './conversation-store.js';
-import type { ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
+import type { ConversationObservationState, ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
 import { type PendingPrompt } from './prompt-batch.js';
 import type { ConversationHandlePage, ExitRecord, InterruptOutcome, QueuedPrompt, SessionEvent, AgentSession, RuntimeSelectorMetadata, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnOutcome, TurnResult } from './types.js';
 /** Bound safe-boundary waiting without turning a hung tool into cancellation. */
@@ -157,7 +157,9 @@ export declare class AcpSession implements AgentSession {
     private readonly sharedTurns;
     /** Commands the adapter currently advertises; only these are control operations. */
     private advertisedCommands;
+    private presentedCommands;
     private queueDepth;
+    private readonly observation;
     private exit;
     private steeringSupported;
     private agentCapabilities?;
@@ -396,6 +398,11 @@ export declare class AcpSession implements AgentSession {
         after?: string;
         limit?: number;
     }): ConversationHandlePage;
+    subscribeConversationFailure(listener: (generation: string) => void): () => void;
+    conversationReplayAvailable(expectedGeneration: string): boolean;
+    replayConversation(request: import('./conversation-replay.js').ConversationReplayRequest): AsyncGenerator<import("./conversation-replay.js").ConversationReplayPage, any, any>;
+    observeConversation(listener: (state: ConversationObservationState) => void): import("./conversation-types.js").ConversationObservation;
+    private captureObservation;
     conversationSnapshot(): ConversationSnapshot;
     subscribeConversation(listener: Parameters<ConversationEventStore['subscribe']>[0]): () => void;
     private isCurrentConversationEvent;

package/dist/session/acp.js

@@ -1,3 +1,4 @@
+import { ConversationObservation } from './conversation-observation.js';
 import { appendTaskCreated } from './task-notice.js';
 import { spawn } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
@@ -278,7 +279,9 @@ export class AcpSession {
     sharedTurns = new Map();
     /** Commands the adapter currently advertises; only these are control operations. */
     advertisedCommands = new Set();
+    presentedCommands = [];
     queueDepth = 0;
+    observation = new ConversationObservation(() => this.captureObservation());
     exit = null;
     steeringSupported = false;
     agentCapabilities;
@@ -330,6 +333,9 @@ export class AcpSession {
             roleId: options.name, log: line => options.log(`[${options.name}] ${line}`),
         });
         this.conversationStartCursor = this.conversation.lastCursor();
+        // A durable append can precede its inventory mutation. Capture only after
+        // the synchronous owner checkpoint, never the state at append notification.
+        this.conversation.subscribe(() => this.observation.scheduleCapture());
         this.sessionFile = join(options.stateDir, '.acp-session-id');
         this.terminated = new Promise((_resolve, reject) => { this.terminate = reject; });
         // Nothing awaits this promise until a request races it; an unobserved
@@ -363,6 +369,7 @@ export class AcpSession {
                 acpSessionId: this.sessionId,
                 payload: { status: 'failed', detail: this.lastError },
             });
+            this.observation.publish();
         });
     }
     static async start(options) {
@@ -451,7 +458,8 @@ export class AcpSession {
             const promptId = open.promptId;
             this.queueDepth++;
             const run = this.enqueue(promptId, text, undefined);
-            void run.finally(() => { this.queueDepth = Math.max(0, this.queueDepth - 1); });
+            this.observation.publish();
+            void run.finally(() => { this.queueDepth = Math.max(0, this.queueDepth - 1); this.observation.publish(); });
         }
     }
     isAlive() {
@@ -470,6 +478,7 @@ export class AcpSession {
             return;
         this.steeringOccupied = true;
         this.refreshSteeringOccupancy();
+        this.observation.publish();
     }
     refreshSteeringOccupancy() {
         if (!this.steeringOccupied)
@@ -492,6 +501,7 @@ export class AcpSession {
         if (!this.steeringOccupied)
             return;
         this.steeringOccupied = false;
+        this.observation.publish();
         this.options.log(`[${this.options.name}] steering-started turn no longer holds the adapter (${reason})`);
     }
     snapshot() {
@@ -714,11 +724,18 @@ export class AcpSession {
         }
         const promptId = randomUUID();
         const queuedBehind = this.queueDepth;
-        this.admitToLedger(promptId, text, queuedBehind, options);
-        this.queueDepth++;
-        const run = this.enqueue(promptId, text, options.origin);
-        const completion = run.then(result => { this.queueDepth = Math.max(0, this.queueDepth - 1); return result; }, error => {
+        const run = this.observation.checkpoint(() => {
+            this.admitToLedger(promptId, text, queuedBehind, options);
+            this.queueDepth++;
+            return this.enqueue(promptId, text, options.origin);
+        });
+        const completion = run.then(result => {
+            this.queueDepth = Math.max(0, this.queueDepth - 1);
+            this.observation.publish();
+            return result;
+        }, error => {
             this.queueDepth = Math.max(0, this.queueDepth - 1);
+            this.observation.publish();
             return turnResult(false, 'failed', error?.message ?? String(error));
         });
         return {
@@ -856,6 +873,7 @@ export class AcpSession {
             actor: { browserSession: command.actorBrowserSession },
         });
         const receipt = {
+            sessionGeneration: this.sessionGeneration,
             commandId: command.commandId,
             promptId: queued.promptId,
             state: queued.queuedBehind > 0 ? 'queued' : 'starting',
@@ -1003,6 +1021,7 @@ export class AcpSession {
             this.allowPermission(pending.toolCallId, permissionId);
         else
             this.releasePermission(pending.toolCallId, permissionId);
+        this.readiness = this.pendingPermissions.size > 0 ? 'awaiting_permission' : 'running';
         this.events.emit('permission', {
             turnId: this.activeTurn?.id,
             origin: this.activeTurn?.origin,
@@ -1019,7 +1038,7 @@ export class AcpSession {
             promptId: this.activeTurn?.id, turnId: this.activeTurn?.id,
             payload: { decision, decisionSource: 'manual', optionId },
         });
-        this.readiness = this.pendingPermissions.size > 0 ? 'awaiting_permission' : 'running';
+        this.observation.publish();
         return true;
     }
     /**
@@ -1085,6 +1104,8 @@ export class AcpSession {
             : { outcome: { outcome: 'cancelled' } });
         const settled = decision === 'denied' && !rejectOption ? 'cancelled' : decision;
         this.releasePermission(pending.toolCallId, permissionId);
+        if (this.pendingPermissions.size === 0 && this.readiness === 'awaiting_permission')
+            this.readiness = 'running';
         this.events.emit('permission', {
             turnId: this.activeTurn?.id,
             origin: this.activeTurn?.origin,
@@ -1108,8 +1129,7 @@ export class AcpSession {
                 ...(rejectOption ? { optionId: rejectOption.optionId } : {}),
             },
         });
-        if (this.pendingPermissions.size === 0 && this.readiness === 'awaiting_permission')
-            this.readiness = 'running';
+        this.observation.publish();
     }
     exitResult() {
         return this.exit;
@@ -1322,6 +1342,7 @@ export class AcpSession {
             kind: 'session.state', sessionGeneration: this.sessionGeneration,
             acpSessionId: this.sessionId, payload: { status: 'idle' },
         });
+        this.observation.publish();
     }
     captureRuntimeMetadata(options, modelId) {
         this.runtimeModel = runtimeSelector(options, 'model');
@@ -1460,8 +1481,11 @@ export class AcpSession {
             attempt.recoveryStartedAt = Date.now();
             const recoveryOrigin = origin?.kind === 'scheduled-loop'
                 ? origin : { kind: 'stall-watchdog' };
-            this.admitToLedger(attempt.recoveryId, STALL_RECOVERY_PROMPT, 0, { origin: recoveryOrigin });
-            const recovered = await this.runSinglePrompt(STALL_RECOVERY_PROMPT, attempt.recoveryId, recoveryOrigin);
+            const recovery = this.observation.checkpoint(() => {
+                this.admitToLedger(attempt.recoveryId, STALL_RECOVERY_PROMPT, 0, { origin: recoveryOrigin });
+                return this.runSinglePrompt(STALL_RECOVERY_PROMPT, attempt.recoveryId, recoveryOrigin);
+            });
+            const recovered = await recovery;
             attempt.report(attempt.superseded ? 'superseded'
                 : recovered.succeeded && attempt.resumed ? 'recovery_completed' : 'blocked_recovery');
             // A failed diagnostic turn must not make startup tear down the session.
@@ -1477,6 +1501,7 @@ export class AcpSession {
      * so none is left open and none is reported delivered that was not sent.
      */
     async runSinglePrompt(text, turnId = randomUUID(), origin, members = [{ promptId: turnId, text, origin }]) {
+        let completionPayload;
         const closeMembers = (payload) => {
             for (const member of members)
                 this.conversation.appendSafe({
@@ -1494,6 +1519,7 @@ export class AcpSession {
         let settle;
         const settled = new Promise(resolve => { settle = resolve; });
         this.activeTurn = { toolEvidence: new Map(), startedAt: Date.now(), toolIds: new Set(), lastProgressAt: 0, progressCount: 0, transportFailures: 0, boundaryUnknown: false, id: turnId, output: '', origin, settled, settle, promptIds: members.map(member => member.promptId), console: members.some(member => member.origin?.kind === 'owner-admin-console') };
+        this.observation.publish();
         this.events.emit('state', { turnId, status: 'running', origin });
         members.forEach((member, index) => this.conversation.appendSafe({
             kind: 'prompt.started', sessionGeneration: this.sessionGeneration,
@@ -1516,11 +1542,11 @@ export class AcpSession {
                 turnId, stopReason: response.stopReason, origin, cancellationSource,
             });
             this.events.emit('state', { status: 'idle' });
-            closeMembers({
+            completionPayload = {
                 outcome: classifyStopReason(response.stopReason),
                 stopReason: response.stopReason,
                 ...(cancellationSource ? { cancellationSource } : {}),
-            });
+            };
             // The prompt was accepted either way — the agent answered. Whether the
             // turn SUCCEEDED is a separate question, and only `stopReason` answers it.
             return turnResult(true, classifyStopReason(response.stopReason), response.stopReason, this.activeTurn?.id === turnId ? this.activeTurn.output : undefined, this.activeTurn?.id === turnId ? this.activeTurn.cancellationSource : undefined);
@@ -1540,7 +1566,7 @@ export class AcpSession {
             });
             if (this.isAlive())
                 this.events.emit('state', { status: 'idle' });
-            closeMembers({ outcome: 'failed', stopReason: this.lastError });
+            completionPayload = { outcome: 'failed', stopReason: this.lastError };
             return turnResult(false, 'failed', this.lastError, this.activeTurn?.id === turnId ? this.activeTurn.output : undefined);
         }
         finally {
@@ -1556,6 +1582,9 @@ export class AcpSession {
                 this.cancelEscalation = undefined;
                 this.activeTurn = undefined;
             }
+            if (completionPayload)
+                closeMembers(completionPayload);
+            this.observation.publish();
         }
     }
     async steerPrompt(text) {
@@ -1648,42 +1677,20 @@ export class AcpSession {
         }
         const timeoutMs = this.options.permissionTimeoutMs ?? PERMISSION_TIMEOUT_MS;
         const expiresAt = new Date(Date.now() + timeoutMs).toISOString();
-        this.readiness = 'awaiting_permission';
-        this.events.emit('permission', {
-            turnId: this.activeTurn?.id,
-            origin: this.activeTurn?.origin,
-            permissionId,
-            toolCallId: this.activeTurn?.origin?.kind === 'scheduled-loop'
-                ? 'scheduled-loop-tool' : params.toolCall.toolCallId,
-            title: this.activeTurn?.origin?.kind === 'scheduled-loop'
+        const presented = {
+            toolCallId: scheduledTurn(this.activeTurn) ? 'scheduled-loop-tool' : toolCallId,
+            title: scheduledTurn(this.activeTurn)
                 ? 'Scheduled-loop permission requested' : params.toolCall.title ?? 'Permission requested',
-            status: 'pending',
             options: params.options.map(option => ({
                 optionId: option.optionId,
-                name: this.activeTurn?.origin?.kind === 'scheduled-loop' ? option.kind : option.name,
+                name: scheduledTurn(this.activeTurn) ? option.kind : option.name,
                 kind: option.kind,
             })),
-        });
-        this.conversation.appendSafe({
-            kind: 'permission.requested', sessionGeneration: this.sessionGeneration,
-            acpSessionId: this.sessionId, permissionId,
-            promptId: this.activeTurn?.id, turnId: this.activeTurn?.id,
-            toolCallId: scheduledTurn(this.activeTurn) ? 'scheduled-loop-tool' : params.toolCall.toolCallId,
-            payload: {
-                toolCallId: scheduledTurn(this.activeTurn) ? 'scheduled-loop-tool' : params.toolCall.toolCallId,
-                title: scheduledTurn(this.activeTurn)
-                    ? 'Scheduled-loop permission requested' : params.toolCall.title ?? 'Permission requested',
-                options: params.options.map(option => ({
-                    optionId: option.optionId,
-                    name: scheduledTurn(this.activeTurn) ? option.kind : option.name,
-                    kind: option.kind,
-                })),
-                expiresAt,
-            },
-        });
+            expiresAt,
+        };
         return new Promise(resolve => {
             const pending = {
-                options: params.options, resolve,
+                options: params.options, resolve, presented,
                 toolCallId,
                 eventToolCallId: scheduledTurn(this.activeTurn) ? 'scheduled-loop-tool' : toolCallId,
             };
@@ -1692,6 +1699,18 @@ export class AcpSession {
             }, timeoutMs);
             pending.expiry.unref?.();
             this.pendingPermissions.set(permissionId, pending);
+            this.readiness = 'awaiting_permission';
+            this.events.emit('permission', {
+                turnId: this.activeTurn?.id, origin: this.activeTurn?.origin,
+                permissionId, ...presented, status: 'pending',
+            });
+            this.conversation.appendSafe({
+                kind: 'permission.requested', sessionGeneration: this.sessionGeneration,
+                acpSessionId: this.sessionId, permissionId,
+                promptId: this.activeTurn?.id, turnId: this.activeTurn?.id,
+                toolCallId: presented.toolCallId, payload: presented,
+            });
+            this.observation.publish();
         });
     }
     /**
@@ -1868,11 +1887,13 @@ export class AcpSession {
         const scheduled = this.activeTurn?.origin?.kind === 'scheduled-loop';
         const messagePhase = update.sessionUpdate === 'agent_message_chunk'
             ? this.codexMessagePhase(update) : undefined;
-        this.recordConversationUpdate(update, scheduled);
+        // Install live capability state before the durable append can synchronously
+        // notify a subscriber that reenters observation at the new ledger barrier.
         if (update.sessionUpdate === 'config_option_update')
             this.captureRuntimeMetadata(update.configOptions);
         if (update.sessionUpdate === 'available_commands_update')
             this.advertisedCommands = new Set((update.availableCommands ?? []).map(command => command.name));
+        this.recordConversationUpdate(update, scheduled);
         if (update.sessionUpdate === 'usage_update') {
             // Claude subscription rate-limit snapshot (claude-agent-acp forwards the SDK rate_limit_event).
             const rateLimit = update._meta?.['_claude/rateLimit'];
@@ -1937,6 +1958,7 @@ export class AcpSession {
             default:
                 break;
         }
+        this.observation.publish();
     }
     /**
      * Codex ACP's phase extension is the only currently supported visibility
@@ -1963,6 +1985,8 @@ export class AcpSession {
             redactText: SCHEDULED_LOOP_REDACTION,
             redactToolCallId: 'scheduled-loop-tool',
         } : {});
+        if (normalized.kind === 'capabilities.updated' && 'commands' in normalized.payload)
+            this.presentedCommands = normalized.payload.commands ?? [];
         this.conversation.appendSafe({
             kind: normalized.kind,
             sessionGeneration: this.sessionGeneration,
@@ -2001,6 +2025,36 @@ export class AcpSession {
             snapshot: this.conversationSnapshot(),
         };
     }
+    subscribeConversationFailure(listener) {
+        return this.conversation.subscribeFailure(listener);
+    }
+    conversationReplayAvailable(expectedGeneration) {
+        return expectedGeneration === this.sessionGeneration && this.conversation.generationDurable(expectedGeneration);
+    }
+    replayConversation(request) {
+        if (request.expectedGeneration !== this.sessionGeneration)
+            throw new Error('session generation changed');
+        return this.conversation.replay(request);
+    }
+    observeConversation(listener) {
+        return this.observation.observe(listener);
+    }
+    captureObservation() {
+        const snapshot = this.snapshot();
+        return {
+            ...this.conversationSnapshot(),
+            ...pendingInventory(this.pendingPrompts),
+            ledgerBarrier: Number(this.conversation.lastCursor() ?? 0),
+            alive: snapshot.alive,
+            readiness: snapshot.alive ? snapshot.readiness : 'offline',
+            activePromptIds: [...(this.activeTurn?.promptIds ?? [])],
+            pendingPermissions: [...this.pendingPermissions].flatMap(([permissionId, pending]) => pending.presented ? [{ permissionId, ...pending.presented }] : []),
+            commands: this.presentedCommands,
+            runtimeModel: snapshot.runtimeModel,
+            reasoningEffort: snapshot.reasoningEffort,
+            permissionMode: snapshot.permissionMode,
+        };
+    }
     conversationSnapshot() {
         return {
             sessionGeneration: this.sessionGeneration,

package/dist/session/arbiter.d.ts

@@ -79,6 +79,10 @@ export declare class RoleTurnArbiter implements AgentSession {
         limit?: number;
     }): ConversationHandlePage;
     conversationSnapshot(): ConversationSnapshot;
+    subscribeConversationFailure(listener: (generation: string) => void): () => void;
+    conversationReplayAvailable(expectedGeneration: string): boolean;
+    replayConversation(request: import('./conversation-replay.js').ConversationReplayRequest): AsyncIterable<import("./conversation-replay.js").ConversationReplayPage>;
+    observeConversation(listener: (state: import('./conversation-types.js').ConversationObservationState) => void): import('./conversation-types.js').ConversationObservation;
     subscribeConversation(listener: (event: ConversationEventV1) => void): () => void;
     submitPromptBrowser(command: SubmitPromptCommand): Promise<PromptReceipt>;
     get liveVoiceSupported(): boolean;

package/dist/session/arbiter.js

@@ -181,6 +181,24 @@ export class RoleTurnArbiter {
             throw new Error('conversation snapshot is unavailable');
         return this.session.conversationSnapshot();
     }
+    subscribeConversationFailure(listener) {
+        if (!this.session.subscribeConversationFailure)
+            throw new Error('conversation durability observation is unavailable');
+        return this.session.subscribeConversationFailure(listener);
+    }
+    conversationReplayAvailable(expectedGeneration) {
+        return this.session.conversationReplayAvailable?.(expectedGeneration) ?? false;
+    }
+    replayConversation(request) {
+        if (!this.session.replayConversation)
+            throw new Error('conversation replay is unavailable');
+        return this.session.replayConversation(request);
+    }
+    observeConversation(listener) {
+        if (!this.session.observeConversation)
+            throw new Error('conversation observation is unavailable');
+        return this.session.observeConversation(listener);
+    }
     subscribeConversation(listener) {
         if (!this.session.subscribeConversation)
             throw new Error('conversation subscription is unavailable');

package/dist/session/codex-app-server.d.ts

@@ -1,6 +1,6 @@
 import { type TaskNoticeBinding, type TaskCreatedNotice } from './task-notice.js';
 import type { CommonPermissions } from '../config.js';
-import type { ConversationEventV1, ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
+import type { ConversationEventV1, ConversationObservationState, ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
 import { type PendingPrompt } from './prompt-batch.js';
 import type { CodexAppServerTransportFactory } from './codex-app-server-transport.js';
 import type { AgentSession, ConversationHandlePage, ExitRecord, InterruptOutcome, QueuedPrompt, SessionEvent, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnResult } from './types.js';
@@ -66,6 +66,7 @@ export declare class CodexAppServerSession implements AgentSession {
     private lastError?;
     private exit;
     private queueDepth;
+    private readonly observation;
     private promptTail;
     /** Admitted prompts not yet handed to the app-server, in admission order. */
     private readonly pendingPrompts;
@@ -112,6 +113,11 @@ export declare class CodexAppServerSession implements AgentSession {
         after?: string;
         limit?: number;
     }): ConversationHandlePage;
+    subscribeConversationFailure(listener: (generation: string) => void): () => void;
+    conversationReplayAvailable(expectedGeneration: string): boolean;
+    replayConversation(request: import('./conversation-replay.js').ConversationReplayRequest): AsyncGenerator<import("./conversation-replay.js").ConversationReplayPage, any, any>;
+    observeConversation(listener: (state: ConversationObservationState) => void): import("./conversation-types.js").ConversationObservation;
+    private captureObservation;
     conversationSnapshot(): ConversationSnapshot;
     subscribeConversation(listener: (event: ConversationEventV1) => void): () => void;
     submitPromptBrowser(command: SubmitPromptCommand): Promise<PromptReceipt>;

package/dist/session/codex-app-server.js

@@ -1,3 +1,4 @@
+import { ConversationObservation } from './conversation-observation.js';
 import { appendTaskCreated } from './task-notice.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
@@ -148,6 +149,7 @@ export class CodexAppServerSession {
     lastError;
     exit = null;
     queueDepth = 0;
+    observation = new ConversationObservation(() => this.captureObservation());
     promptTail = Promise.resolve();
     /** Admitted prompts not yet handed to the app-server, in admission order. */
     pendingPrompts = [];
@@ -170,6 +172,9 @@ export class CodexAppServerSession {
             roleId: options.name, log: line => options.log(`[${options.name}] ${line}`),
         });
         this.conversationStartCursor = this.conversation.lastCursor();
+        // A durable append can precede its inventory mutation. Capture only after
+        // the synchronous owner checkpoint, never the state at append notification.
+        this.conversation.subscribe(() => this.observation.scheduleCapture());
         // Use Fleet's provider-neutral resume marker so runner recovery rotates the
         // exact native thread id after a poisoned fast resume.
         this.threadFile = join(options.stateDir, '.session-id');
@@ -234,14 +239,18 @@ export class CodexAppServerSession {
         }
         const promptId = randomUUID();
         const queuedBehind = this.queueDepth;
-        this.admit(promptId, text, queuedBehind, options);
-        this.queueDepth++;
-        const run = this.enqueue(promptId, text, options.origin);
+        const run = this.observation.checkpoint(() => {
+            this.admit(promptId, text, queuedBehind, options);
+            this.queueDepth++;
+            return this.enqueue(promptId, text, options.origin);
+        });
         const completion = run.then(result => {
             this.queueDepth = Math.max(0, this.queueDepth - 1);
+            this.observation.publish();
             return result;
         }, error => {
             this.queueDepth = Math.max(0, this.queueDepth - 1);
+            this.observation.publish();
             return turnResult(false, 'failed', error instanceof Error ? error.message : String(error));
         });
         return {
@@ -413,6 +422,7 @@ export class CodexAppServerSession {
         });
         this.conversation.close();
         await this.transport.close();
+        this.observation.publish();
     }
     taskNoticeBinding() {
         return this.activeTurn && this.threadId ? { sessionGeneration: this.sessionGeneration, acpSessionId: this.threadId, promptId: this.activeTurn.promptId } : undefined;
@@ -432,6 +442,36 @@ export class CodexAppServerSession {
         }
         return { ...page, events: visible, snapshot: this.conversationSnapshot() };
     }
+    subscribeConversationFailure(listener) {
+        return this.conversation.subscribeFailure(listener);
+    }
+    conversationReplayAvailable(expectedGeneration) {
+        return expectedGeneration === this.sessionGeneration && this.conversation.generationDurable(expectedGeneration);
+    }
+    replayConversation(request) {
+        if (request.expectedGeneration !== this.sessionGeneration)
+            throw new Error('session generation changed');
+        return this.conversation.replay(request);
+    }
+    observeConversation(listener) {
+        return this.observation.observe(listener);
+    }
+    captureObservation() {
+        const snapshot = this.snapshot();
+        return {
+            ...this.conversationSnapshot(),
+            ...pendingInventory(this.pendingPrompts),
+            ledgerBarrier: Number(this.conversation.lastCursor() ?? 0),
+            alive: snapshot.alive,
+            readiness: snapshot.alive ? snapshot.readiness : 'offline',
+            activePromptIds: [...(this.activeTurn?.promptIds ?? [])],
+            pendingPermissions: [...this.pendingPermissions].flatMap(([permissionId, pending]) => pending.presented ? [{ permissionId, ...pending.presented }] : []),
+            commands: [{ name: 'compact', description: textBlock('Compact session context') }],
+            runtimeModel: snapshot.runtimeModel,
+            reasoningEffort: snapshot.reasoningEffort,
+            permissionMode: snapshot.permissionMode,
+        };
+    }
     conversationSnapshot() {
         return {
             sessionGeneration: this.sessionGeneration,
@@ -460,6 +500,7 @@ export class CodexAppServerSession {
             actor: { browserSession: command.actorBrowserSession },
         });
         const receipt = {
+            sessionGeneration: this.sessionGeneration,
             commandId: command.commandId, promptId: queued.promptId,
             state: queued.queuedBehind ? 'queued' : 'starting', queuedBehind: queued.queuedBehind,
             acceptedAt: new Date().toISOString(), eventCursor: this.conversation.lastCursor() ?? '0',
@@ -515,6 +556,7 @@ export class CodexAppServerSession {
             kind: 'session.state', sessionGeneration: this.sessionGeneration,
             payload: { status: 'idle' },
         });
+        this.observation.publish();
     }
     recoverOpenPrompts() {
         for (const open of this.conversation.openPrompts()) {
@@ -534,7 +576,8 @@ export class CodexAppServerSession {
                 ? { kind: 'owner-admin-console', commandId: open.commandId }
                 : undefined;
             const run = this.enqueue(open.promptId, open.text, origin);
-            void run.finally(() => { this.queueDepth = Math.max(0, this.queueDepth - 1); });
+            this.observation.publish();
+            void run.finally(() => { this.queueDepth = Math.max(0, this.queueDepth - 1); this.observation.publish(); });
         }
     }
     admit(promptId, text, queuedBehind, options) {
@@ -580,6 +623,7 @@ export class CodexAppServerSession {
         this.finalAnswerObserved = false;
         this.activeItems.clear();
         this.readiness = 'running';
+        this.observation.publish();
         this.events.emit('state', { turnId: promptId, status: 'running', origin });
         members.forEach((member, index) => this.conversation.appendSafe({
             kind: 'prompt.started', sessionGeneration: this.sessionGeneration,
@@ -890,6 +934,7 @@ export class CodexAppServerSession {
                     ...(active.cancellationSource ? { cancellationSource: active.cancellationSource } : {}),
                 },
             });
+        this.observation.publish();
         active.settle(result);
     }
     /**
@@ -1053,7 +1098,6 @@ export class CodexAppServerSession {
             this.resolvePermission(permissionId, pending, 'denied', 'automatic', 'deny_once', unattended ? 'permissions.unattended=deny' : 'permissions.approval=deny', unattended ? 'no controller is attached' : 'the role denies permission requests');
             return;
         }
-        this.pendingPermissions.set(permissionId, pending);
         this.readiness = 'awaiting_permission';
         const timeoutMs = this.options.permissionTimeoutMs ?? PERMISSION_TIMEOUT_MS;
         const expiresAt = new Date(Date.now() + timeoutMs).toISOString();
@@ -1063,19 +1107,23 @@ export class CodexAppServerSession {
             ?? (method === 'item/fileChange/requestApproval' ? 'Apply file changes'
                 : method === 'item/permissions/requestApproval' ? 'Grant additional permissions'
                     : 'Run command');
+        const presented = { toolCallId, title, options, expiresAt };
+        pending.presented = presented;
+        this.pendingPermissions.set(permissionId, pending);
         this.events.emit('permission', {
             turnId: this.activeTurn?.promptId, origin: this.activeTurn?.origin,
-            permissionId, toolCallId, title, status: 'pending', options,
+            permissionId, ...presented, status: 'pending',
         });
         this.conversation.appendSafe({
             kind: 'permission.requested', sessionGeneration: this.sessionGeneration,
             permissionId, promptId: this.activeTurn?.promptId, turnId: this.activeTurn?.promptId,
-            toolCallId, payload: { toolCallId, title, options, expiresAt },
+            toolCallId, payload: presented,
         });
         pending.expiry = setTimeout(() => {
             this.autoResolvePermission(permissionId, pending, undefined, `no decision arrived within ${Math.round(timeoutMs / 1000)}s`);
         }, timeoutMs);
         pending.expiry.unref?.();
+        this.observation.publish();
     }
     serverRequestResolved(params) {
         const requestId = typeof params.requestId === 'string' || typeof params.requestId === 'number'
@@ -1101,6 +1149,8 @@ export class CodexAppServerSession {
         this.resolvePermission(permissionId, pending, 'denied', 'automatic', 'deny_once', policy, reason);
     }
     resolvePermission(permissionId, pending, decision, decisionSource, optionId, policy, reason) {
+        if (!this.pendingPermissions.size && this.readiness === 'awaiting_permission')
+            this.readiness = 'running';
         this.events.emit('permission', {
             turnId: this.activeTurn?.promptId, origin: this.activeTurn?.origin,
             permissionId, toolCallId: pending.toolCallId, status: 'completed', decision,
@@ -1113,8 +1163,7 @@ export class CodexAppServerSession {
             payload: { decision, decisionSource, ...(optionId ? { optionId } : {}),
                 ...(policy ? { policy } : {}), ...(reason ? { reason } : {}) },
         });
-        if (!this.pendingPermissions.size && this.readiness === 'awaiting_permission')
-            this.readiness = 'running';
+        this.observation.publish();
         this.scheduleTerminalReconciliation();
     }
     currentEvent(event) {
@@ -1162,10 +1211,12 @@ export class CodexAppServerSession {
             if (this.activeTurn)
                 this.finishTurn('failed', this.lastError);
         }
+        this.observation.publish();
     }
     fail(error) {
         this.lastError = error instanceof Error ? error.message : String(error);
         this.readiness = 'failed';
         this.events.emit('error', { text: this.lastError });
+        this.observation.publish();
     }
 }

package/dist/session/control.d.ts

@@ -1,6 +1,7 @@
 import type { LayoutControlRequest } from '../rooms-tasks/layout-control.js';
 import type { SupervisorCorrespondence, AgentHistoryQuery } from '../agent-ours/correspondence.js';
 import { type Socket } from 'node:net';
+import { type PassiveConversationFollowRequest } from './conversation-replay.js';
 import type { AgentSession, ControlFailureKind, SessionEvent, SessionSnapshot } from './types.js';
 import type { OwnerChannelHandle, OwnerChannelManagementRequest } from '../owner-channel/channel.js';
 import type { ScheduledLoopManagerHandle } from '../loops/manager.js';
@@ -26,7 +27,8 @@ export interface ControlRequest {
     ownerChannel?: OwnerChannelManagementRequest;
     loop?: string;
     /** Conversation cursor: replay strictly after this durable seq. */
-    after?: string;
+    after?: string | number;
+    expectedGeneration?: string;
     limit?: number;
     /** Idempotency key for v3 mutations. */
     commandId?: string;
@@ -141,6 +143,7 @@ export declare class RoleControlServer {
     private handle;
     /** Version and capability gate shared by every conversation v3 command. */
     private requireConversation;
+    private observationFeatures;
     private write;
 }
 /**
@@ -160,7 +163,7 @@ export declare function followControl(stateDir: string, onMessage: (message: Rec
  * `{ version, conversationEvent }`. Closing the socket detaches the
  * controller-presence this connection contributed.
  */
-export declare function followConversation(stateDir: string, after: string | undefined, onMessage: (message: Record<string, unknown>) => void): Promise<{
+export declare function followConversation(stateDir: string, after: string | undefined | PassiveConversationFollowRequest, onMessage: (message: Record<string, unknown>) => void): Promise<{
     socket: Socket;
     close(): void;
 }>;