@ours.network/fleet 1.2.0-nightly.46 → 1.2.0-nightly.47

package/dist/application/session-control.d.ts

@@ -55,8 +55,14 @@ export interface RoleSessionControl {
         text: string;
         actorBrowserSession: string;
         expectedSessionGeneration?: string;
+        requireIdle?: boolean;
         source: 'owner_admin_console';
     }): Promise<PromptReceipt>;
+    interruptPromptV2?(request: {
+        commandId: string;
+        expectedSessionGeneration: string;
+        promptId: string;
+    }): Promise<InterruptReceipt>;
     interruptV2?(commandId: string): Promise<InterruptReceipt & {
         commandId: string;
     }>;
@@ -109,8 +115,14 @@ export declare class RoleSessionControlAdapter implements RoleSessionControl {
         text: string;
         actorBrowserSession: string;
         expectedSessionGeneration?: string;
+        requireIdle?: boolean;
         source: 'owner_admin_console';
     }): Promise<PromptReceipt>;
+    interruptPromptV2(request: {
+        commandId: string;
+        expectedSessionGeneration: string;
+        promptId: string;
+    }): Promise<InterruptReceipt>;
     interruptV2(commandId: string): Promise<InterruptReceipt & {
         commandId: string;
     }>;

package/dist/application/session-control.js

@@ -106,6 +106,9 @@ export class RoleSessionControlAdapter {
         // A prompt bound to a session generation (voice or attachments) is checked atomically by supervisors that
         // support it. Older supervisors do not know that command and never answer, so check the generation here
         // and submit an ordinary prompt; its command id keeps retries idempotent either way.
+        const features = request.requireIdle ? (await this.describe()).features : undefined;
+        if (request.requireIdle && (!request.expectedSessionGeneration || !features?.includes('idle_bound_prompts')))
+            throw new FleetError('capability_unavailable', 'Live voice requires an updated supervisor.');
         let command = 'submit_prompt_v2';
         if (request.expectedSessionGeneration) {
             if ((await this.describe()).features.includes('generation_bound_prompts'))
@@ -119,18 +122,33 @@ export class RoleSessionControlAdapter {
         try {
             return await this.call(command, {
                 commandId: request.commandId, text: request.text, actor: request.actorBrowserSession,
-                source: request.source, expectedSessionGeneration: request.expectedSessionGeneration,
+                source: request.source, expectedSessionGeneration: request.expectedSessionGeneration, requireIdle: request.requireIdle,
             });
         }
         catch (error) {
             const fleetError = normalizeError(error);
             if (fleetError.message.includes('session_changed:'))
                 throw new FleetError('stale_state', 'Agent session changed. Record a new voice message.');
+            if (fleetError.message.includes('voice_busy:'))
+                throw new FleetError('conflict', 'Agent is already working. Wait for the current turn.');
             if (fleetError.message.includes('idempotency_conflict'))
                 throw new FleetError('idempotency_conflict', 'this command id was already used with a different prompt body');
             throw fleetError;
         }
     }
+    async interruptPromptV2(request) {
+        if (!(await this.describe()).features.includes('targeted_voice_interrupt'))
+            throw new FleetError('capability_unavailable', 'Live voice requires an updated supervisor.');
+        try {
+            return await this.call('interrupt_voice_v2', request);
+        }
+        catch (error) {
+            const failure = normalizeError(error);
+            if (failure.message.includes('session_changed:'))
+                throw new FleetError('stale_state', 'Agent session changed.');
+            throw failure;
+        }
+    }
     async interruptV2(commandId) {
         const receipt = await this.call('interrupt_v2', { commandId });
         return {

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.46",
-  "buildId": "a75b12e57308",
-  "commit": "f608ced10209f4b9ecf9dc9b573d8cab46136a68",
+  "version": "1.2.0-nightly.47",
+  "buildId": "bbc0b3f7e8a7",
+  "commit": "5a8f562be01ca289722c0504f70281f2ce6d64e1",
   "dirty": true,
-  "builtAt": "2026-10-04T23:11:11.430Z",
+  "builtAt": "2026-10-05T15:15:27.375Z",
   "capabilities": [
     "managed-cli.setup-v1",
     "workspace.enroll.preserve-profile-v1",

package/dist/session/acp.d.ts

@@ -272,6 +272,8 @@ export declare class AcpSession implements AgentSession {
      * (`queuePrompt({ interrupt: true })`) needs the typed error, because only it
      * still owes an undelivered message a replay.
      */
+    readonly liveVoiceSupported = true;
+    interruptPrompt(generation: string, promptId: string): Promise<InterruptOutcome>;
     interrupt(source?: TurnCancellationSource): Promise<InterruptOutcome>;
     private cancelActive;
     /**

package/dist/session/acp.js

@@ -763,6 +763,8 @@ export class AcpSession {
             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 },
@@ -795,6 +797,14 @@ export class AcpSession {
      * (`queuePrompt({ interrupt: true })`) needs the typed error, because only it
      * still owes an undelivered message a replay.
      */
+    liveVoiceSupported = true;
+    async interruptPrompt(generation, promptId) {
+        if (generation !== this.sessionGeneration)
+            throw new Error('session_changed: Agent session changed.');
+        if (this.activeTurn?.id !== promptId)
+            return { state: 'settled' };
+        return this.interrupt('local-console');
+    }
     async interrupt(source = 'local-console') {
         try {
             await this.cancelActive(source);

package/dist/session/arbiter.d.ts

@@ -75,6 +75,8 @@ export declare class RoleTurnArbiter implements AgentSession {
     conversationSnapshot(): ConversationSnapshot;
     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

@@ -177,6 +177,14 @@ export class RoleTurnArbiter {
         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

@@ -69,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';

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

@@ -227,6 +227,14 @@ 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)
@@ -376,6 +384,8 @@ export class CodexAppServerSession {
             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 },

package/dist/session/control.d.ts

@@ -11,11 +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' | 'submit_voice_prompt' | 'interrupt_v2' | 'layout_control' | 'agent_contacts' | 'agent_history' | '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;

package/dist/session/control.js

@@ -9,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', 'submit_voice_prompt', '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. */
@@ -243,6 +243,7 @@ export class RoleControlServer {
                                 ...(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'] : []),
@@ -466,7 +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,
+                            expectedSessionGeneration: request.expectedSessionGeneration, requireIdle: request.requireIdle === true,
                         });
                         this.write(socket, { version: 1, id: request.id, ok: true, result: receipt });
                     }
@@ -477,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())

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

@@ -264,6 +264,8 @@ export interface ConversationEventV1 {
 }
 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/types.d.ts

@@ -319,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/web/server.js

@@ -691,6 +691,11 @@ export async function buildWebServer(services, boundary, options = {}) {
         const detail = await services.query.detail(request.params.id);
         return { ...detail, chatIdle: detail.role.lifetime === 'temporary' ? readChatIdle(agentDir(request.params.id, true)) ?? null : null };
     });
+    app.get('/api/v1/roles/:id/voice-capabilities', async (request) => {
+        auth.authenticate(request);
+        const descriptor = await (await services.session(request.params.id)).describe();
+        return { supported: ['generation_bound_prompts', 'idle_bound_prompts', 'targeted_voice_interrupt'].every(f => descriptor.features.includes(f)) };
+    });
     app.get('/api/v1/roles/:id/removal-preview', async (request) => {
         auth.authenticate(request);
         if (!ROLE_NAME_RE.test(request.params.id))
@@ -781,6 +786,8 @@ export async function buildWebServer(services, boundary, options = {}) {
         const body = request.body;
         if (body?.expectedSessionGeneration !== undefined && (typeof body.expectedSessionGeneration !== 'string' || !body.expectedSessionGeneration.trim()))
             throw new FleetError('invalid_request', 'expectedSessionGeneration must be a nonempty string');
+        if (body?.requireIdle !== undefined && typeof body.requireIdle !== 'boolean')
+            throw new FleetError('invalid_request', 'requireIdle must be boolean');
         let text = String(body?.text ?? '');
         if (body?.attachments !== undefined) {
             if (typeof body.commandId !== 'string' || !body.commandId.trim())
@@ -807,7 +814,7 @@ export async function buildWebServer(services, boundary, options = {}) {
             const admittedCommandId = commandId ?? randomBytes(16).toString('hex');
             const receipt = await control.submitPromptV2({
                 commandId: admittedCommandId, text, source: 'owner_admin_console',
-                expectedSessionGeneration: body.expectedSessionGeneration,
+                expectedSessionGeneration: body.expectedSessionGeneration, requireIdle: body.requireIdle === true,
                 actorBrowserSession: createHmac('sha256', digestKey).update(session.id).digest('hex').slice(0, 24),
             });
             await audit.record({
@@ -819,7 +826,7 @@ export async function buildWebServer(services, boundary, options = {}) {
             reply.code(202);
             return receipt;
         }
-        if (body.expectedSessionGeneration !== undefined)
+        if (body.expectedSessionGeneration !== undefined || body.requireIdle)
             throw new FleetError('capability_unavailable', 'session-bound voice input is unavailable for this role');
         const receipt = await control.sendText(text);
         await audit.record({
@@ -836,6 +843,16 @@ export async function buildWebServer(services, boundary, options = {}) {
         const commandId = typeof body?.commandId === 'string' && body.commandId.trim()
             ? body.commandId : undefined;
         const control = await services.session(request.params.id);
+        if (body?.expectedSessionGeneration !== undefined || body?.promptId !== undefined) {
+            if (!commandId || typeof body.expectedSessionGeneration !== 'string' || !body.expectedSessionGeneration.trim() || typeof body.promptId !== 'string' || !body.promptId.trim())
+                throw new FleetError('invalid_request', 'Targeted interrupt requires commandId, expectedSessionGeneration and promptId');
+            if (!control.interruptPromptV2)
+                throw new FleetError('capability_unavailable', 'Targeted voice interrupt is unavailable');
+            const receipt = await control.interruptPromptV2({ commandId, expectedSessionGeneration: body.expectedSessionGeneration, promptId: body.promptId });
+            await audit.record({ requestId: request.id, browser: session.id, roleId: request.params.id, action: 'session.interrupt_voice', result: 'accepted' });
+            reply.code(202);
+            return receipt;
+        }
         if (commandId && control.interruptV2) {
             const receipt = await control.interruptV2(commandId);
             await audit.record({
@@ -920,6 +937,70 @@ export async function buildWebServer(services, boundary, options = {}) {
             throw new FleetError('role_not_found', 'creation action not found');
         return action;
     });
+    // A fetch stream works through the same authenticated workspace transport as
+    // ordinary requests, and owns one ACP controller until its browser disconnects.
+    app.post('/api/v1/roles/:id/live-presence', async (request, reply) => {
+        const browser = auth.authenticate(request, true);
+        const generation = request.body?.expectedSessionGeneration;
+        if (typeof generation !== 'string' || !generation.trim())
+            throw new FleetError('invalid_request', 'expectedSessionGeneration is required');
+        const control = await services.session(request.params.id);
+        if (!control.followConversation || !control.conversationPage)
+            throw new FleetError('capability_unavailable', 'Live voice requires a conversation controller');
+        const page = await control.conversationPage({ limit: 1 });
+        if (page.snapshot.sessionGeneration !== generation)
+            throw new FleetError('stale_state', 'Agent session changed. Start live voice again.');
+        // Session/page discovery can await I/O; recheck revocation before attaching.
+        auth.authenticate(request, true);
+        if (reply.raw.destroyed)
+            return;
+        reply.hijack();
+        for (const [name, value] of Object.entries(reply.getHeaders()))
+            if (value !== undefined)
+                reply.raw.setHeader(name, Array.isArray(value) ? value : String(value));
+        reply.raw.writeHead(200, { 'Content-Type': 'application/x-ndjson', 'Cache-Control': 'no-store', 'X-Accel-Buffering': 'no' });
+        let ended = false;
+        let follow;
+        let heartbeat;
+        let unbind;
+        const close = () => { if (ended)
+            return; ended = true; unbind?.(); if (heartbeat)
+            clearInterval(heartbeat); follow?.close(); reply.raw.end(); };
+        const write = (value) => { if (!ended && !reply.raw.write(JSON.stringify(value) + '\n'))
+            close(); };
+        reply.raw.once('close', close);
+        unbind = auth.bindTransport(browser.id, close);
+        try {
+            follow = await control.followConversation({
+                after: page.nextCursor,
+                onPage: current => { if (current.snapshot.sessionGeneration !== generation) {
+                    write({ error: 'Agent session changed. Start live voice again.' });
+                    close();
+                }
+                else
+                    write({ ready: true }); },
+                onEvent: event => { if (event.sessionGeneration !== generation) {
+                    write({ error: 'Agent session changed. Start live voice again.' });
+                    close();
+                } },
+                onClose: () => close(),
+            });
+            if (ended)
+                follow.close();
+            else
+                heartbeat = setInterval(() => { try {
+                    auth.authenticate(request);
+                    write({ heartbeat: true });
+                }
+                catch {
+                    close();
+                } }, 10_000);
+        }
+        catch {
+            write({ error: 'Agent controller connection failed.' });
+            close();
+        }
+    });
     app.post('/api/v1/ws-tickets', async (request) => {
         const body = request.body;
         if (!body?.purpose || !['events', 'conversation'].includes(body.purpose))

package/docs/live-voice.md

@@ -0,0 +1,13 @@
+# Live voice managed-session boundary
+
+App Live voice sends transcripts through existing ACP managed sessions and reads the actual agent conversation. Updated ACP and native Codex supervisors advertise `generation_bound_prompts`, `idle_bound_prompts` and `targeted_voice_interrupt`; `/api/v1/roles/:id/voice-capabilities` authenticates the browser and reports whether all are present.
+
+`submit_voice_prompt` accepts `requireIdle: true`. Receipt replay precedes the idle check so retrying a lost acknowledgment does not create a second prompt or fail just because the first is running. New admission checks generation and idle/queue/tool/permission state inside the existing turn arbiter before queuing. Unrelated work is never interrupted to make room.
+
+`interrupt_voice_v2` requires a command ID, expected session generation and exact prompt ID. A matching active prompt uses normal managed-session cancellation; a settled or different prompt is a harmless no-op. A stale generation is rejected. Receipts are idempotent and conflicting reuse of an interrupt command is rejected. The browser's `/interrupt` route selects this path only when the complete target is present, with no legacy unbound fallback.
+
+Authenticated CSRF-protected `POST /api/v1/roles/:id/live-presence` takes `{ expectedSessionGeneration }`, validates the current generation before attaching `followConversation`, and streams NDJSON readiness/heartbeats. The HTTP connection owns one attended controller until disconnect. Close, generation change, auth expiry, slow consumer or attach failure detach it. The browser's ordinary workspace fetch supports this stream without provider credentials in a URL. Existing ACP permission expiry and controller detach grace remain in force.
+
+The daemon/App changes and configuration instructions live in the corresponding `ours-app/docs/live-voice.md` and `ours-sdk` Live voice documentation. The daemon owns the OpenAI key and 60-second Realtime credential minting; Fleet never receives the provider key.
+
+Coverage includes actual ACP/control-socket busy/retry/targeted-cancel tests, native Codex transport tests, authenticated presence-boundary tests and the App native browser/audio integration with separate Codex/Claude ACP protocol fixtures. Provider inference and physical-device acceptance are separate operator checks.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.2.0-nightly.46",
+  "version": "1.2.0-nightly.47",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, managed native/ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",
@@ -19,6 +19,7 @@
     "presets",
     "README.md",
     "docs/task-workspaces.md",
+    "docs/live-voice.md",
     "docs/room-layouts.md",
     "docs/validation/managed-cli-permissions.md",
     "LICENSE"
@@ -41,9 +42,9 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.3.0",
     "@fastify/websocket": "^11.2.0",
-    "@ours.network/cli": "2.8.1-nightly.13",
-    "@ours.network/mcp": "1.2.0-nightly.10",
-    "@ours.network/sdk": "3.8.1-nightly.15",
+    "@ours.network/cli": "2.8.1-nightly.15",
+    "@ours.network/mcp": "1.2.0-nightly.12",
+    "@ours.network/sdk": "3.8.1-nightly.17",
     "commander": "^12.1.0",
     "fastify": "^5.4.0",
     "qrcode": "1.5.4",
@@ -56,7 +57,7 @@
     "@agentclientprotocol/codex-acp": "1.10.0"
   },
   "devDependencies": {
-    "@ours.network/daemon": "3.8.1-nightly.7",
+    "@ours.network/daemon": "3.8.1-nightly.9",
     "@types/node": "^22.20.4",
     "@types/qrcode": "^1.5.6",
     "@types/ws": "^8.18.1",