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

package/README.md

@@ -1856,6 +1856,58 @@ pipe with a 32KiB limit and refuses a terminal. Legacy v1 payloads, which contai
 long-lived scoped credentials, are accepted only through file/stdin, never as
 command arguments. Use only one payload transport.
 
+When this host already has a registration, Fleet inspects the one-use grant without
+consuming it. The same workspace reruns without a deletion prompt or retirement.
+An account-origin change for that workspace requires `--migrate-app-origin`; a
+changed server identity is refused. An older App without inspection support falls
+back to asking before redemption. An unavailable inspection service preserves the
+grant and setup. Fleet verifies the redeemed destination against the inspection.
+
+For another workspace, setup describes the existing workspace, tunnel hostname and
+account origin and asks `[y/N]`. No answer or `no` preserves the setup and grant; a
+noninteractive caller must pass `--replace-registration`, otherwise it exits with
+an error. A legacy binding without a server identity must rerun its own workspace
+first. The original Human root signs retirement. Fleet waits for the account's
+durable cleanup receipt before stopping the old service and revoking its linked
+devices. If a migrated database has no old registration, the signed command confirms
+absence; the service has no old provider resources to delete. Installation identities,
+profile, agents, history, stable host ID and local pairing are preserved.
+
+Replacement recovery is saved in an owned private `workspace/replacement.json`
+after root, host, service and server-contact preconditions pass. The App must
+explicitly support deadline-enforced retirement; an older App without that
+capability preserves the existing setup. `setup-tunnel --resume` retries its nonce
+and saved operation deadline (24 hours less a five-minute clock margin).
+If the enrollment challenge expires, obtain a fresh App command for the same target
+and pass `--replace-registration`; completed retirement is retained. The old server
+identity is pinned: only its own invitation can reconnect it.
+
+`setup-tunnel --abandon-replacement` removes the private recovery payload only when
+a fresh private receipt confirms no deletion and the operation was never dispatched
+or was terminally rejected. A lost transport response remains uncertain. Expired
+operations require a fresh receipt proving the old binding still exists after the
+deadline plus five minutes and an explicit server guarantee that the deadline is enforced;
+older recovery records without that guarantee must be resumed. Abandoning preserves
+the existing binding, connector and installation data. A terminally rejected operation
+requires abandonment and a new App command, rather than reusing its nonce.
+After that deadline, a fresh command for the same target can also resume with a
+new operation nonce after checking the enforced expiry. This confirms signed
+absence if an old successful receipt was lost and later pruned.
+
+If the App accepted the successor proof before Fleet wrote its local binding,
+a fresh command for that target retains the original private connector from the
+recovery record. If that successor cannot be recovered, remove it in the App,
+then use `setup-tunnel --discard-retired-replacement` and a fresh App command.
+Discard is allowed only after retirement and local cleanup, while the old local
+binding remains. It removes only the recovery record. This host has no working
+registration until the new setup completes; the old service was stopped and its
+linked devices revoked.
+
+Renewal commands contain no existing live connector credential. Fleet keeps the
+current private connector byte for byte, and accepts renewal only for its recorded
+workspace, server, origin and tunnel hostname. Restore a missing or unsafe connector,
+or remove and re-create that workspace in the App before setting it up again.
+
 After service and signed tunnel-target confirmation, setup prints both a QR and
 ordinary private single-use connection code. The App checks readiness automatically
 and immediately opens the code field. If setup or code output fails after binding,

package/dist/application/role-removal-service.js

@@ -1,3 +1,4 @@
+import { retireNotificationTarget } from '../notifications/target-cleanup.js';
 import { cpSync, existsSync, mkdirSync, readdirSync, renameSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { loadConfig, ROLE_NAME_RE } from '../config.js';
@@ -87,6 +88,7 @@ export class RoleRemovalService {
             await this.options.ops.backend.uninstall(preview.role);
             if (existsSync(sourceState))
                 renameSync(sourceState, join(recoveryPath, 'orphan-state'));
+            await retireNotificationTarget(`/fleet/chats?chat=${encodeURIComponent(preview.role)}`).catch(() => { });
             this.options.ops.log(`removed orphaned backend/state '${preview.role}'`);
         }
         return { ...preview, removed: true, recoveryPath };

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.45",
-  "buildId": "9af6d0fa4b7e",
-  "commit": "f59c69b6662ae09b5e72ea2c4c0a958729e1928f",
+  "version": "1.2.0-nightly.47",
+  "buildId": "bbc0b3f7e8a7",
+  "commit": "5a8f562be01ca289722c0504f70281f2ce6d64e1",
   "dirty": true,
-  "builtAt": "2026-10-04T12:42:35.826Z",
+  "builtAt": "2026-10-05T15:15:27.375Z",
   "capabilities": [
     "managed-cli.setup-v1",
     "workspace.enroll.preserve-profile-v1",

package/dist/cli.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
+import { beginWorkspaceReplacement, abandonWorkspaceReplacement, discardRetiredWorkspaceReplacement, clearWorkspaceReplacement, confirmWorkspaceReplacement, finishWorkspaceReplacement, readWorkspaceBinding, readWorkspaceReplacement, requiresWorkspaceReplacement, refreshWorkspaceReplacement } from './workspace-replacement.js';
 import { completeTunnelSetup } from './tunnel-setup-completion.js';
-import { readTunnelSetupFile, readTunnelSetupStdin, readTunnelSetupArgument, redeemTunnelSetup } from './tunnel-setup-input.js';
+import { readTunnelSetupFile, readTunnelSetupStdin, readTunnelSetupArgument, redeemTunnelSetup, inspectTunnelSetup, verifyTunnelSetupTarget } from './tunnel-setup-input.js';
 import { ensureMinimalSetup } from './minimal-setup.js';
-import { confirmWorkspaceTarget } from './workspace-enrollment.js';
+import { confirmWorkspaceTarget, checkWorkspaceConnector } from './workspace-enrollment.js';
 import { clearPendingTunnelSetup, readPendingTunnelSetup, requiredPortAfterExpiry, savePendingTunnelSetup, setupTunnelPreflight } from './setup-tunnel-preflight.js';
 import { availableWebPort } from './web/available-port.js';
 import QRCode from 'qrcode';
@@ -1609,9 +1610,23 @@ webCommand.command('uninstall').description('stop and uninstall the owner web se
 });
 async function workspaceEnrollmentCommand(opts, setupTunnel = false, argument) {
     try {
+        if (opts.discardRetiredReplacement) {
+            if (!setupTunnel || argument !== undefined || opts.file || opts.stdin || opts.check || opts.resume || opts.migrateAppOrigin || opts.replaceRegistration || opts.configuration || opts.abandonReplacement)
+                throw Error('--discard-retired-replacement takes no payload or other setup options');
+            discardRetiredWorkspaceReplacement();
+            process.stdout.write('Retired replacement recovery discarded. This host has no working registration: the old service was stopped and linked devices revoked. After removing the failed successor in the App, use a fresh command to complete a new registration. Installation data and the old local binding are preserved.\n');
+            return;
+        }
+        if (opts.abandonReplacement) {
+            if (!setupTunnel || argument !== undefined || opts.file || opts.stdin || opts.check || opts.resume || opts.migrateAppOrigin || opts.replaceRegistration || opts.configuration)
+                throw Error('--abandon-replacement takes no payload or other setup options');
+            await abandonWorkspaceReplacement();
+            process.stdout.write('Unsent or rejected replacement abandoned; existing local setup preserved. Obtain a fresh App command for another setup.\n');
+            return;
+        }
         if (setupTunnel && opts.check && opts.resume)
             throw Error('Use either --check or --resume');
-        if (setupTunnel && (opts.check || opts.resume) && (argument !== undefined || opts.file || opts.stdin || opts.migrateAppOrigin))
+        if (setupTunnel && (opts.check || opts.resume) && (argument !== undefined || opts.file || opts.stdin || opts.migrateAppOrigin || opts.replaceRegistration))
             throw Error('--check and --resume take no payload or migration flag');
         if (setupTunnel && opts.check) {
             await setupTunnelPreflight();
@@ -1621,10 +1636,22 @@ async function workspaceEnrollmentCommand(opts, setupTunnel = false, argument) {
         }
         let pending;
         if (setupTunnel && opts.resume) {
-            pending = readPendingTunnelSetup();
-            if (opts.configuration && resolvePath(opts.configuration) !== pending.configuration)
-                throw Error(`This setup started with configuration ${pending.configuration}; resume it without --configuration`);
-            await setupTunnelPreflight();
+            const replacement = readWorkspaceReplacement();
+            if (replacement) {
+                if (opts.configuration && resolvePath(opts.configuration) !== replacement.configuration)
+                    throw Error('Resume replacement with its original configuration');
+                await setupTunnelPreflight();
+                const result = await finishWorkspaceReplacement(replacement);
+                pending = { appOrigin: replacement.payload.appOrigin, origin: result.origin, hostWorkspaceId: result.hostWorkspaceId, rootCid: result.rootCid, challenge: replacement.payload.challenge, configuration: replacement.configuration };
+                savePendingTunnelSetup(pending);
+                clearWorkspaceReplacement();
+            }
+            else {
+                pending = readPendingTunnelSetup();
+                if (opts.configuration && resolvePath(opts.configuration) !== pending.configuration)
+                    throw Error(`This setup started with configuration ${pending.configuration}; resume it without --configuration`);
+                await setupTunnelPreflight();
+            }
         }
         else {
             if (argument === undefined && !opts.file && !opts.stdin)
@@ -1634,18 +1661,49 @@ async function workspaceEnrollmentCommand(opts, setupTunnel = false, argument) {
             if (opts.stdin && process.stdin.isTTY)
                 throw Error('--stdin requires a pipe; use an owned private --file instead');
             const input = setupTunnel ? (argument !== undefined ? readTunnelSetupArgument(argument) : opts.stdin ? await readTunnelSetupStdin() : readTunnelSetupFile(opts.file)) : undefined;
+            const previous = setupTunnel ? readWorkspaceBinding() : undefined;
+            const replacement = setupTunnel ? readWorkspaceReplacement() : undefined;
+            if (replacement && !opts.replaceRegistration)
+                throw Error('An unfinished replacement exists. Run setup-tunnel --resume, use a fresh command for the same target with --replace-registration, or --abandon-replacement when retirement was never sent or definitively rejected. If retirement and cleanup completed but the successor cannot be recovered, remove the successor in the App and use --discard-retired-replacement');
+            if (replacement && resolvePath(opts.configuration ?? defaultConfigPath()) !== replacement.configuration)
+                throw Error('Replacement requires its original configuration');
+            const target = previous && !replacement ? await inspectTunnelSetup(input) : undefined;
+            const different = previous && !replacement && (!target || requiresWorkspaceReplacement(previous, target, opts.migrateAppOrigin));
+            if (different && !(await confirmWorkspaceReplacement(previous, opts.replaceRegistration))) {
+                if (!process.stdin.isTTY)
+                    throw Error('Replacement confirmation required; existing setup and grant preserved');
+                return;
+            }
             if (setupTunnel) {
                 await setupTunnelPreflight();
                 await checkWorkspaceConfiguration(opts.configuration ?? defaultConfigPath());
             }
-            const payload = setupTunnel ? await redeemTunnelSetup(input) : readWorkspacePayload(opts.file);
+            let payload = setupTunnel ? await redeemTunnelSetup(input) : readWorkspacePayload(opts.file);
+            verifyTunnelSetupTarget(target, payload);
+            const replace = previous && !replacement && requiresWorkspaceReplacement(previous, { workspaceId: payload.challenge.workspaceId, serverCid: payload.serverCid, appOrigin: payload.appOrigin }, opts.migrateAppOrigin);
+            if (replacement) {
+                refreshWorkspaceReplacement(replacement, payload, opts.configuration ?? defaultConfigPath());
+                payload = replacement.payload;
+            }
+            checkWorkspaceConnector(payload);
             if (setupTunnel)
                 await ensureMinimalSetup(opts.configuration ?? defaultConfigPath());
-            const result = await enrollWorkspace(payload, opts.configuration, { migrateAppOrigin: opts.migrateAppOrigin, preserveProfile: setupTunnel || opts.preserveProfile });
+            let result;
+            if (replacement) {
+                result = await finishWorkspaceReplacement(replacement);
+            }
+            else if (replace) {
+                const record = await beginWorkspaceReplacement(previous, payload, opts.configuration ?? defaultConfigPath());
+                result = await finishWorkspaceReplacement(record);
+            }
+            else
+                result = await enrollWorkspace(payload, opts.configuration, { migrateAppOrigin: opts.migrateAppOrigin, preserveProfile: setupTunnel || opts.preserveProfile });
             pending = { appOrigin: payload.appOrigin, origin: result.origin, hostWorkspaceId: result.hostWorkspaceId, rootCid: result.rootCid, challenge: payload.challenge, configuration: resolvePath(opts.configuration ?? defaultConfigPath()) };
-            // The proof is one-time: keep what the remaining steps need so they can be finished without a new command.
-            if (setupTunnel)
+            // Keep both the replacement capability and the proof until the next recovery record is durable.
+            if (setupTunnel) {
                 savePendingTunnelSetup(pending);
+                clearWorkspaceReplacement();
+            }
         }
         try {
             await finishWorkspaceService(pending, opts.resume ? pending.configuration : opts.configuration, setupTunnel);
@@ -1739,7 +1797,10 @@ cOpt(program.command('setup-tunnel').argument('[payload]', 'minimal one-use v2 A
     .option('--file <path>', 'owned private App grant or legacy payload file (chmod 600)')
     .option('--stdin', 'read the private App grant or legacy payload from a pipe')
     .option('--check', 'only verify host prerequisites; changes nothing and needs no payload')
-    .option('--resume', 'finish a setup that stopped after this host was bound; needs no new payload')
+    .option('--resume', 'finish an interrupted replacement or setup; needs no new payload')
+    .option('--discard-retired-replacement', 'forget a failed successor after retirement and local cleanup; remove it in the App first')
+    .option('--abandon-replacement', 'discard an unsent or definitively rejected replacement after checking its private receipt')
+    .option('--replace-registration', 'confirm retirement of the existing account registration when the new one differs')
     .option('--migrate-app-origin', 'explicitly migrate the same workspace to its new account origin after verified signed proof')
     .action(async (payload, opts) => workspaceEnrollmentCommand(opts, true, payload));
 program.command('link-device').description('create a single-use workspace device connection code (expires in five minutes)')

package/dist/notifications/fleet-producer.d.ts

@@ -10,6 +10,7 @@ export declare class FleetNotificationProducer {
     private readonly queues;
     private readonly timer;
     private readonly existing;
+    private cleanup?;
     constructor(roots: string[], stateDir: string, config: ProducerConfig, warn?: (line: string) => void);
     private names;
     poll(): void;

package/dist/notifications/fleet-producer.js

@@ -1,7 +1,42 @@
-import { closeSync, existsSync, lstatSync, openSync, readSync, readdirSync, statSync } from 'node:fs';
+import { roomsDir } from '../rooms-tasks/room-state.js';
+import { drainNotificationTargetCleanup } from './target-cleanup.js';
+import { closeSync, existsSync, lstatSync, openSync, readSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { createHash } from 'node:crypto';
 import { NotificationOutbox } from './outbox.js';
+/** Unlike a UI inventory, unread classification must not treat unreadable records as absence. */
+function taskRoleAssociations() {
+    const dir = roomsDir(), result = new Map();
+    let files;
+    try {
+        files = readdirSync(dir);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return result;
+        throw error;
+    }
+    for (const name of files.filter(name => name.endsWith('.json'))) {
+        const file = join(dir, name), stat = lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1024 * 1024)
+            throw Error('Unreadable room association');
+        const room = JSON.parse(readFileSync(file, 'utf8'));
+        if (!room || typeof room.room_id !== 'string' || !Array.isArray(room.member_seats))
+            throw Error('Invalid room association');
+        if (room.task_id === undefined)
+            continue;
+        if (typeof room.task_id !== 'string' || !/^[A-Za-z0-9_-]{1,120}$/.test(room.task_id))
+            throw Error('Invalid task association');
+        for (const seat of room.member_seats) {
+            if (typeof seat.role_name !== 'string')
+                throw Error('Invalid member association');
+            if (result.has(seat.role_name) && result.get(seat.role_name) !== room.task_id)
+                throw Error('Ambiguous task association');
+            result.set(seat.role_name, room.task_id);
+        }
+    }
+    return result;
+}
 /** Read durable supervisor ledgers without restarting agents or attaching a
  * conversation controller. Each tick reads at most 256 KiB per role, from its
  * checkpoint; it never loads a complete transcript or requests model history. */
@@ -13,6 +48,7 @@ export class FleetNotificationProducer {
     queues = new Map();
     timer;
     existing = new Set();
+    cleanup;
     constructor(roots, stateDir, config, warn = () => { }) {
         this.roots = roots;
         this.stateDir = stateDir;
@@ -34,6 +70,49 @@ export class FleetNotificationProducer {
         }
     }
     poll() {
+        this.cleanup ??= drainNotificationTargetCleanup(this.config, undefined, undefined, { beforeDelete: async (url) => {
+                const name = new URL(url, 'https://ours.invalid').searchParams.get('chat');
+                if (!name || !/^[A-Za-z0-9_-]+$/.test(name))
+                    return false;
+                // A recreated or retained role still has a valid target. Filesystem errors cannot prove removal.
+                for (const root of this.roots) {
+                    try {
+                        lstatSync(join(root, name));
+                        return false;
+                    }
+                    catch (error) {
+                        if (error.code !== 'ENOENT')
+                            throw error;
+                    }
+                }
+                for (const root of this.roots) {
+                    const roleDir = join(root, name), queue = this.queues.get(roleDir);
+                    if (queue) {
+                        await queue.retire();
+                        this.queues.delete(roleDir);
+                    }
+                    else {
+                        const file = join(this.stateDir, createHash('sha256').update(roleDir).digest('hex') + '.json');
+                        if (existsSync(file)) {
+                            const queue = new NotificationOutbox(file, this.config, async () => { throw Error('retired target'); });
+                            try {
+                                await queue.retire();
+                            }
+                            finally {
+                                await queue.close();
+                            }
+                        }
+                    }
+                }
+                return true;
+            } }).catch(() => { }).finally(() => { this.cleanup = undefined; });
+        let taskRoles;
+        try {
+            taskRoles = taskRoleAssociations();
+        }
+        catch {
+            this.warn('Notification task association unavailable; delivering unclassified events');
+        }
         for (const root of this.roots)
             for (const roleId of this.names(root)) {
                 const roleDir = join(root, roleId), dir = join(roleDir, '.conversation');
@@ -108,7 +187,7 @@ export class FleetNotificationProducer {
                         if (['message.chunk', 'message.replace'].includes(event.kind) && event.promptId && event.messageId && current.prompts.includes(prompt))
                             current.messages[prompt] = event.messageId;
                         if (event.kind === 'turn.completed' && event.promptId && current.prompts.includes(prompt)) {
-                            if (!outbox.enqueue(`${roleId}:${event.sessionGeneration}:${event.seq}`, { url: `/fleet/chats?chat=${encodeURIComponent(roleId)}&detail=1#fleet-message-${encodeURIComponent(current.messages[prompt] ?? event.promptId)}` }))
+                            if (!outbox.enqueue(`${roleId}:${event.sessionGeneration}:${event.seq}`, { ...(taskRoles ? { taskId: taskRoles.get(roleId) ?? null } : {}), url: `/fleet/chats?chat=${encodeURIComponent(roleId)}&detail=1#fleet-message-${encodeURIComponent(current.messages[prompt] ?? event.promptId)}` }))
                                 break;
                             current.prompts = current.prompts.filter(p => p !== prompt);
                             delete current.messages[prompt];
@@ -125,5 +204,5 @@ export class FleetNotificationProducer {
             }
     }
     async drain() { await Promise.all([...this.queues.values()].map(q => q.drain())); }
-    async close() { clearInterval(this.timer); await Promise.all([...this.queues.values()].map(q => q.close())); }
+    async close() { clearInterval(this.timer); await this.cleanup; await Promise.all([...this.queues.values()].map(q => q.close())); }
 }

package/dist/notifications/outbox.d.ts

@@ -3,6 +3,7 @@ export interface NotificationInput {
     title: string;
     body: string;
     url: string;
+    taskId?: string | null;
 }
 export interface ProducerConfig {
     /** Service base URL. With a gateway credential it is the server gateway's notifications route. */
@@ -29,6 +30,7 @@ export declare class NotificationOutbox {
     cursor?: number;
     checkpoint?: unknown;
     private running?;
+    private retired;
     private timer;
     constructor(file: string, config: ProducerConfig, project: (value: unknown, id: string) => Promise<NotificationInput>, warn?: (message: string) => void);
     private persist;
@@ -37,6 +39,8 @@ export declare class NotificationOutbox {
     enqueue(id: string, value: unknown, cursor?: number | undefined): boolean;
     drain(): Promise<void>;
     private drainOnce;
+    /** Wait for the current send before clearing queued sends and retiring its target. */
+    retire(): Promise<void>;
     close(): Promise<void>;
 }
 export {};

package/dist/notifications/outbox.js

@@ -66,6 +66,7 @@ export class NotificationOutbox {
     cursor;
     checkpoint;
     running;
+    retired = false;
     timer;
     constructor(file, config, project, warn = () => { }) {
         this.file = file;
@@ -106,6 +107,8 @@ export class NotificationOutbox {
     advance(cursor) { this.persist(this.entries, cursor); }
     saveCheckpoint(checkpoint) { this.persist(this.entries, this.cursor, checkpoint); }
     enqueue(id, value, cursor = this.cursor) {
+        if (this.retired)
+            return false;
         if (this.entries.some(e => e.id === id)) {
             if (cursor !== this.cursor)
                 this.advance(cursor);
@@ -117,10 +120,14 @@ export class NotificationOutbox {
         return true;
     }
     drain() {
+        if (this.retired)
+            return Promise.resolve();
         return this.running ??= this.drainOnce().finally(() => { this.running = undefined; });
     }
     async drainOnce() {
         for (const entry of [...this.entries].slice(0, 32)) {
+            if (this.retired)
+                break;
             try {
                 const value = entry.payload ?? await this.project(entry.value, entry.id);
                 // Freeze the canonical projection before any network attempt. A crash
@@ -145,5 +152,7 @@ export class NotificationOutbox {
             }
         }
     }
+    /** Wait for the current send before clearing queued sends and retiring its target. */
+    async retire() { this.retired = true; clearInterval(this.timer); await this.running; this.persist([]); }
     async close() { clearInterval(this.timer); await this.running; }
 }

package/dist/notifications/target-cleanup.d.ts

@@ -0,0 +1,8 @@
+import { type ProducerConfig } from './outbox.js';
+/** Queue only after the owning lifecycle has established deletion, never on a failed inventory read. */
+export declare function retireNotificationTarget(url: string, config?: ProducerConfig | undefined, dir?: string, request?: typeof fetch): Promise<void>;
+/** Persisted retries also run from the ordinary web notification producer after restart. */
+export declare function drainNotificationTargetCleanup(config: ProducerConfig, dir?: string, request?: typeof fetch, options?: {
+    retain?: boolean;
+    beforeDelete?: (url: string) => Promise<boolean>;
+}): Promise<void>;

package/dist/notifications/target-cleanup.js

@@ -0,0 +1,41 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { replaceFileAtomically } from '../atomic-file.js';
+import { stateRoot } from '../paths.js';
+import { producerConfig } from './outbox.js';
+const cleanupDir = () => join(stateRoot(), 'notifications', 'removed-targets');
+/** Queue only after the owning lifecycle has established deletion, never on a failed inventory read. */
+export async function retireNotificationTarget(url, config = producerConfig(), dir = cleanupDir(), request = fetch) {
+    if (!config)
+        return;
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    replaceFileAtomically(join(dir, createHash('sha256').update(url).digest('hex') + '.json'), JSON.stringify({ url }) + '\n', 0o600);
+    await drainNotificationTargetCleanup(config, dir, request, { retain: true });
+}
+/** Persisted retries also run from the ordinary web notification producer after restart. */
+export async function drainNotificationTargetCleanup(config, dir = cleanupDir(), request = fetch, options = {}) {
+    if (!existsSync(dir))
+        return;
+    for (const file of readdirSync(dir).filter(file => /^[a-f0-9]{64}\.json$/.test(file)).slice(0, 32)) {
+        try {
+            const path = join(dir, file), value = JSON.parse(readFileSync(path, 'utf8'));
+            if (typeof value.url !== 'string' || !value.url.startsWith('/fleet/chats?'))
+                continue;
+            if (options.beforeDelete && !(await options.beforeDelete(value.url))) {
+                rmSync(path, { force: true });
+                continue;
+            }
+            const response = await request(config.origin + '/api/v1/delete-target', { method: 'POST', redirect: 'error', signal: AbortSignal.timeout(10000),
+                headers: { ...(config.gatewayCredential ? { 'X-Ours-Api-Token': config.gatewayCredential, 'X-Ours-Notifications-Producer': config.token } : { Authorization: `Bearer ${config.token}` }), 'Content-Type': 'application/json' }, body: JSON.stringify(value) });
+            await response.body?.cancel();
+            if (!response.ok)
+                break;
+            if (!options.retain)
+                rmSync(path, { force: true });
+        }
+        catch {
+            break; /* No credentials or response bodies are included in logs. */
+        }
+    }
+}

package/dist/ops.js

@@ -1,3 +1,4 @@
+import { retireNotificationTarget } from './notifications/target-cleanup.js';
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, unlinkSync, } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID, createHash } from 'node:crypto';
@@ -257,6 +258,7 @@ export async function rmRole(cfg, name, deps) {
     rmSync(agentDir(name), { recursive: true, force: true });
     if (generatedSource && existsSync(role.sourceFile)) {
         unlinkSync(role.sourceFile);
+        await retireNotificationTarget(`/fleet/chats?chat=${encodeURIComponent(name)}`).catch(() => { });
         deps.log(`removed ${role.sourceFile}`);
     }
     deps.log(`removed '${name}' (its ours identity is left intact)`);

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';