@ours.network/fleet 1.2.0-nightly.5 → 1.2.0-nightly.51

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

@@ -1,3 +1,4 @@
+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 { CodexAppServerTransportFactory } from './codex-app-server-transport.js';
@@ -68,6 +69,8 @@ export declare class CodexAppServerSession implements AgentSession {
     snapshot(): SessionSnapshot;
     queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
     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 +79,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,6 +1,8 @@
+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 { CodexAppServerTransport } from './codex-app-server-transport.js';
@@ -12,7 +14,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);
@@ -226,10 +227,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?.promptId !== 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 +346,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);
@@ -367,6 +382,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 },
@@ -415,6 +434,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' },
@@ -486,6 +509,12 @@ export class CodexAppServerSession {
             promptId, turnId: promptId, source: sourceFor(origin).source, payload: {},
         });
         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: [] }],
@@ -699,7 +728,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 +775,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 }) } : {}),
             },
         });
     }

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;

package/dist/session/conversation-normalizer.d.ts

@@ -1,5 +1,5 @@
 import type * as acp from '@agentclientprotocol/sdk';
-import type { AdapterMeta, ConversationEventKind, ConversationPayload } from './conversation-types.js';
+import type { AdapterMeta, BoundedJson, ConversationEventKind, ConversationPayload } from './conversation-types.js';
 /**
  * Reduce one ACP v1 `session/update` into one conversation-domain event draft.
  *
@@ -43,4 +43,5 @@ export interface NormalizedUpdate {
     toolCallId?: string;
     adapterMeta?: AdapterMeta[];
 }
+export declare function boundedJson(value: unknown): BoundedJson;
 export declare function normalizeSessionUpdate(update: acp.SessionUpdate, options?: NormalizeOptions): NormalizedUpdate;

package/dist/session/conversation-normalizer.js

@@ -246,7 +246,7 @@ function redactSensitiveJson(value) {
     };
     return { value: visit(value, 0), redacted };
 }
-function boundedJson(value) {
+export function boundedJson(value) {
     let serialized;
     let safe;
     let redacted = false;

package/dist/session/conversation-store.d.ts

@@ -29,6 +29,7 @@ type EventDraft = Omit<ConversationEventV1, 'schemaVersion' | 'roleId' | 'eventI
 export declare class ConversationEventStore {
     private readonly dir;
     private nextSeq;
+    private firstAvailableSeq?;
     private segments;
     private tail;
     private readonly listeners;
@@ -81,7 +82,6 @@ export declare class ConversationEventStore {
     private trackPromptState;
     private segmentFd;
     private writeManifest;
-    private firstStoredSeq;
     private eventsAfter;
     private markDegraded;
 }

package/dist/session/conversation-store.js

@@ -24,6 +24,7 @@ export class IdempotencyConflictError extends Error {
 export class ConversationEventStore {
     dir;
     nextSeq = 1;
+    firstAvailableSeq;
     segments = [];
     tail = [];
     listeners = new Set();
@@ -72,6 +73,7 @@ export class ConversationEventStore {
         const fd = this.segmentFd(Buffer.byteLength(line));
         writeSync(fd, line);
         fsyncSync(fd);
+        this.firstAvailableSeq ??= event.seq;
         this.nextSeq++;
         this.activeBytes += Buffer.byteLength(line);
         this.tail.push(event);
@@ -101,7 +103,10 @@ export class ConversationEventStore {
         const events = this.eventsAfter(after, limit + 1);
         const hasMore = events.length > limit;
         const pageEvents = hasMore ? events.slice(0, limit) : events;
-        const firstStored = this.firstStoredSeq();
+        // This single-writer store never removes retained segments. Recovery and
+        // append already know the first readable sequence; paging the memory tail
+        // must not parse the first segment again, especially while skipping replay.
+        const firstStored = this.firstAvailableSeq;
         return {
             events: pageEvents,
             ...(firstStored !== undefined ? { firstAvailableCursor: String(firstStored) } : {}),
@@ -159,6 +164,7 @@ export class ConversationEventStore {
         let maxSeq = 0;
         for (const segment of this.segments) {
             for (const event of this.readSegment(segment)) {
+                this.firstAvailableSeq ??= event.seq;
                 maxSeq = Math.max(maxSeq, event.seq);
                 this.tail.push(event);
                 if (this.tail.length > TAIL_EVENTS)
@@ -308,16 +314,6 @@ export class ConversationEventStore {
         }
     }
     // ── reads ──────────────────────────────────────────────────────────────────
-    firstStoredSeq() {
-        if (this.tail.length && this.tail[0].seq === 1)
-            return 1;
-        for (const segment of this.segments) {
-            const events = this.readSegment(segment);
-            if (events.length)
-                return events[0].seq;
-        }
-        return this.tail[0]?.seq;
-    }
     eventsAfter(after, limit) {
         // Serve from the in-memory tail whenever the range allows it.
         if (this.tail.length && after >= this.tail[0].seq - 1)

package/dist/session/conversation-types.d.ts

@@ -1,3 +1,4 @@
+import type { TaskCreatedNotice } from './task-notice.js';
 import type { PromptOrigin, TurnCancellationSource, TurnOutcome } from './types.js';
 /**
  * Durable conversation domain schema for managed-session consoles.
@@ -7,11 +8,11 @@ import type { PromptOrigin, TurnCancellationSource, TurnOutcome } from './types.
  * file touches the wire: transport updates are reduced into these shapes by a
  * session adapter, and the store assigns `seq`/`eventId`/timestamps.
  */
-export type ConversationEventKind = 'prompt.admitted' | 'prompt.started' | 'prompt.interrupt_requested' | 'message.chunk' | 'message.replace' | 'thought.chunk' | 'thought.replace' | 'plan.replace' | 'tool.upsert' | 'tool.content_chunk' | 'permission.requested' | 'permission.resolved' | 'monitor.delivery' | 'usage.updated' | 'turn.state' | 'turn.completed' | 'session.state' | 'session.info' | 'capabilities.updated' | 'error'
+export type ConversationEventKind = 'prompt.admitted' | 'prompt.started' | 'prompt.interrupt_requested' | 'message.chunk' | 'message.replace' | 'thought.chunk' | 'thought.replace' | 'plan.replace' | 'tool.upsert' | 'tool.content_chunk' | 'permission.requested' | 'permission.resolved' | 'fleet.task_created' | 'monitor.delivery' | 'usage.updated' | 'turn.state' | 'turn.completed' | 'session.state' | 'session.info' | 'capabilities.updated' | 'error'
 /** A well-formed transport update this version cannot represent. Bounded, never a crash. */
  | 'unsupported';
 /** Where a conversation record came from. Typed provenance, never prompt text. */
-export type ConversationSource = 'owner_admin_console' | 'owner_channel' | 'fleet_monitor' | 'scheduled_loop' | 'startup' | 'local_console' | 'agent' | 'agent_replay';
+export type ConversationSource = 'owner_admin_console' | 'owner_channel' | 'fleet_monitor' | 'scheduled_loop' | 'startup' | 'local_console' | 'agent' | 'agent_replay' | 'fleet_lifecycle';
 export interface NormalizedText {
     type: 'text';
     text: string;
@@ -227,7 +228,7 @@ export interface BoundedJson {
     digest?: string;
     redacted?: true;
 }
-export type ConversationPayload = MessageChunkPayload | ThoughtChunkPayload | PlanReplacePayload | ToolUpsertPayload | UsageUpdatedPayload | SessionStatePayload | SessionInfoPayload | CapabilitiesUpdatedPayload | UnsupportedPayload | PromptAdmittedPayload | PromptStartedPayload | PromptInterruptRequestedPayload | PermissionRequestedPayload | PermissionResolvedPayload | TurnStatePayload | TurnCompletedPayload | MonitorDeliveryPayload | SessionLifecyclePayload | ErrorPayload;
+export type ConversationPayload = MessageChunkPayload | ThoughtChunkPayload | PlanReplacePayload | ToolUpsertPayload | UsageUpdatedPayload | SessionStatePayload | SessionInfoPayload | CapabilitiesUpdatedPayload | UnsupportedPayload | PromptAdmittedPayload | PromptStartedPayload | PromptInterruptRequestedPayload | PermissionRequestedPayload | PermissionResolvedPayload | TurnStatePayload | TurnCompletedPayload | MonitorDeliveryPayload | SessionLifecyclePayload | ErrorPayload | TaskCreatedNotice;
 export interface ConversationEventV1 {
     schemaVersion: 1;
     roleId: string;
@@ -262,6 +263,9 @@ export interface ConversationEventV1 {
     adapterMeta?: AdapterMeta[];
 }
 export interface SubmitPromptCommand {
+    expectedSessionGeneration?: string;
+    /** Live speech must not silently queue behind an unrelated turn. */
+    requireIdle?: boolean;
     /** Idempotency-Key / clientRequestId. Reuse with a different body is a conflict. */
     commandId: string;
     text: string;

package/dist/session/task-notice.d.ts

@@ -0,0 +1,14 @@
+import type { ConversationEventStore } from './conversation-store.js';
+export interface TaskNoticeBinding {
+    sessionGeneration: string;
+    acpSessionId: string;
+    promptId: string;
+}
+export interface TaskCreatedNotice {
+    operationId: string;
+    taskId: string;
+    title: string;
+    state: string;
+}
+/** Only the trusted Fleet audit completion calls this, never model output. */
+export declare function appendTaskCreated(store: ConversationEventStore, binding: TaskNoticeBinding, notice: TaskCreatedNotice): void;

package/dist/session/task-notice.js

@@ -0,0 +1,13 @@
+/** Only the trusted Fleet audit completion calls this, never model output. */
+export function appendTaskCreated(store, binding, notice) {
+    let after;
+    do {
+        const page = store.page({ after, limit: 1000 });
+        if (page.events.some(e => e.kind === 'fleet.task_created' && e.payload.operationId === notice.operationId))
+            return;
+        if (!page.hasMore)
+            break;
+        after = page.nextCursor;
+    } while (after);
+    store.append({ kind: 'fleet.task_created', source: 'fleet_lifecycle', ...binding, turnId: binding.promptId, payload: notice });
+}

package/dist/session/types.d.ts

@@ -1,3 +1,4 @@
+import type { TaskCreatedNotice, TaskNoticeBinding } from './task-notice.js';
 import type { SessionBackendId } from '../config.js';
 import type { ConversationEventV1, ConversationSnapshot, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
 /**
@@ -289,6 +290,8 @@ export interface AgentSession {
     readonly capabilities?: AgentSessionCapabilities;
     isAlive(): boolean;
     snapshot(): SessionSnapshot;
+    taskNoticeBinding?(): TaskNoticeBinding | undefined;
+    recordTaskCreated?(binding: TaskNoticeBinding, notice: TaskCreatedNotice): void;
     conversationPage?(request: {
         after?: string;
         limit?: number;
@@ -316,6 +319,9 @@ export interface AgentSession {
      * keep compiling. Read it through `interruptOutcome`, never directly.
      */
     interrupt(source?: TurnCancellationSource): Promise<InterruptResult>;
+    /** Atomically bind cancellation to one voice-owned turn. */
+    readonly liveVoiceSupported?: boolean;
+    interruptPrompt?(generation: string, promptId: string): Promise<InterruptResult>;
     respondPermission(permissionId: string, optionId: string): boolean;
     /** Generation-bound browser decision; stale/settled/invalid all fail closed. */
     respondPermissionV2?(permissionId: string, optionId: string, sessionGeneration: string): 'accepted' | 'stale';

package/dist/setup-tunnel-preflight.d.ts

@@ -0,0 +1,34 @@
+import { type Exec } from './exec.js';
+import type { WorkspacePayload } from './workspace-enrollment.js';
+/**
+ * Check what the steps after the one-time root proof depend on, before that
+ * proof is sent: a failure afterwards cannot be retried with a fresh command.
+ */
+export declare function setupTunnelPreflight({ exec, platform, node }?: {
+    exec?: Exec;
+    platform?: NodeJS.Platform;
+    node?: string;
+}): Promise<void>;
+/** What the steps after the proof need, kept so they can be finished without a new command. */
+export interface PendingTunnelSetup {
+    appOrigin: string;
+    origin: string;
+    hostWorkspaceId: string;
+    rootCid: string;
+    challenge: WorkspacePayload['challenge'];
+    /** Fleet configuration the setup started with; a resume must use the same one. */
+    configuration: string;
+    /** Every port sent to the account as the tunnel target. Without confirmedPort, the remote target may be any of these or the default. */
+    requestedPorts?: number[];
+    /** Last positively confirmed target; cleared before any new retarget request. */
+    confirmedPort?: number;
+}
+export declare function savePendingTunnelSetup(pending: PendingTunnelSetup): void;
+export declare function clearPendingTunnelSetup(): void;
+export declare function readPendingTunnelSetup(): PendingTunnelSetup;
+export declare const DEFAULT_TUNNEL_PORT = 49271;
+/**
+ * The port the web service must bind when the account can no longer retarget
+ * the tunnel. Unknown when a different port was requested and never confirmed.
+ */
+export declare function requiredPortAfterExpiry(pending: PendingTunnelSetup): number;

package/dist/setup-tunnel-preflight.js

@@ -0,0 +1,62 @@
+import { existsSync, lstatSync, readFileSync, rmSync } from 'node:fs';
+import { userInfo } from 'node:os';
+import { join } from 'node:path';
+import { replaceFileAtomically } from './atomic-file.js';
+import { realExec } from './exec.js';
+import { stateRoot } from './paths.js';
+const UNCHANGED = 'Nothing was changed and this host was not bound.';
+/**
+ * Check what the steps after the one-time root proof depend on, before that
+ * proof is sent: a failure afterwards cannot be retried with a fresh command.
+ */
+export async function setupTunnelPreflight({ exec = realExec, platform = process.platform, node = process.versions.node } = {}) {
+    const [major, minor] = node.split('.').map(Number);
+    if (major < 22 || (major === 22 && minor < 13))
+        throw Error(`Tunnel setup requires Node.js 22.13 or newer; this is ${node}. Update Node.js, then run a fresh tunnel setup command. ${UNCHANGED}`);
+    if (platform === 'linux') {
+        const manager = await exec('systemctl', ['--user', 'show-environment'], { timeout: 10_000 });
+        if (manager.code !== 0)
+            throw Error(`The user service manager is not reachable from this shell (${manager.stderr.trim().split('\n')[0] || `systemctl --user exited ${manager.code}`}). `
+                + `Log in directly as ${userInfo().username} (not through su or sudo), or run: sudo loginctl enable-linger ${userInfo().username} && export XDG_RUNTIME_DIR=/run/user/${process.getuid?.()} `
+                + `Then run a fresh tunnel setup command. ${UNCHANGED}`);
+    }
+    const help = await exec('cloudflared', ['tunnel', 'run', '--help'], { timeout: 10_000 });
+    if (help.code === 127)
+        throw Error(`cloudflared is not installed or not on PATH. Install it, then run a fresh tunnel setup command. ${UNCHANGED}`);
+    if (help.code !== 0 || !`${help.stdout}\n${help.stderr}`.includes('--token-file'))
+        throw Error(`This cloudflared is too old for tunnel setup (no --token-file support). Update cloudflared, then run a fresh tunnel setup command. ${UNCHANGED}`);
+}
+const pendingPath = () => join(stateRoot(), 'workspace', 'pending-setup.json');
+export function savePendingTunnelSetup(pending) {
+    replaceFileAtomically(pendingPath(), JSON.stringify(pending) + '\n', 0o600);
+}
+export function clearPendingTunnelSetup() { rmSync(pendingPath(), { force: true }); }
+export function readPendingTunnelSetup() {
+    const path = pendingPath();
+    if (!existsSync(path))
+        throw Error('No unfinished tunnel setup on this host. Run the tunnel setup command from the App.');
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.uid !== process.getuid?.() || (stat.mode & 0o077) !== 0)
+        throw Error('Unfinished tunnel setup record must be an owned private file');
+    const pending = JSON.parse(readFileSync(path, 'utf8'));
+    if (typeof pending?.appOrigin !== 'string' || typeof pending.origin !== 'string' || typeof pending.hostWorkspaceId !== 'string'
+        || typeof pending.rootCid !== 'string' || !pending.challenge || !Number.isSafeInteger(pending.challenge.expiresAt) || typeof pending.configuration !== 'string'
+        || (pending.requestedPorts !== undefined && (!Array.isArray(pending.requestedPorts) || !pending.requestedPorts.every(Number.isInteger))))
+        throw Error('Unfinished tunnel setup record is invalid');
+    if (pending.confirmedPort !== undefined && (!Number.isInteger(pending.confirmedPort) || pending.confirmedPort < 1024 || pending.confirmedPort > 65535))
+        throw Error('Unfinished tunnel setup record is invalid');
+    return pending;
+}
+export const DEFAULT_TUNNEL_PORT = 49_271;
+/**
+ * The port the web service must bind when the account can no longer retarget
+ * the tunnel. Unknown when a different port was requested and never confirmed.
+ */
+export function requiredPortAfterExpiry(pending) {
+    if (pending.confirmedPort !== undefined)
+        return pending.confirmedPort;
+    const other = [...new Set(pending.requestedPorts ?? [])].filter(port => port !== DEFAULT_TUNNEL_PORT);
+    if (!other.length)
+        return DEFAULT_TUNNEL_PORT;
+    throw Error(`The setup window has expired and it is unknown whether the tunnel points at port ${[...other, DEFAULT_TUNNEL_PORT].join(' or ')}: the account's answer to a port request was not received. This setup cannot be finished automatically`);
+}

package/dist/socket-path.d.ts

@@ -0,0 +1,2 @@
+/** Optional private socket directory for deeply nested, isolated Fleet homes. */
+export declare function socketPath(logicalPath: string): string;

package/dist/socket-path.js

@@ -0,0 +1,22 @@
+import { createHash } from 'node:crypto';
+import { lstatSync, mkdirSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+/** Optional private socket directory for deeply nested, isolated Fleet homes. */
+export function socketPath(logicalPath) {
+    const root = process.env.OURS_FLEET_SOCKET_ROOT;
+    if (!root) {
+        if (Buffer.byteLength(logicalPath) > 103)
+            throw new Error('Unix socket path is too long; configure a short private OURS_FLEET_SOCKET_ROOT');
+        return logicalPath;
+    }
+    if (!isAbsolute(root) || resolve(root) !== root)
+        throw new Error('OURS_FLEET_SOCKET_ROOT must be an absolute normalized path');
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    const stat = lstatSync(root);
+    if (!stat.isDirectory() || stat.isSymbolicLink() || stat.uid !== process.getuid?.() || (stat.mode & 0o777) !== 0o700)
+        throw new Error('OURS_FLEET_SOCKET_ROOT must be an owner-only 0700 directory');
+    const path = join(root, createHash('sha256').update(resolve(logicalPath)).digest('hex').slice(0, 24) + '.sock');
+    if (Buffer.byteLength(path) > 103)
+        throw new Error('OURS_FLEET_SOCKET_ROOT is too long');
+    return path;
+}