@ours.network/fleet 1.2.0-nightly.7 → 1.2.0-nightly.70

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

@@ -1,8 +1,12 @@
+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';
 import { isAbsolute, join, resolve } from 'node:path';
+import { boundedJson } from './conversation-normalizer.js';
 import { ConversationEventStore } from './conversation-store.js';
 import { SessionEvents } from './events.js';
+import { memberAuthority, memberBindings, pendingInventory, takeBatch, refuseAtRelease, RELEASE_GUARD_REFUSED, } from './prompt-batch.js';
 import { CodexAppServerTransport } from './codex-app-server-transport.js';
 import { CODEX_APP_SERVER_CANCEL_DEADLINE_EXCEEDED, SessionControlError, sessionBackendCapabilities, turnResult, } from './types.js';
 const PERMISSION_TIMEOUT_MS = 10 * 60_000;
@@ -12,7 +16,6 @@ const INTERRUPT_TERMINATE_GRACE_MS = 5_000;
 const TERMINAL_RECONCILE_QUIET_MS = 2_000;
 const TERMINAL_RECONCILE_REQUEST_TIMEOUT_MS = 5_000;
 const SCHEDULED_REDACTION = '[scheduled-loop content redacted]';
-const COMMENTARY_REDACTION = '[assistant commentary redacted]';
 const OWNER_ADMIN_CONTEXT_KEY = 'ours-fleet://prompt-provenance?source=owner_admin_console';
 const OWNER_CHANNEL_CONTEXT_KEY = 'ours-fleet://prompt-provenance?source=owner_channel';
 const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -24,6 +27,7 @@ function sourceFor(origin) {
         case 'owner': return { source: 'owner_channel', persistBody: false };
         case 'fleet-monitor': return { source: 'fleet_monitor', persistBody: false };
         case 'scheduled-loop': return { source: 'scheduled_loop', persistBody: false };
+        case 'self-reminder': return { source: 'fleet_monitor', persistBody: false };
         case 'local-console':
         default: return { source: 'local_console', persistBody: true };
     }
@@ -74,6 +78,31 @@ export function nativePromptAdditionalContext(origin) {
         };
     return undefined;
 }
+const PROMPT_BATCH_CONTEXT_KEY = 'ours-fleet://prompt-batch';
+/**
+ * Application context for a turn that carries several admitted prompts.
+ *
+ * The single-prompt context says "the accompanying user text", which would
+ * cover every member. A shared turn therefore carries this one entry instead:
+ * each member is its own user text item, in order, and its route and exact
+ * bytes are stated here by the server. Text imitating this wording is still
+ * only user text; it cannot add an application-context entry.
+ */
+export function nativeBatchAdditionalContext(members) {
+    if (members.length === 1)
+        return nativePromptAdditionalContext(members[0].origin);
+    const bindings = memberBindings(members, origin => sourceFor(origin).source);
+    return {
+        [PROMPT_BATCH_CONTEXT_KEY]: {
+            kind: 'application',
+            value: `Fleet queued prompt batch: ${members.length} separately admitted prompts in submission order, `
+                + 'one user text item each. Server-generated provenance per item, describing only that item: '
+                + bindings.map(binding => `item ${binding.index} of ${binding.of} `
+                    + `(source=${binding.source}, bytes=${binding.bytes}, sha256=${binding.sha256}): `
+                    + `${memberAuthority(binding.source)}`).join('; ') + '.',
+        },
+    };
+}
 function toolItem(item) {
     switch (item.type) {
         case 'commandExecution': return {
@@ -121,7 +150,13 @@ export class CodexAppServerSession {
     lastError;
     exit = null;
     queueDepth = 0;
+    deferredRecovered = [];
+    observation = new ConversationObservation(() => this.captureObservation());
     promptTail = Promise.resolve();
+    /** Admitted prompts not yet handed to the app-server, in admission order. */
+    pendingPrompts = [];
+    /** Admitted prompt → the turn that carries it, while that turn is open. */
+    sharedTurns = new Map();
     activeTurn;
     controllerCount = 0;
     controllerGrace;
@@ -139,6 +174,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');
@@ -172,6 +210,9 @@ export class CodexAppServerSession {
             alive: this.isAlive(),
             readiness: this.readiness,
             sessionId: this.threadId,
+            // A shared turn is a human console turn if any member is: inbox traffic must not cut it short.
+            ...(this.activeTurn?.origin ? { activePromptSource: this.activeTurn.console
+                    ? 'owner-admin-console' : this.activeTurn.origin.kind } : {}),
             lastError: this.lastError,
             pendingPermissionId: this.pendingPermissions.keys().next().value,
             runtimeModel: this.runtimeModel,
@@ -184,6 +225,9 @@ export class CodexAppServerSession {
         };
     }
     async queuePrompt(text, options = {}) {
+        // A guarded prompt must reach the model only through the release fence.
+        if (options.releaseGuard)
+            options = { ...options, interrupt: false, steer: false };
         if (this.closing || !this.threadId || !this.transport.isAlive())
             throw new SessionControlError('offline', this.lastError ?? 'Codex app-server session is offline');
         let delivery;
@@ -200,15 +244,18 @@ export class CodexAppServerSession {
         }
         const promptId = randomUUID();
         const queuedBehind = this.queueDepth;
-        this.admit(promptId, text, queuedBehind, options);
-        this.queueDepth++;
-        const run = this.promptTail.then(() => this.runPrompt(text, promptId, options.origin));
-        this.promptTail = run.then(() => undefined, () => undefined);
+        const run = this.observation.checkpoint(() => {
+            this.admit(promptId, text, queuedBehind, options);
+            this.queueDepth++;
+            return this.enqueue(promptId, text, options.origin, options.releaseGuard);
+        });
         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 {
@@ -216,6 +263,53 @@ export class CodexAppServerSession {
             delivery: delivery ?? (queuedBehind ? 'queued' : 'started'),
         };
     }
+    /** The turn whose events and result answer this admitted prompt; itself unless a release shared it. */
+    sharedTurnId(promptId) {
+        return this.sharedTurns.get(promptId);
+    }
+    /** Each prompt keeps its own step in the chain; the step it reaches releases a whole snapshot. */
+    enqueue(promptId, text, origin, releaseGuard) {
+        const entry = {
+            promptId, text, origin, ...sourceFor(origin), admittedAt: new Date().toISOString(),
+            // The one text the native session runs as an operation instead of a turn.
+            command: text.trim() === '/compact',
+            ...(releaseGuard ? { releaseGuard } : {}),
+        };
+        this.pendingPrompts.push(entry);
+        const run = this.promptTail.then(() => this.release(entry));
+        this.promptTail = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    /**
+     * The turn boundary: the first waiting prompt to get here synchronously
+     * takes every pending prompt delivered with it into one turn. A prompt
+     * admitted afterwards stays pending for the next boundary, and a step whose
+     * prompt was already taken reports that turn's result.
+     */
+    release(entry) {
+        if (entry.released)
+            return entry.released;
+        const refused = refuseAtRelease(this.pendingPrompts, entry, Boolean(this.threadId && this.transport.isAlive()));
+        if (refused) {
+            this.conversation.appendSafe({
+                kind: 'turn.completed', sessionGeneration: this.sessionGeneration,
+                promptId: entry.promptId, turnId: entry.promptId,
+                payload: { outcome: 'cancelled', stopReason: RELEASE_GUARD_REFUSED },
+            });
+            entry.released = Promise.resolve(refused);
+            return entry.released;
+        }
+        const members = takeBatch(this.pendingPrompts, entry);
+        for (const member of members)
+            this.sharedTurns.set(member.promptId, members[0].promptId);
+        const run = this.runPrompt(members).finally(() => {
+            for (const member of members)
+                this.sharedTurns.delete(member.promptId);
+        });
+        for (const member of members)
+            member.released = run;
+        return run;
+    }
     async submitPrompt(text, options = {}) {
         try {
             return await (await this.queuePrompt(text, options)).completion;
@@ -226,10 +320,20 @@ export class CodexAppServerSession {
             throw error;
         }
     }
+    liveVoiceSupported = true;
+    async interruptPrompt(generation, promptId) {
+        if (generation !== this.sessionGeneration)
+            throw new Error('session_changed: Agent session changed.');
+        if (!this.activeTurn?.promptIds.includes(promptId))
+            return { state: 'settled' };
+        return this.interrupt('local-console');
+    }
     async interrupt(source = 'local-console') {
         const active = this.activeTurn;
-        if (!active || !this.threadId || !active.nativeTurnId)
+        if (!active || !this.threadId)
             return { state: 'settled' };
+        if (!active.nativeTurnId)
+            throw new SessionControlError('backend', 'The operation is still pending without a native turn ID. Cancellation is not confirmed; inspect or restart the agent if it does not progress.');
         active.cancellationSource ??= source;
         this.events.emit('state', { turnId: active.promptId, status: 'running', origin: active.origin });
         this.conversation.appendSafe({
@@ -334,7 +438,12 @@ 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;
     }
+    recordTaskCreated(binding, notice) { appendTaskCreated(this.conversation, binding, notice); }
     conversationPage(request = {}) {
         const floor = Number(this.conversationStartCursor ?? 0);
         const requested = Number(request.after ?? 0);
@@ -349,11 +458,42 @@ 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,
             readiness: this.isAlive() ? this.readiness : 'offline',
             queueDepth: this.queueDepth,
+            ...pendingInventory(this.pendingPrompts),
             pendingPermissionIds: [...this.pendingPermissions.keys()],
             ...(this.conversation.degraded ? { historyDegraded: true } : {}),
         };
@@ -367,11 +507,16 @@ export class CodexAppServerSession {
         const existing = this.conversation.receiptFor(command.commandId, bodyDigest);
         if (existing)
             return existing;
+        if (command.expectedSessionGeneration !== undefined && command.expectedSessionGeneration !== this.conversationSnapshot().sessionGeneration)
+            throw new Error('session_changed: Agent session changed. Record a new voice message.');
+        if (command.requireIdle && (this.queueDepth > 0 || this.conversationSnapshot().readiness !== 'idle'))
+            throw new Error('voice_busy: Agent is already working. Wait for the current turn.');
         const queued = await this.queuePrompt(command.text, {
             origin: { kind: 'owner-admin-console', commandId: command.commandId },
             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',
@@ -387,6 +532,8 @@ export class CodexAppServerSession {
         this.transport.notify('initialized');
         const persisted = this.options.mode === 'resume' && existsSync(this.threadFile)
             ? readFileSync(this.threadFile, 'utf8').trim() : '';
+        if (this.options.requireResume && !persisted)
+            throw new Error('TASK_CONTEXT_RESUME_UNAVAILABLE');
         const common = {
             cwd: this.options.cwd,
             approvalPolicy: this.options.approvalPolicy,
@@ -406,6 +553,8 @@ export class CodexAppServerSession {
         this.threadId = string(thread?.id);
         if (!this.threadId)
             throw new Error('Codex app-server did not return a thread id');
+        if (this.options.requireResume && this.threadId !== persisted)
+            throw new Error('TASK_CONTEXT_RESUME_MISMATCH');
         writeFileSync(this.threadFile, this.threadId + '\n', { mode: 0o600 });
         const model = string(response.model) ?? this.options.model ?? undefined;
         if (model)
@@ -415,10 +564,15 @@ export class CodexAppServerSession {
             this.reasoningEffort = { value: effort };
         this.readiness = 'idle';
         this.events.emit('state', { status: 'idle', text: `Codex thread ${this.threadId}` });
+        this.conversation.appendSafe({
+            kind: 'capabilities.updated', sessionGeneration: this.sessionGeneration,
+            payload: { commands: [{ name: 'compact', description: textBlock('Compact session context') }] },
+        });
         this.conversation.appendSafe({
             kind: 'session.state', sessionGeneration: this.sessionGeneration,
             payload: { status: 'idle' },
         });
+        this.observation.publish();
     }
     recoverOpenPrompts() {
         for (const open of this.conversation.openPrompts()) {
@@ -433,15 +587,27 @@ export class CodexAppServerSession {
                 });
                 continue;
             }
-            this.queueDepth++;
             const origin = open.commandId
                 ? { kind: 'owner-admin-console', commandId: open.commandId }
                 : undefined;
-            const run = this.promptTail.then(() => this.runPrompt(open.text, open.promptId, origin));
-            this.promptTail = run.then(() => undefined, () => undefined);
-            void run.finally(() => { this.queueDepth = Math.max(0, this.queueDepth - 1); });
+            const recovered = { promptId: open.promptId, text: open.text, ...(origin ? { origin } : {}) };
+            if (this.options.deferRecoveredPrompts)
+                this.deferredRecovered.push(recovered);
+            else
+                this.dispatchRecovered(recovered);
         }
     }
+    /** Dispatch recovered prompts once the caller's control plane is listening. */
+    activateRecoveredPrompts() {
+        for (const recovered of this.deferredRecovered.splice(0))
+            this.dispatchRecovered(recovered);
+    }
+    dispatchRecovered({ promptId, text, origin }) {
+        this.queueDepth++;
+        const run = this.enqueue(promptId, text, origin);
+        this.observation.publish();
+        void run.finally(() => { this.queueDepth = Math.max(0, this.queueDepth - 1); this.observation.publish(); });
+    }
     admit(promptId, text, queuedBehind, options) {
         const { source, persistBody } = sourceFor(options.origin);
         const bytes = Buffer.byteLength(text);
@@ -470,30 +636,44 @@ export class CodexAppServerSession {
         else
             this.conversation.appendSafe(draft);
     }
-    async runPrompt(text, promptId, origin) {
+    async runPrompt(members) {
+        const { text, promptId, origin } = members[0];
         if (!this.threadId || !this.transport.isAlive())
             return turnResult(false, 'failed', this.lastError ?? 'Codex app-server session is offline');
         let settle;
         const settled = new Promise(resolveResult => { settle = resolveResult; });
-        const active = { promptId, origin, output: '', settled, settle };
+        const active = {
+            promptId, origin, output: '', settled, settle,
+            promptIds: members.map(member => member.promptId),
+            console: members.some(member => member.origin?.kind === 'owner-admin-console'),
+        };
         this.activeTurn = active;
         this.finalAnswerObserved = false;
         this.activeItems.clear();
         this.readiness = 'running';
+        this.observation.publish();
         this.events.emit('state', { turnId: promptId, status: 'running', origin });
-        this.conversation.appendSafe({
+        members.forEach((member, index) => this.conversation.appendSafe({
             kind: 'prompt.started', sessionGeneration: this.sessionGeneration,
-            promptId, turnId: promptId, source: sourceFor(origin).source, payload: {},
-        });
+            promptId: member.promptId, turnId: promptId, source: sourceFor(member.origin).source,
+            payload: members.length > 1 ? { batch: { turnId: promptId, index, size: members.length } } : {},
+        }));
         try {
+            if (text.trim() === '/compact') {
+                // The acknowledgement is not completion. Standard turn notifications
+                // settle the same queued prompt and durable browser receipt.
+                await this.transport.request('thread/compact/start', { threadId: this.threadId });
+                return await settled;
+            }
             const response = await this.transport.request('turn/start', {
                 threadId: this.threadId,
-                input: [{ type: 'text', text, text_elements: [] }],
+                // One unchanged user text item per admitted prompt, in admission order.
+                input: members.map(member => ({ type: 'text', text: member.text, text_elements: [] })),
                 approvalPolicy: this.options.approvalPolicy,
                 model: this.options.model ?? null,
                 effort: this.options.effort ?? null,
-                ...(nativePromptAdditionalContext(origin)
-                    ? { additionalContext: nativePromptAdditionalContext(origin) } : {}),
+                ...(nativeBatchAdditionalContext(members)
+                    ? { additionalContext: nativeBatchAdditionalContext(members) } : {}),
             });
             const turn = isObject(response.turn) ? response.turn : undefined;
             active.nativeTurnId ??= string(turn?.id);
@@ -699,7 +879,7 @@ export class CodexAppServerSession {
             promptId: this.activeTurn?.promptId, turnId: this.activeTurn?.promptId,
             messageId: id, source: 'agent',
             payload: {
-                role: 'assistant', content: textBlock(delta, scheduled ? SCHEDULED_REDACTION : phase === 'commentary' ? COMMENTARY_REDACTION : undefined),
+                role: 'assistant', content: textBlock(delta, scheduled ? SCHEDULED_REDACTION : undefined),
             },
         });
     }
@@ -746,6 +926,10 @@ export class CodexAppServerSession {
                 toolCallId: scheduled ? 'scheduled-loop-tool' : id, snapshot,
                 title: scheduled ? 'scheduled-loop tool' : tool.title, status: tool.status,
                 kind: string(item.type),
+                ...(!scheduled && item.arguments !== undefined ? { rawInput: boundedJson(item.arguments) } : {}),
+                ...(!scheduled && item.type === 'commandExecution' ? { rawInput: boundedJson({ command: item.command, cwd: item.cwd }), ...(item.aggregatedOutput !== undefined ? { rawOutput: boundedJson({ output: item.aggregatedOutput, exitCode: item.exitCode }) } : {}) } : {}),
+                ...(!scheduled && item.type === 'fileChange' && item.changes !== undefined ? { rawOutput: boundedJson(item.changes) } : {}),
+                ...(!scheduled && (item.result !== undefined || item.error !== undefined) ? { rawOutput: boundedJson({ result: item.result, error: item.error }) } : {}),
             },
         });
     }
@@ -768,14 +952,17 @@ export class CodexAppServerSession {
             cancellationSource: active.cancellationSource,
         });
         this.events.emit('state', { status: this.readiness });
-        this.conversation.appendSafe({
-            kind: 'turn.completed', sessionGeneration: this.sessionGeneration,
-            promptId: active.promptId, turnId: active.promptId,
-            payload: {
-                outcome, ...(detail ? { stopReason: detail } : {}),
-                ...(active.cancellationSource ? { cancellationSource: active.cancellationSource } : {}),
-            },
-        });
+        // Every member closes with the shared outcome, so none is left waiting.
+        for (const member of active.promptIds)
+            this.conversation.appendSafe({
+                kind: 'turn.completed', sessionGeneration: this.sessionGeneration,
+                promptId: member, turnId: active.promptId,
+                payload: {
+                    outcome, ...(detail ? { stopReason: detail } : {}),
+                    ...(active.cancellationSource ? { cancellationSource: active.cancellationSource } : {}),
+                },
+            });
+        this.observation.publish();
         active.settle(result);
     }
     /**
@@ -939,7 +1126,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();
@@ -949,19 +1135,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'
@@ -987,6 +1177,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,
@@ -999,8 +1191,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) {
@@ -1048,10 +1239,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,4 +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';
@@ -9,8 +12,13 @@ export interface ControlRequest {
     version: 1 | 2 | 3;
     id: string;
     token: string;
-    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config' | 'conversation_page' | 'conversation_follow' | 'submit_prompt_v2' | 'interrupt_v2' | 'respond_permission_v2' | 'fleet_spawn' | 'fleet_audit_begin' | 'fleet_audit_present' | 'fleet_audit_finish';
+    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config' | 'conversation_page' | 'conversation_follow' | 'submit_prompt_v2' | 'submit_voice_prompt' | 'interrupt_v2' | 'interrupt_voice_v2' | 'layout_control' | 'agent_contacts' | 'agent_history' | 'respond_permission_v2' | 'fleet_spawn' | 'fleet_audit_begin' | 'fleet_audit_present' | 'fleet_audit_finish';
+    layout?: LayoutControlRequest;
+    agentHistory?: AgentHistoryQuery;
     text?: string;
+    expectedSessionGeneration?: string;
+    requireIdle?: boolean;
+    promptId?: string;
     permissionId?: string;
     optionId?: string;
     since?: number;
@@ -19,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;
@@ -112,9 +121,13 @@ export declare class RoleControlServer {
     private readonly sockets;
     /** Interrupt idempotency: same command id returns the first receipt. */
     private readonly interruptCommands;
+    private correspondence?;
+    setCorrespondence(value: SupervisorCorrespondence): void;
     private ownerChannel?;
     private loopManager?;
     private reloadConfig?;
+    private layoutControl?;
+    setLayoutControl(handler: (request: LayoutControlRequest) => Promise<unknown>): void;
     private fleetSpawner?;
     private fleetAuditor?;
     constructor(stateDir: string, session: AgentSession, log: (line: string) => void);
@@ -130,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;
 }
 /**
@@ -149,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;
 }>;