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

package/dist/notifications/fleet-producer.js

@@ -1,5 +1,5 @@
 import { roomsDir } from '../rooms-tasks/room-state.js';
-import { drainNotificationTargetCleanup } from './target-cleanup.js';
+import { drainNotificationTargetCleanup, notificationAgentId } from './target-cleanup.js';
 import { closeSync, existsSync, lstatSync, openSync, readSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { createHash } from 'node:crypto';
@@ -71,7 +71,7 @@ export class FleetNotificationProducer {
     }
     poll() {
         this.cleanup ??= drainNotificationTargetCleanup(this.config, undefined, undefined, { beforeDelete: async (url) => {
-                const name = new URL(url, 'https://ours.invalid').searchParams.get('chat');
+                const name = notificationAgentId(url);
                 if (!name || !/^[A-Za-z0-9_-]+$/.test(name))
                     return false;
                 // A recreated or retained role still has a valid target. Filesystem errors cannot prove removal.
@@ -126,7 +126,7 @@ export class FleetNotificationProducer {
                     if (!outbox) {
                         const key = createHash('sha256').update(roleDir).digest('hex');
                         outbox = new NotificationOutbox(join(this.stateDir, key + '.json'), this.config, async (value, eventId) => ({ eventId, title: `${roleId}: agent completed`, body: 'Your agent finished responding. Open the chat to view the result.',
-                            url: `/fleet/chats?chat=${encodeURIComponent(roleId)}&detail=1`, ...value }), this.warn);
+                            url: `/fleet/chats/agents/${encodeURIComponent(roleId)}`, ...value }), this.warn);
                         if (!outbox.checkpoint) {
                             const segment = this.existing.has(roleDir) ? segments.at(-1) : segments[0];
                             outbox.saveCheckpoint({ segment, offset: this.existing.has(roleDir) ? statSync(join(dir, segment)).size : 0, prompts: [] });
@@ -187,7 +187,7 @@ export class FleetNotificationProducer {
                         if (['message.chunk', 'message.replace'].includes(event.kind) && event.promptId && event.messageId && current.prompts.includes(prompt))
                             current.messages[prompt] = event.messageId;
                         if (event.kind === 'turn.completed' && event.promptId && current.prompts.includes(prompt)) {
-                            if (!outbox.enqueue(`${roleId}:${event.sessionGeneration}:${event.seq}`, { ...(taskRoles ? { taskId: taskRoles.get(roleId) ?? null } : {}), url: `/fleet/chats?chat=${encodeURIComponent(roleId)}&detail=1#fleet-message-${encodeURIComponent(current.messages[prompt] ?? event.promptId)}` }))
+                            if (!outbox.enqueue(`${roleId}:${event.sessionGeneration}:${event.seq}`, { ...(taskRoles ? { taskId: taskRoles.get(roleId) ?? null } : {}), url: `/fleet/chats/agents/${encodeURIComponent(roleId)}#fleet-message-${encodeURIComponent(current.messages[prompt] ?? event.promptId)}` }))
                                 break;
                             current.prompts = current.prompts.filter(p => p !== prompt);
                             delete current.messages[prompt];

package/dist/notifications/target-cleanup.d.ts

@@ -1,4 +1,6 @@
 import { type ProducerConfig } from './outbox.js';
+/** Only the canonical agent namespace can authorize role-target cleanup. */
+export declare function notificationAgentId(path: string): string | null;
 /** Queue only after the owning lifecycle has established deletion, never on a failed inventory read. */
 export declare function retireNotificationTarget(url: string, config?: ProducerConfig | undefined, dir?: string, request?: typeof fetch): Promise<void>;
 /** Persisted retries also run from the ordinary web notification producer after restart. */

package/dist/notifications/target-cleanup.js

@@ -5,6 +5,24 @@ import { replaceFileAtomically } from '../atomic-file.js';
 import { stateRoot } from '../paths.js';
 import { producerConfig } from './outbox.js';
 const cleanupDir = () => join(stateRoot(), 'notifications', 'removed-targets');
+/** Only the canonical agent namespace can authorize role-target cleanup. */
+export function notificationAgentId(path) {
+    try {
+        if (typeof path !== 'string' || /[\\\x00-\x20]|%(?:2f|5c|00|0[ad])/i.test(path))
+            return null;
+        const match = /^\/fleet\/chats\/agents\/([^/?#]+)(?:[?#]|$)/.exec(path);
+        if (!match)
+            return null;
+        const url = new URL(path, 'https://ours.invalid');
+        if (['source', 'chat', 'task', 'detail'].some(key => url.searchParams.has(key)))
+            return null;
+        const id = decodeURIComponent(match[1]);
+        return /^[A-Za-z0-9_-]+$/.test(id) ? id : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Queue only after the owning lifecycle has established deletion, never on a failed inventory read. */
 export async function retireNotificationTarget(url, config = producerConfig(), dir = cleanupDir(), request = fetch) {
     if (!config)
@@ -17,11 +35,15 @@ export async function retireNotificationTarget(url, config = producerConfig(), d
 export async function drainNotificationTargetCleanup(config, dir = cleanupDir(), request = fetch, options = {}) {
     if (!existsSync(dir))
         return;
-    for (const file of readdirSync(dir).filter(file => /^[a-f0-9]{64}\.json$/.test(file)).slice(0, 32)) {
+    let attempts = 0;
+    for (const file of readdirSync(dir).filter(file => /^[a-f0-9]{64}\.json$/.test(file))) {
+        if (attempts >= 32)
+            break;
         try {
             const path = join(dir, file), value = JSON.parse(readFileSync(path, 'utf8'));
-            if (typeof value.url !== 'string' || !value.url.startsWith('/fleet/chats?'))
+            if (!notificationAgentId(value.url))
                 continue;
+            attempts++;
             if (options.beforeDelete && !(await options.beforeDelete(value.url))) {
                 rmSync(path, { force: true });
                 continue;

package/dist/ops.js

@@ -271,7 +271,7 @@ export async function rmRole(cfg, name, deps) {
     rmSync(agentDir(name), { recursive: true, force: true });
     if (generatedSource && existsSync(role.sourceFile)) {
         unlinkSync(role.sourceFile);
-        await retireNotificationTarget(`/fleet/chats?chat=${encodeURIComponent(name)}`).catch(() => { });
+        await retireNotificationTarget(`/fleet/chats/agents/${encodeURIComponent(name)}`).catch(() => { });
         deps.log(`removed ${role.sourceFile}`);
     }
     deps.log(`removed '${name}' (its ours identity is left intact)`);

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