@ours.network/fleet 1.2.0-nightly.6 → 1.2.0-nightly.60

package/dist/session/arbiter.js

@@ -29,6 +29,7 @@ export class RoleTurnArbiter {
     tail = Promise.resolve();
     unsettled = 0;
     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. */
@@ -89,7 +90,20 @@ export class RoleTurnArbiter {
         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) {
+        return options.origin?.kind === 'fleet-monitor'
+            && this.session.snapshot().activePromptSource === 'owner-admin-console'
+            ? { ...options, interrupt: false, steer: false } : options;
     }
     async submitPrompt(text, options = {}) {
         return (await this.queuePrompt(text, options)).completion;
@@ -99,6 +113,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 +154,20 @@ export class RoleTurnArbiter {
             throw error;
         });
     }
+    /** 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(); }
@@ -157,7 +189,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)));

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 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,7 @@ export interface CodexAppServerSessionOptions {
     env: Record<string, string>;
     stateDir: string;
     mode: 'fresh' | 'resume';
+    requireResume?: boolean;
     permissions: CommonPermissions;
     permissionMode: NonNullable<SessionSnapshot['permissionMode']>;
     model?: string | null;
@@ -28,6 +31,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;
@@ -54,6 +67,10 @@ export declare class CodexAppServerSession implements AgentSession {
     private exit;
     private queueDepth;
     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 +84,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,6 +106,8 @@ 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;

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

@@ -1,8 +1,11 @@
+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, } 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 +15,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);
@@ -74,6 +76,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 {
@@ -122,6 +149,10 @@ export class CodexAppServerSession {
     exit = null;
     queueDepth = 0;
     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;
@@ -172,6 +203,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,
@@ -202,8 +236,7 @@ export class CodexAppServerSession {
         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.enqueue(promptId, text, options.origin);
         const completion = run.then(result => {
             this.queueDepth = Math.max(0, this.queueDepth - 1);
             return result;
@@ -216,6 +249,42 @@ 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) {
+        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',
+        };
+        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 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 +295,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({
@@ -335,6 +414,10 @@ export class CodexAppServerSession {
         this.conversation.close();
         await this.transport.close();
     }
+    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);
@@ -354,6 +437,7 @@ export class CodexAppServerSession {
             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,6 +451,10 @@ 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 },
@@ -387,6 +475,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 +496,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,6 +507,10 @@ 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' },
@@ -437,8 +533,7 @@ export class CodexAppServerSession {
             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);
+            const run = this.enqueue(open.promptId, open.text, origin);
             void run.finally(() => { this.queueDepth = Math.max(0, this.queueDepth - 1); });
         }
     }
@@ -470,30 +565,43 @@ 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.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 +807,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 +854,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 +880,16 @@ 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 } : {}),
+                },
+            });
         active.settle(result);
     }
     /**

package/dist/session/control.d.ts

@@ -1,3 +1,5 @@
+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 { AgentSession, ControlFailureKind, SessionEvent, SessionSnapshot } from './types.js';
 import type { OwnerChannelHandle, OwnerChannelManagementRequest } from '../owner-channel/channel.js';
@@ -9,8 +11,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;
@@ -112,9 +119,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);

package/dist/session/control.js

@@ -1,3 +1,4 @@
+import { socketPath as privateSocketPath } from '../socket-path.js';
 import { randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { chmodSync, existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { createConnection, createServer } from 'node:net';
@@ -8,7 +9,7 @@ import { interruptSession, queueSessionPrompt, respondSessionPermission, respond
 const MAX_LINE_BYTES = 64 * 1024;
 /** Commands that require protocol version 3. */
 const V3_COMMANDS = new Set([
-    'conversation_page', 'conversation_follow', 'submit_prompt_v2', 'interrupt_v2',
+    'conversation_page', 'conversation_follow', 'submit_prompt_v2', 'submit_voice_prompt', 'interrupt_v2', 'interrupt_voice_v2',
     'respond_permission_v2',
 ]);
 /** The one retained-range projection shared by polling and live-follow admission. */
@@ -99,7 +100,7 @@ export function oversightTaxonomy(name = '<Name>') {
 export function oversightTaxonomyLines(name = '<Name>') {
     return oversightTaxonomy(name).map(r => `- **${r.result}** — ${r.meaning} → ${r.action}`);
 }
-export const controlSocketPath = (stateDir) => join(stateDir, '.control.sock');
+export const controlSocketPath = (stateDir) => privateSocketPath(join(stateDir, '.control.sock'));
 export const controlTokenPath = (stateDir) => join(stateDir, '.control-token');
 function sameToken(actual, supplied) {
     const a = Buffer.from(actual);
@@ -116,9 +117,13 @@ export class RoleControlServer {
     sockets = new Set();
     /** Interrupt idempotency: same command id returns the first receipt. */
     interruptCommands = new Map();
+    correspondence;
+    setCorrespondence(value) { this.correspondence = value; }
     ownerChannel;
     loopManager;
     reloadConfig;
+    layoutControl;
+    setLayoutControl(handler) { this.layoutControl = handler; }
     fleetSpawner;
     fleetAuditor;
     constructor(stateDir, session, log) {
@@ -235,7 +240,10 @@ export class RoleControlServer {
                             protocolVersion: this.session.conversationPage ? 3 : 2,
                             features: [
                                 'events_since', 'observer_follow', 'retained_range',
+                                ...(this.correspondence ? ['agent_correspondence'] : []),
                                 ...(this.session.conversationPage ? ['conversation_v3'] : []),
+                                ...(this.session.submitPromptBrowser ? ['generation_bound_prompts'] : []),
+                                ...(this.session.liveVoiceSupported ? ['idle_bound_prompts', 'targeted_voice_interrupt'] : []),
                                 ...(this.session.capabilities?.steering ? ['steering'] : []),
                                 ...(this.session.capabilities?.permissions ? ['permissions'] : []),
                                 ...(this.session.capabilities?.messagePhases ? ['message_phases'] : []),
@@ -308,6 +316,13 @@ export class RoleControlServer {
                     });
                     return;
                 }
+                case 'layout_control': {
+                    if (request.version !== 2 || !request.layout || !this.layoutControl)
+                        throw new SessionControlError('rejected', 'layout control unavailable');
+                    const result = await this.layoutControl(request.layout);
+                    this.write(socket, { version: 1, id: request.id, ok: true, result });
+                    return;
+                }
                 case 'fleet_spawn': {
                     if (request.version !== 2 || !request.spawn || typeof request.spawn.name !== 'string')
                         throw new SessionControlError('rejected', 'version 2 and typed spawn options are required');
@@ -362,6 +377,23 @@ export class RoleControlServer {
                     this.write(socket, { version: 1, id: request.id, ok: true, result: { delivered: true } });
                     return;
                 }
+                case 'agent_contacts':
+                case 'agent_history': {
+                    if (!this.correspondence)
+                        throw new SessionControlError('rejected', 'Supervisor correspondence API is unavailable; this session needs an updated supervisor.');
+                    const query = request.agentHistory;
+                    if (request.command === 'agent_history' && (!query || !/^[a-f0-9]{64}$/i.test(query.peer_cid) || (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 200)) || (query.before_seq !== undefined && (!Number.isSafeInteger(query.before_seq) || query.before_seq < 1))))
+                        throw new SessionControlError('rejected', 'Valid peer_cid, limit (1–200) and before_seq are required.');
+                    let result;
+                    try {
+                        result = request.command === 'agent_contacts' ? await this.correspondence.contacts() : await this.correspondence.history(query);
+                    }
+                    catch {
+                        throw new SessionControlError('rejected', 'Supervisor correspondence read failed; identity or transport is unavailable.');
+                    }
+                    this.write(socket, { version: 1, id: request.id, ok: true, result });
+                    return;
+                }
                 case 'owner_channel_manage': {
                     if (!request.ownerChannel || typeof request.ownerChannel.action !== 'string')
                         throw new SessionControlError('rejected', 'owner-channel management action is required');
@@ -421,7 +453,10 @@ export class RoleControlServer {
                                 socket.write(JSON.stringify({ version: 1, conversationEvent: event }) + '\n');
                         }) };
                 }
+                case 'submit_voice_prompt':
                 case 'submit_prompt_v2': {
+                    if (request.command === 'submit_voice_prompt' && !request.expectedSessionGeneration?.trim())
+                        throw new SessionControlError('rejected', 'expectedSessionGeneration is required');
                     this.requireConversation(request);
                     if (!request.commandId?.trim() || !request.text?.trim() || !request.actor?.trim()
                         || request.source !== 'owner_admin_console')
@@ -432,6 +467,7 @@ export class RoleControlServer {
                         const receipt = await this.session.submitPromptBrowser({
                             commandId: request.commandId, text: request.text,
                             source: 'owner_admin_console', actorBrowserSession: request.actor,
+                            expectedSessionGeneration: request.expectedSessionGeneration, requireIdle: request.requireIdle === true,
                         });
                         this.write(socket, { version: 1, id: request.id, ok: true, result: receipt });
                     }
@@ -442,6 +478,29 @@ export class RoleControlServer {
                     }
                     return;
                 }
+                case 'interrupt_voice_v2': {
+                    this.requireConversation(request);
+                    if (!request.commandId?.trim() || !request.expectedSessionGeneration?.trim() || !request.promptId?.trim())
+                        throw new SessionControlError('rejected', 'commandId, expectedSessionGeneration and promptId are required');
+                    if (!this.session.interruptPrompt)
+                        throw new SessionControlError('rejected', 'targeted voice interrupt unavailable');
+                    const key = 'voice:' + request.commandId;
+                    const signature = JSON.stringify([request.expectedSessionGeneration, request.promptId]);
+                    const existing = this.interruptCommands.get(key);
+                    if (existing) {
+                        if (existing.signature !== signature)
+                            throw new SessionControlError('rejected', 'idempotency_conflict: interrupt target changed');
+                        this.write(socket, { version: 1, id: request.id, ok: true, result: existing.receipt });
+                        return;
+                    }
+                    const outcome = await this.session.interruptPrompt(request.expectedSessionGeneration, request.promptId);
+                    const receipt = { accepted: true, commandId: request.commandId, ...outcome };
+                    this.interruptCommands.set(key, { signature, receipt });
+                    if (this.interruptCommands.size > 200)
+                        this.interruptCommands.delete(this.interruptCommands.keys().next().value);
+                    this.write(socket, { version: 1, id: request.id, ok: true, result: receipt });
+                    return;
+                }
                 case 'interrupt_v2': {
                     this.requireConversation(request);
                     if (!request.commandId?.trim())
@@ -532,7 +591,13 @@ export async function controlRequest(stateDir, request, timeoutMs = 120_000) {
         socket.once('error', error => {
             clearTimeout(timer);
             const code = error.code;
-            reject(new SessionControlError(code === 'ENOENT' || code === 'ECONNREFUSED' ? 'control-unavailable' : 'backend', `role control socket: ${error.message}`));
+            const permissionHint = code === 'EPERM' || code === 'EACCES'
+                ? `; the operating system denied access before '${request.command}' reached the supervisor. `
+                    + 'Check socket permissions and the command execution sandbox. '
+                    + 'An existing socket does not prove this process can connect; do not bypass Fleet audit. '
+                    + 'For managed workspace sessions, see docs/validation/managed-cli-permissions.md.'
+                : '';
+            reject(new SessionControlError(code === 'ENOENT' || code === 'ECONNREFUSED' ? 'control-unavailable' : 'backend', `role control socket: ${error.message}${permissionHint}`));
         });
         socket.on('data', chunk => {
             buffer += chunk;