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

package/dist/session/arbiter.d.ts

@@ -1,5 +1,53 @@
 import type { ConversationHandlePage, ExitRecord, InterruptOutcome, PromptOrigin, QueuedPrompt, SessionEvent, AgentSession, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnResult } from './types.js';
 import type { ConversationEventV1, ConversationSnapshot, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
+export type ReminderAttempt = 
+/** Admitted; `queued.completion` settles when the turn (or its refusal) ends. */
+{
+    state: 'admitted';
+    queued: QueuedPrompt;
+} | {
+    state: 'busy';
+} | {
+    state: 'unavailable';
+    error: string;
+    admitted: false;
+};
+/**
+ * The single interruption an urgent reminder may request, as the arbiter saw
+ * it. `target` names the exact checked turn; `outcome` is what the session
+ * and the target's own terminal result actually reported.
+ */
+export interface UrgentInterruptReport {
+    target: UrgentInterruptTarget;
+    outcome: 'cancelled' | 'ended' | 'forced' | 'failed';
+    reason?: string;
+}
+export interface UrgentInterruptTarget {
+    source: NonNullable<SessionSnapshot['activePromptSource']>;
+    sessionId?: string;
+    generation: string;
+    promptId: string;
+}
+/** The urgent path's durable seams; every one is synchronous and owned by the reminder store. */
+export interface UrgentReminderHooks {
+    /** The durable `admitting` claim (as for `tryReminder`). False: nothing is queued. */
+    beforeQueue(): boolean;
+    /** Release fence; the only way the prompt reaches the model. */
+    releaseGuard(): boolean;
+    /** Whether this event may still request its one interruption. */
+    mayInterrupt(): boolean;
+    /** Durable mark written BEFORE the session is asked to cancel. False: do not cancel. */
+    markRequested(target: UrgentInterruptTarget): boolean;
+    /** How the requested interruption ended. */
+    recordOutcome(report: UrgentInterruptReport): void;
+    /** The busy turn was not interruptible this time, and why. */
+    deferred(reason: UrgentDeferral): void;
+    /** Still this caller's current, undispatched claim? Re-checked after every await. */
+    stillAdmitting(): boolean;
+    /** The wake text, built once the interruption (if any) is known. */
+    text(report?: UrgentInterruptReport): string;
+}
+export type UrgentDeferral = 'protected_turn' | 'untracked_turn' | 'permission_pending' | 'queued_work' | 'session_starting' | 'interrupt_unsupported' | 'uncorrelatable' | 'interrupt_already_used';
 export type ScheduledAttempt = {
     state: 'started';
     queued: QueuedPrompt;
@@ -22,7 +70,12 @@ export declare class RoleTurnArbiter implements AgentSession {
     readonly capabilities: import("./types.js").AgentSessionCapabilities | undefined;
     private tail;
     private unsettled;
+    /** Admissions waiting for the boundary; an urgent interruption yields to them. */
+    private waiting;
+    /** Terminal results of prompts this arbiter admitted and that have not settled yet. */
+    private readonly live;
     private stopping;
+    private retiring;
     /** Bumped by `retireStalledAdmission`; every claim carries the one it was made under. */
     private generation;
     /** Resolves the instant the CURRENT generation is retired. */
@@ -53,6 +106,11 @@ export declare class RoleTurnArbiter implements AgentSession {
      */
     retireStalledAdmission(): void;
     queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
+    /** Inbox traffic must not cancel or steer an active human console/voice turn.
+     * Queue it once; the monitor commits its cursor after that turn succeeds.
+     * Other origins retain their configured monitor policy.
+     */
+    private monitorAdmissionOptions;
     submitPrompt(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
     /**
      * Do not hold `exclusive` while ACP waits for a tool boundary: permission
@@ -62,6 +120,40 @@ export declare class RoleTurnArbiter implements AgentSession {
     tryScheduled(text: string, origin: Extract<PromptOrigin, {
         kind: 'scheduled-loop';
     }>, beforeQueue?: () => void | Promise<void>): Promise<ScheduledAttempt>;
+    /**
+     * Admit a self-reminder wake only into an idle role, at the same boundary
+     * every producer uses. It never interrupts or steers, and never joins a
+     * queue behind other work: a busy role answers `busy` and the caller tries
+     * again later. `beforeQueue` makes the caller's durable claim; if it
+     * declines, nothing is queued. `releaseGuard` is the session's last-moment
+     * fence and is the only way the prompt can reach the model.
+     */
+    tryReminder(text: string, origin: Extract<PromptOrigin, {
+        kind: 'self-reminder';
+    }>, beforeQueue: () => boolean, releaseGuard: () => boolean): Promise<ReminderAttempt>;
+    /**
+     * Admit an URGENT self-reminder wake. Idle: exactly `tryReminder`. Busy: the
+     * reminder may ask the exact checked turn to stop — once per event — and is
+     * then admitted at the next boundary like any other reminder.
+     *
+     * The check and the cancel request happen in one synchronous step inside the
+     * admission boundary, so the turn asked to stop is the turn that was checked.
+     * Only a running, correlatable, interruptible turn with nothing queued behind
+     * it and no admission waiting is ever asked to stop; anything else is a
+     * reported deferral (`busy`). After the cancellation the boundary is given up
+     * before the wake is queued, so an owner prompt (or any producer) that
+     * arrived meanwhile is admitted first and the wake simply finds the role
+     * busy. A forced, failed or uncertain cancellation never queues the wake.
+     */
+    tryUrgentReminder(origin: Extract<PromptOrigin, {
+        kind: 'self-reminder';
+    }>, hooks: UrgentReminderHooks): Promise<ReminderAttempt>;
+    /** The exact interruptible turn, or why there is none. Synchronous by design. */
+    private urgentTarget;
+    private queueReminder;
+    /** Retire only at the same admission boundary used by all prompt producers. */
+    retireIfIdle(expired: (snapshot: SessionSnapshot, queueDepth: number) => boolean): Promise<boolean>;
+    sharedTurnId(promptId: string): string | undefined;
     stopScheduledAdmission(): void;
     isAlive(): boolean;
     snapshot(): SessionSnapshot;
@@ -70,8 +162,14 @@ 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;
+    interruptPrompt(generation: string, promptId: string): Promise<InterruptOutcome>;
     interrupt(source?: TurnCancellationSource): Promise<InterruptOutcome>;
     respondPermission(permissionId: string, optionId: string): boolean;
     respondPermissionV2(permissionId: string, optionId: string, sessionGeneration: string): 'accepted' | 'stale';

package/dist/session/arbiter.js

@@ -1,4 +1,14 @@
 import { ACP_CANCEL_DEADLINE_EXCEEDED, SessionControlError, interruptOutcome, } from './types.js';
+/**
+ * Turn sources an urgent reminder may cancel. Owner-channel requests and the
+ * owner console are owner commands: cancelling one finalizes the request and
+ * its reply route (owner-channel/channel.ts), which is an owner-visible
+ * effect. Startup is the readiness gate, stall-watchdog is mid-recovery, and
+ * another self-reminder's turn must not be cancelled by a sibling.
+ */
+const URGENT_INTERRUPTIBLE = new Set(['fleet-monitor', 'scheduled-loop', 'local-console']);
+/** How long a settled cancellation may take to surface the target's own terminal result. */
+const URGENT_CORRELATION_MS = 2_000;
 /**
  * Raised for admissions that were still waiting on a generation which had to be
  * retired. It carries `ACP_CANCEL_DEADLINE_EXCEEDED` because that is the only
@@ -28,7 +38,12 @@ export class RoleTurnArbiter {
     capabilities;
     tail = Promise.resolve();
     unsettled = 0;
+    /** Admissions waiting for the boundary; an urgent interruption yields to them. */
+    waiting = 0;
+    /** Terminal results of prompts this arbiter admitted and that have not settled yet. */
+    live = new Map();
     stopping = false;
+    retiring = false;
     /** Bumped by `retireStalledAdmission`; every claim carries the one it was made under. */
     generation = 0;
     /** Resolves the instant the CURRENT generation is retired. */
@@ -48,11 +63,18 @@ export class RoleTurnArbiter {
      */
     exclusive(operation) {
         const generation = this.generation;
+        this.waiting++;
+        let counted = true;
+        const uncount = () => { if (counted) {
+            counted = false;
+            this.waiting = Math.max(0, this.waiting - 1);
+        } };
         const run = Promise.race([this.tail, this.retirement.promise]).then(() => {
+            uncount();
             if (generation !== this.generation)
                 throw new AdmissionRetiredError();
             return operation();
-        });
+        }, error => { uncount(); throw error; });
         this.tail = run.then(() => undefined, () => undefined);
         return run;
     }
@@ -60,10 +82,12 @@ export class RoleTurnArbiter {
         const generation = this.generation;
         this.unsettled++;
         const completion = queued.completion.finally(() => {
+            this.live.delete(queued.promptId);
             // A retired generation's claims were released in one step already.
             if (generation === this.generation)
                 this.unsettled = Math.max(0, this.unsettled - 1);
         });
+        this.live.set(queued.promptId, completion);
         return { ...queued, completion };
     }
     /**
@@ -86,10 +110,29 @@ export class RoleTurnArbiter {
         this.retirement = retirementSignal();
         this.tail = Promise.resolve();
         this.unsettled = 0;
+        this.waiting = 0;
         retired.retire();
     }
     queuePrompt(text, options = {}) {
-        return this.exclusive(async () => this.track(await this.session.queuePrompt(text, options)));
+        return this.exclusive(async () => {
+            if (this.retiring)
+                throw new Error('Chat is closing');
+            return this.track(await this.session.queuePrompt(text, this.monitorAdmissionOptions(options)));
+        });
+    }
+    /** Inbox traffic must not cancel or steer an active human console/voice turn.
+     * Queue it once; the monitor commits its cursor after that turn succeeds.
+     * Other origins retain their configured monitor policy.
+     */
+    monitorAdmissionOptions(options) {
+        if (options.origin?.kind !== 'fleet-monitor')
+            return options;
+        const active = this.session.snapshot().activePromptSource;
+        // A self-reminder turn is protected the same way: a retried wake (say the
+        // one an urgent reminder just interrupted) queues behind it instead of
+        // cancelling it before the agent could inspect and acknowledge.
+        return active === 'owner-admin-console' || active === 'self-reminder'
+            ? { ...options, interrupt: false, steer: false } : options;
     }
     async submitPrompt(text, options = {}) {
         return (await this.queuePrompt(text, options)).completion;
@@ -99,6 +142,10 @@ export class RoleTurnArbiter {
      * answers and explicit interrupts must remain able to pass immediately.
      */
     submitPromptAfterTool(text, options = {}) {
+        if (this.retiring)
+            return Promise.reject(new Error('Chat is closing'));
+        if (this.monitorAdmissionOptions(options) !== options)
+            return this.submitPrompt(text, options);
         return this.session.submitPromptAfterTool?.(text, options)
             ?? this.session.submitPrompt(text, { ...options, interrupt: false, steer: false });
     }
@@ -136,6 +183,179 @@ export class RoleTurnArbiter {
             throw error;
         });
     }
+    /**
+     * Admit a self-reminder wake only into an idle role, at the same boundary
+     * every producer uses. It never interrupts or steers, and never joins a
+     * queue behind other work: a busy role answers `busy` and the caller tries
+     * again later. `beforeQueue` makes the caller's durable claim; if it
+     * declines, nothing is queued. `releaseGuard` is the session's last-moment
+     * fence and is the only way the prompt can reach the model.
+     */
+    async tryReminder(text, origin, beforeQueue, releaseGuard) {
+        await new Promise(resolve => setImmediate(resolve));
+        return this.exclusive(async () => {
+            const snapshot = this.session.snapshot();
+            if (this.stopping || this.retiring || !snapshot.alive || snapshot.readiness === 'failed')
+                return { state: 'unavailable', error: this.stopping ? 'role is stopping' : 'session is unavailable', admitted: false };
+            if (snapshot.readiness !== 'idle' || this.unsettled > 0)
+                return { state: 'busy' };
+            if (!beforeQueue())
+                return { state: 'unavailable', error: 'claim declined', admitted: false };
+            try {
+                const queued = await this.session.queuePrompt(text, {
+                    interrupt: false, steer: false, origin, releaseGuard,
+                });
+                return { state: 'admitted', queued: this.track(queued) };
+            }
+            catch (error) {
+                return { state: 'unavailable', error: error?.message ?? String(error), admitted: false };
+            }
+        }).catch(error => {
+            if (error instanceof AdmissionRetiredError)
+                return { state: 'unavailable', error: error.message, admitted: false };
+            throw error;
+        });
+    }
+    /**
+     * Admit an URGENT self-reminder wake. Idle: exactly `tryReminder`. Busy: the
+     * reminder may ask the exact checked turn to stop — once per event — and is
+     * then admitted at the next boundary like any other reminder.
+     *
+     * The check and the cancel request happen in one synchronous step inside the
+     * admission boundary, so the turn asked to stop is the turn that was checked.
+     * Only a running, correlatable, interruptible turn with nothing queued behind
+     * it and no admission waiting is ever asked to stop; anything else is a
+     * reported deferral (`busy`). After the cancellation the boundary is given up
+     * before the wake is queued, so an owner prompt (or any producer) that
+     * arrived meanwhile is admitted first and the wake simply finds the role
+     * busy. A forced, failed or uncertain cancellation never queues the wake.
+     */
+    async tryUrgentReminder(origin, hooks) {
+        await new Promise(resolve => setImmediate(resolve));
+        const unavailable = (error) => ({ state: 'unavailable', error, admitted: false });
+        const first = await this.exclusive(async () => {
+            const snapshot = this.session.snapshot();
+            if (this.stopping || this.retiring || !snapshot.alive || snapshot.readiness === 'failed')
+                return unavailable(this.stopping ? 'role is stopping' : 'session is unavailable');
+            if (snapshot.readiness === 'idle' && this.unsettled === 0)
+                return this.queueReminder(hooks, origin);
+            const deferral = this.urgentTarget(snapshot);
+            if (typeof deferral === 'string' || !hooks.mayInterrupt()) {
+                hooks.deferred(typeof deferral === 'string' ? deferral : 'interrupt_already_used');
+                return { state: 'busy' };
+            }
+            if (!hooks.beforeQueue())
+                return unavailable('claim declined');
+            if (!hooks.markRequested(deferral))
+                return unavailable('interrupt request not recorded');
+            const terminal = this.live.get(deferral.promptId);
+            // No await between the check above and this call: the session cancels
+            // the turn that was checked, never a successor.
+            let report;
+            try {
+                const outcome = interruptOutcome(await this.session.interrupt('self-reminder'));
+                report = outcome.state === 'forced'
+                    ? { target: deferral, outcome: 'forced', ...(outcome.reasonCode ? { reason: outcome.reasonCode } : {}) }
+                    : { target: deferral, outcome: await correlate(terminal) };
+            }
+            catch (error) {
+                report = { target: deferral, outcome: 'failed', reason: controlReason(error) };
+            }
+            hooks.recordOutcome(report);
+            return report;
+        }).catch(error => {
+            if (error instanceof AdmissionRetiredError)
+                return unavailable(error.message);
+            throw error;
+        });
+        if ('state' in first)
+            return first;
+        if (first.outcome === 'forced' || first.outcome === 'failed')
+            return unavailable(`interruption ${first.outcome}; the wake was not queued`);
+        // Give up the boundary: anything that queued during the cancellation —
+        // owner input first among them — is admitted before the wake.
+        await new Promise(resolve => setImmediate(resolve));
+        return this.exclusive(async () => {
+            const snapshot = this.session.snapshot();
+            if (this.stopping || this.retiring || !snapshot.alive || snapshot.readiness === 'failed')
+                return unavailable(this.stopping ? 'role is stopping' : 'session is unavailable');
+            if (!hooks.stillAdmitting())
+                return unavailable('reminder changed during the interruption');
+            if (snapshot.readiness !== 'idle' || this.unsettled > 0 || this.waiting > 0)
+                return { state: 'busy' };
+            return this.queueReminder(hooks, origin, first, false);
+        }).catch(error => {
+            if (error instanceof AdmissionRetiredError)
+                return unavailable(error.message);
+            throw error;
+        });
+    }
+    /** The exact interruptible turn, or why there is none. Synchronous by design. */
+    urgentTarget(snapshot) {
+        if (snapshot.readiness === 'starting')
+            return 'session_starting';
+        if (snapshot.readiness === 'awaiting_permission' || snapshot.pendingPermissionId)
+            return 'permission_pending';
+        if (snapshot.readiness !== 'running')
+            return 'untracked_turn';
+        const source = snapshot.activePromptSource;
+        if (!source)
+            return 'untracked_turn';
+        if (!URGENT_INTERRUPTIBLE.has(source))
+            return 'protected_turn';
+        if (!this.session.capabilities?.interrupt)
+            return 'interrupt_unsupported';
+        if (this.waiting > 0 || this.unsettled > 1)
+            return 'queued_work';
+        if (!this.session.observeConversation)
+            return 'uncorrelatable';
+        let state;
+        try {
+            const observation = this.session.observeConversation(() => { });
+            state = observation.snapshot;
+            observation.unsubscribe();
+        }
+        catch {
+            return 'uncorrelatable';
+        }
+        if (state.pendingPermissions.length || state.pendingPermissionIds.length)
+            return 'permission_pending';
+        if (state.pendingPromptCount > 0 || state.queueDepth > 1)
+            return 'queued_work';
+        if (state.activePromptIds.length < 1)
+            return 'untracked_turn';
+        return {
+            source, generation: state.sessionGeneration, promptId: state.activePromptIds[0],
+            ...(snapshot.sessionId ? { sessionId: snapshot.sessionId } : {}),
+        };
+    }
+    async queueReminder(hooks, origin, report, claim = true) {
+        if (claim && !hooks.beforeQueue())
+            return { state: 'unavailable', error: 'claim declined', admitted: false };
+        try {
+            const queued = await this.session.queuePrompt(hooks.text(report), {
+                interrupt: false, steer: false, origin, releaseGuard: () => hooks.releaseGuard(),
+            });
+            return { state: 'admitted', queued: this.track(queued) };
+        }
+        catch (error) {
+            return { state: 'unavailable', error: error?.message ?? String(error), admitted: false };
+        }
+    }
+    /** Retire only at the same admission boundary used by all prompt producers. */
+    retireIfIdle(expired) {
+        return this.exclusive(async () => {
+            const snapshot = this.session.snapshot();
+            const queue = this.session.conversationSnapshot?.().queueDepth ?? -1;
+            if (this.retiring || this.unsettled > 0 || snapshot.readiness !== 'idle' || !expired(snapshot, queue))
+                return false;
+            this.retiring = true;
+            this.stopping = true;
+            await this.session.close();
+            return true;
+        });
+    }
+    sharedTurnId(promptId) { return this.session.sharedTurnId?.(promptId); }
     stopScheduledAdmission() { this.stopping = true; }
     isAlive() { return this.session.isAlive(); }
     snapshot() { return this.session.snapshot(); }
@@ -149,6 +369,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');
@@ -157,7 +395,16 @@ export class RoleTurnArbiter {
     submitPromptBrowser(command) {
         if (!this.session.submitPromptBrowser)
             return Promise.reject(new Error('browser prompt admission is unavailable'));
-        return this.exclusive(() => this.session.submitPromptBrowser(command));
+        return this.exclusive(() => { if (this.retiring)
+            throw new Error('Chat is closing'); return this.session.submitPromptBrowser(command); });
+    }
+    get liveVoiceSupported() { return this.session.liveVoiceSupported === true; }
+    interruptPrompt(generation, promptId) {
+        return this.exclusive(async () => {
+            if (!this.session.interruptPrompt)
+                throw new Error('targeted voice interrupt is unavailable');
+            return interruptOutcome(await this.session.interruptPrompt(generation, promptId));
+        });
     }
     interrupt(source = 'local-console') {
         return this.exclusive(async () => interruptOutcome(await this.session.interrupt(source)));
@@ -175,3 +422,25 @@ export class RoleTurnArbiter {
     exitResult() { return this.session.exitResult(); }
     close() { return this.session.close(); }
 }
+/**
+ * Whether the target's own terminal result proves this request cancelled it.
+ * A settled interrupt says only that the turn (or nothing) ended; without the
+ * target's correlated result the honest answer is `ended`.
+ */
+async function correlate(terminal) {
+    if (!terminal)
+        return 'ended';
+    let timer;
+    const result = await Promise.race([
+        terminal,
+        new Promise(resolve => { timer = setTimeout(() => resolve(undefined), URGENT_CORRELATION_MS); timer.unref?.(); }),
+    ]);
+    if (timer)
+        clearTimeout(timer);
+    return result?.outcome === 'cancelled' && result.cancellationSource === 'self-reminder' ? 'cancelled' : 'ended';
+}
+function controlReason(error) {
+    if (error instanceof SessionControlError)
+        return error.reasonCode ?? error.kind;
+    return 'control_error';
+}

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

@@ -1,5 +1,7 @@
+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';
 type JsonObject = Record<string, unknown>;
@@ -10,6 +12,9 @@ export interface CodexAppServerSessionOptions {
     env: Record<string, string>;
     stateDir: string;
     mode: 'fresh' | 'resume';
+    requireResume?: boolean;
+    /** Hold recovered never-started prompts until activateRecoveredPrompts(). */
+    deferRecoveredPrompts?: boolean;
     permissions: CommonPermissions;
     permissionMode: NonNullable<SessionSnapshot['permissionMode']>;
     model?: string | null;
@@ -28,6 +33,16 @@ export interface CodexAppServerSessionOptions {
 }
 /** Server-generated application provenance for authenticated browser prompts only. */
 export declare function nativePromptAdditionalContext(origin: PromptOrigin | undefined): JsonObject | undefined;
+/**
+ * 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 declare function nativeBatchAdditionalContext(members: ReadonlyArray<Pick<PendingPrompt, 'text' | 'origin'>>): JsonObject | undefined;
 /** Native Codex session implementing Fleet's provider-neutral live-session contract. */
 export declare class CodexAppServerSession implements AgentSession {
     private readonly options;
@@ -53,7 +68,13 @@ export declare class CodexAppServerSession implements AgentSession {
     private lastError?;
     private exit;
     private queueDepth;
+    private readonly deferredRecovered;
+    private readonly observation;
     private promptTail;
+    /** Admitted prompts not yet handed to the app-server, in admission order. */
+    private readonly pendingPrompts;
+    /** Admitted prompt → the turn that carries it, while that turn is open. */
+    private readonly sharedTurns;
     private activeTurn?;
     private controllerCount;
     private controllerGrace?;
@@ -67,7 +88,20 @@ export declare class CodexAppServerSession implements AgentSession {
     isAlive(): boolean;
     snapshot(): SessionSnapshot;
     queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
+    /** The turn whose events and result answer this admitted prompt; itself unless a release shared it. */
+    sharedTurnId(promptId: string): string | undefined;
+    /** Each prompt keeps its own step in the chain; the step it reaches releases a whole snapshot. */
+    private enqueue;
+    /**
+     * 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.
+     */
+    private release;
     submitPrompt(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
+    readonly liveVoiceSupported = true;
+    interruptPrompt(generation: string, promptId: string): Promise<InterruptOutcome>;
     interrupt(source?: TurnCancellationSource): Promise<InterruptOutcome>;
     respondPermission(permissionId: string, optionId: string): boolean;
     respondPermissionV2(permissionId: string, optionId: string, sessionGeneration: string): 'accepted' | 'stale';
@@ -76,15 +110,25 @@ export declare class CodexAppServerSession implements AgentSession {
     setControllerAttached(attached: boolean): void;
     exitResult(): ExitRecord | null;
     close(): Promise<void>;
+    taskNoticeBinding(): TaskNoticeBinding | undefined;
+    recordTaskCreated(binding: TaskNoticeBinding, notice: TaskCreatedNotice): void;
     conversationPage(request?: {
         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>;
     private initialize;
     private recoverOpenPrompts;
+    /** Dispatch recovered prompts once the caller's control plane is listening. */
+    activateRecoveredPrompts(): void;
+    private dispatchRecovered;
     private admit;
     private runPrompt;
     private steer;