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

package/dist/runner.d.ts

@@ -1,6 +1,6 @@
 import { prepareManagedAgent, releaseManagedAgent } from './agent-ours/service.js';
 import { type ResolvedRole } from './config.js';
-import { type MonitorHandle, type MonitorOpts, type FetchLike } from './monitor.js';
+import { probeIdentityPresence, type MonitorHandle, type MonitorOpts, type FetchLike } from './monitor.js';
 import { type DaemonGenerationProbe } from './daemon-recovery.js';
 import { type Exec } from './exec.js';
 import { RoleControlServer } from './session/control.js';
@@ -20,6 +20,7 @@ export interface RunnerDeps {
     log(line: string): void;
     /** HTTP transport for the monitor's daemon long-poll (injectable for tests). */
     fetch: FetchLike;
+    identityProbeDeps?: Parameters<typeof probeIdentityPresence>[3];
     probeGeneration(env: NodeJS.ProcessEnv): Promise<DaemonGenerationProbe>;
     /** Construct the supervisor mail monitor (injectable so tests stub it out). */
     createMonitor(opts: MonitorOpts): MonitorHandle;
@@ -29,7 +30,7 @@ export interface RunnerDeps {
     /** Neutral construction seam for deterministic runner lifecycle tests. */
     startAgentSession(adapter: AgentSessionAdapter, options: AgentSessionStartOptions): Promise<AgentSession>;
     /** Construct the authenticated role control route (injectable where sockets are unavailable). */
-    createControlServer(stateDir: string, session: AgentSession, log: (line: string) => void): Pick<RoleControlServer, 'start' | 'close' | 'setFleetSpawner' | 'setFleetAuditor' | 'setOwnerChannel' | 'setConfigReloader' | 'setLoopManager'>;
+    createControlServer(stateDir: string, session: AgentSession, log: (line: string) => void): Pick<RoleControlServer, 'start' | 'close' | 'setFleetSpawner' | 'setFleetAuditor' | 'setOwnerChannel' | 'setConfigReloader' | 'setLoopManager'> & Partial<Pick<RoleControlServer, 'setLayoutControl' | 'setCorrespondence'>>;
     /** Construct scheduled-loop execution (injectable for fail-closed startup tests). */
     createLoopManager(...args: ConstructorParameters<typeof ScheduledLoopManager>): ScheduledLoopManagerHandle;
     /** Acquire the cross-process owner-channel binder lease before replacing the control socket. */
@@ -44,6 +45,11 @@ export declare class SupervisorRecycleRequiredError extends Error {
     readonly code = "OWNER_CHANNEL_SUPERVISOR_RECYCLE_REQUIRED";
     constructor();
 }
+export declare function localFleetAuditor(stateDir: string, caller: string, log: (line: string) => void, session: AgentSession): {
+    begin(requestId: string, argv: string[]): Promise<import("./fleet-command-audit.js").FleetAuditAttempt>;
+    finish(input: Parameters<NonNullable<OwnerChannelHandle["finishFleetCommandAudit"]>>[0]): Promise<import("./fleet-command-audit.js").FleetAuditAttempt>;
+    present(): Promise<void>;
+};
 /** Environment injected only into the managed harness process. */
 export declare function managedFleetProxyEnv(role: ResolvedRole, stateDir: string): Record<string, string>;
 /**
@@ -149,6 +155,16 @@ export declare const START_STAGGER_FILE = ".start-stagger-ms";
 export declare function reserveLaunchSlot(root: string, staggerMs: number, deps: Pick<RunnerDeps, 'now' | 'sleep' | 'log'>): Promise<number>;
 /** Read a temp role's config snapshot written by spawnTemp. */
 export declare function loadTempRole(name: string): ResolvedRole;
+/**
+ * Fall back to the config path applyRole() recorded at the last up/restart/spawn
+ * for this role. systemd's shared unit template (`ours-fleet-agent@.service`)
+ * execs `_run <name>` with no -c on every restart, so a role brought up from a
+ * non-default config (`ours-fleet up -c custom.yaml`) would otherwise silently
+ * resolve against the default ~/fleet.yaml on its very first restart and fail
+ * with "no such role". An empty/missing marker means "use the default", same as
+ * no -c was ever given.
+ */
+export declare function resolveConfigPath(dir: string, explicit?: string): string | undefined;
 /** What one child session did, so the supervising loop can decide what follows. */
 export interface AttemptResult {
     elapsedSecs: number;
@@ -158,7 +174,7 @@ export interface AttemptResult {
     mode: 'fresh' | 'resume';
     modelRecovery?: 'advance' | 'hold';
     /** Present only when a temporary-role lifecycle signal ended the session. */
-    retirementReason?: 'identity-closed' | 'operator-stop' | 'supervisor-signal';
+    retirementReason?: 'identity-closed' | 'operator-stop' | 'supervisor-signal' | 'idle-timeout';
 }
 /** Continuous authoritative absence required after an identity was observed. */
 export declare const TEMP_IDENTITY_CLOSE_DEBOUNCE_MS = 5000;

package/dist/runner.js

@@ -1,17 +1,21 @@
+import { createLayoutControl } from './rooms-tasks/layout-control.js';
+import { TemporaryChatIdle } from './temp-idle.js';
 import { prepareManagedAgent, releaseManagedAgent } from './agent-ours/service.js';
 import { prepareManagedHarness } from './agent-ours/harness.js';
+import { prepareManagedCliLaunch } from './managed-cli.js';
 import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, realpathSync } from 'node:fs';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
 import { parse } from 'yaml';
 import { agentDir, stateRoot } from './paths.js';
-import { loadConfig, findRole, isolationContextFor, resolveMonitorConfig, resolvePermissions, } from './config.js';
+import { loadConfig, findRole, isolationContextFor, resolveSnapshotMonitor, resolvePermissions, } from './config.js';
 import { getAdapter } from './harness/registry.js';
 import { createMonitor, probeIdentityPresence, } from './monitor.js';
 import { DaemonGenerationObserver, RoleRecoveryController, probeDaemonGeneration, } from './daemon-recovery.js';
 import { realExec } from './exec.js';
 import { resolveIsolation } from './isolation/policy.js';
+import { pinSubscriptionForLaunch } from './subscriptions/launch.js';
 import { selectIsolationBackend } from './isolation/registry.js';
 import { resourceArgs, cpuControllerDelegated } from './isolation/resources.js';
 import { resolveLaunchRuntime } from './isolation/runtime.js';
@@ -75,12 +79,16 @@ const defaultDeps = () => ({
 });
 const MONITOR_OWNER_FILE = '.monitor-owner';
 const OBSOLETE_OURS_AUTOSTART_ENV = 'OURS_AUTOSTART';
-function localFleetAuditor(stateDir, caller, log) {
+export function localFleetAuditor(stateDir, caller, log, session) {
+    const bindings = new Map();
     const store = new FleetCommandAuditStore(join(stateDir, '.fleet-command-audit.json'));
     return {
         async begin(requestId, argv) {
             let attempt = store.begin(requestId, caller, argv);
             if (attempt.invocation === 'sending') {
+                const binding = session.taskNoticeBinding?.();
+                if (binding)
+                    bindings.set(attempt.correlationId, binding);
                 log(`[${caller}] fleet proxy command ${attempt.correlationId} `
                     + `route=${attempt.classification.route} decision=${attempt.classification.decision}`);
                 attempt = store.invocation(attempt.correlationId, caller, 'delivered');
@@ -94,6 +102,19 @@ function localFleetAuditor(stateDir, caller, log) {
                 ...(input.resourceIds ? { resourceIds: input.resourceIds } : {}),
                 ...(input.presentations ? { presentations: input.presentations } : {}),
             });
+            const binding = bindings.get(attempt.correlationId);
+            if (binding && attempt.outcome?.class === 'success' && attempt.outcome.effect === 'completed') {
+                for (const p of attempt.outcome.presentations ?? [])
+                    if (p.kind === 'task' && p.operation === 'create') {
+                        try {
+                            session.recordTaskCreated?.(binding, { operationId: p.eventId, taskId: p.id, title: p.title ?? p.id, state: p.newState });
+                        }
+                        catch {
+                            log(`[${caller}] task-created conversation notice could not be persisted`);
+                        }
+                    }
+                bindings.delete(attempt.correlationId);
+            }
             if (attempt.outcome?.delivery === 'sending')
                 attempt = store.outcome(attempt.correlationId, caller, 'delivered');
             return attempt;
@@ -414,7 +435,7 @@ export function loadTempRole(name) {
     // Upgrade snapshots written before monitor.mode/interrupt existed. A snapshot
     // with no monitor block keeps the historical native/no-supervisor behavior.
     if (role.monitor)
-        role.monitor = resolveMonitorConfig(undefined, role.monitor);
+        role.monitor = resolveSnapshotMonitor(role.monitor);
     role.__temp = true;
     return role;
 }
@@ -427,7 +448,7 @@ export function loadTempRole(name) {
  * with "no such role". An empty/missing marker means "use the default", same as
  * no -c was ever given.
  */
-function resolveConfigPath(dir, explicit) {
+export function resolveConfigPath(dir, explicit) {
     if (explicit)
         return explicit;
     const marker = join(dir, '.config-path');
@@ -502,10 +523,22 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     writeFileSync(bootedFile, `${new Date(deps.now()).toISOString()} ${mode}\n`);
     const runCwd = role.cwd && existsSync(role.cwd) ? role.cwd : dir;
     role = { ...role, monitor: { ...role.monitor, mode: 'fleet' } };
-    const prep = await adapter.prepareSession(role, { stateDir: dir, runCwd });
+    // Native policy for Fleet commands run from the harness command sandbox. This
+    // is the same step for configured, spawned and task-room agents alike.
+    const prep = prepareManagedCliLaunch(role, {
+        // A temporary agent has no config path threaded through its detached
+        // supervisor; spawn records the one it was created from beside its snapshot.
+        stateDir: dir, runCwd, configPath: configPath ?? resolveConfigPath(dir), temp,
+        prep: await adapter.prepareSession(role, { stateDir: dir, runCwd }), log: deps.log,
+    });
     const sessionBackend = role.session ?? 'acp';
     const sessionLabel = sessionBackend === 'acp' ? 'ACP' : 'Codex app-server';
     let launch = adapter.agentSession.prepareLaunch(role, prep);
+    // Resolve the fleet-wide active subscription profile once, now: a later switch
+    // never changes this session (the operator restarts agents to move them).
+    const subscription = pinSubscriptionForLaunch(role, dir);
+    if (subscription?.pin.home)
+        deps.log(`[${name}] subscription: ${subscription.pin.provider} profile ${subscription.pin.profileId}`);
     // Preserve the role's existing isolation policy.
     let wrappedArgv = launch.argv;
     if (role.isolation) {
@@ -516,6 +549,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         launch = { ...launch, argv: runtime.argv };
         const ctx = {
             ...isolationContextFor(role), stateDir: dir, runCwd,
+            subscriptionHome: subscription?.writablePath,
             runtimeReadPaths: [...runtime.readPaths, ...resolveLaunchRuntime([process.execPath, fileURLToPath(new URL('./agent-ours/bridge.js', import.meta.url))]).readPaths],
         };
         const policy = resolveIsolation(role.isolation, ctx);
@@ -539,8 +573,9 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             wrappedArgv = [...rprefix, ...wrappedArgv];
     }
     const managedService = await deps.prepareAgentOurs(role, dir, opts.identityLifetime ? opts.identityLifetime === 'temporary' : temp);
+    let layoutRetiring = false;
     try {
-        const managedHarness = prepareManagedHarness(role, dir, runCwd, managedService.descriptor, harnessChildEnv(role, launch.env, dir));
+        const managedHarness = prepareManagedHarness(role, dir, runCwd, managedService.descriptor, { ...harnessChildEnv(role, launch.env, dir), ...subscription?.env });
         // Start-stagger: space this launch at least start_stagger_ms after the previous
         // agent launch across the whole host, so a burst of boots (systemd starts every
         // user unit concurrently on boot; `ours-fleet up`/restart-all bulk-start) does not
@@ -599,6 +634,16 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         let unsubscribeRecovery;
         let monitorLoop;
         let sessionStartupComplete = false;
+        let startupRecoveryAllowed = false;
+        let successfulTurnObserved = false;
+        let monitorMayStart = false;
+        let monitorStarted = false;
+        const startMonitorAfterStartup = () => {
+            if (!monitorStarted && monitorMayStart && sessionStartupComplete && !deps.shouldStop?.()) {
+                monitorStarted = true;
+                monitorLoop = monitor?.run(pid);
+            }
+        };
         let sessionClosed = false;
         let ownerChannel;
         let ownerBinder;
@@ -627,13 +672,23 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             pid = agentSession.pid;
             arbiter = new RoleTurnArbiter(agentSession);
             sessionHandle = arbiter;
-            unsubscribeRecovery = agentSession.subscribe(event => {
+            const unsubscribeFailure = agentSession.subscribe(event => {
                 if (event.kind !== 'error' || !event.text || event.origin?.kind === 'stall-watchdog')
                     return;
                 const evidence = classifyFailureText(event.text, sessionBackend, new Date(deps.now()).toISOString());
                 if (evidence)
                     resolvedMonitorDeps.onFailureEvidence?.(evidence);
             });
+            const unsubscribeStartup = agentSession.subscribeConversation?.(event => {
+                if (event.kind !== 'turn.completed' || !('outcome' in event.payload) || event.payload.outcome !== 'completed')
+                    return;
+                successfulTurnObserved = true;
+                if (startupRecoveryAllowed) {
+                    sessionStartupComplete = true;
+                    startMonitorAfterStartup();
+                }
+            });
+            unsubscribeRecovery = () => { unsubscribeFailure(); unsubscribeStartup?.(); };
             if (role.owner_channel) {
                 try {
                     ownerBinder = await deps.acquireOwnerBinder(dir, name, role.owner_channel.identity);
@@ -662,6 +717,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                         harness: role.harness,
                         config: role.owner_channel,
                         session: arbiter,
+                        startupPending: () => !sessionStartupComplete,
                         stateDir: dir,
                         env: role.env,
                         log: deps.log,
@@ -669,11 +725,18 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                         ...(configPath ? { configPath } : {}),
                     });
                 control = deps.createControlServer(dir, arbiter, deps.log);
+                control.setCorrespondence?.({ contacts: () => managedService.runtime.readContacts(), history: query => managedService.runtime.readHistory(query) });
                 control.setFleetAuditor(ownerChannel ? {
                     begin: (requestId, argv) => ownerChannel.beginFleetCommandAudit(requestId, argv),
                     finish: input => ownerChannel.finishFleetCommandAudit(input),
                     present: presentations => ownerChannel.notifyFleetLifecycle(presentations),
-                } : localFleetAuditor(dir, name, deps.log));
+                } : localFleetAuditor(dir, name, deps.log, agentSession));
+                control.setLayoutControl?.(createLayoutControl({
+                    agent: name, temporary: temp, standalone: !role.roomMemberStartup,
+                    runtime: managedService.runtime, session: arbiter,
+                    stopping: () => Boolean(deps.shouldStop?.()),
+                    retire: async () => { layoutRetiring = true; await arbiter.close(); },
+                }));
                 await control.start();
             }
             catch (error) {
@@ -704,10 +767,8 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 // refusal or a cancellation reached the agent and was not acted on, so
                 // the monitor must keep its cursor and try again.
                 submit: async (text, options) => {
-                    // Cancelling the runner-owned startup prompt makes startup look failed
-                    // and closes the session before the wake turn can run. During startup,
-                    // steer into the live turn instead; after it completes, honor the
-                    // configured interrupt policy normally.
+                    // Delivery starts after the protected startup turn succeeds. Honor the
+                    // configured interrupt policy for subsequent turns.
                     const policy = options?.interrupt;
                     const interrupt = policy === true && sessionStartupComplete;
                     const promptOptions = {
@@ -715,8 +776,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                         ...(interrupt ? { interruptSource: 'fleet-monitor' } : {}),
                         origin: { kind: 'fleet-monitor' },
                     };
-                    // Startup is already a protected boundary: as with immediate mode,
-                    // steer rather than waiting on/cancelling the runner-owned first turn.
+                    // after_tool waits for a safe boundary in subsequent active turns.
                     const result = policy === 'after_tool' && sessionStartupComplete
                         ? await arbiter.submitPromptAfterTool(text, promptOptions)
                         : await arbiter.submitPrompt(text, promptOptions);
@@ -752,10 +812,28 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             // startup prompt and then refuses it has not started; logging the role as
             // up would hide a role that never read its briefing.
             const starting = arbiter.submitPrompt(firstPrompt, { origin: { kind: 'startup' } });
-            // Monitoring starts immediately. The delivery adapter above downgrades
-            // interruption to steering until this startup turn reaches a terminal
-            // success, so there is neither a deaf gap nor a boot-cancellation loop.
-            monitorLoop = monitor?.run(pid);
+            // Keep the early cursor baseline; do not deliver wakes into the protected
+            // first turn. Steering can pre-empt startup just like cancellation.
+            // Owner traffic and agent replies must be observed during a long first
+            // turn. Ordinary owner input steers until startup has proved successful.
+            if (ownerChannel) {
+                try {
+                    await ownerChannel.start();
+                    control.setOwnerChannel(ownerChannel);
+                }
+                catch (error) {
+                    monitor?.stop();
+                    if (monitorLoop)
+                        await monitorLoop;
+                    await control.close();
+                    await ownerChannel.close().catch(() => undefined);
+                    ownerBinder?.release();
+                    await agentSession.close();
+                    unsubscribeRecovery?.();
+                    throw new Error(`[${name}] owner channel failed to start: `
+                        + `${error?.message ?? String(error)}`);
+                }
+            }
             const started = await starting;
             // A temporary role's first turn can be the active turn when an ours wake
             // needs immediate attention. A typed console/monitor cancellation ends
@@ -768,6 +846,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             if (!started.succeeded && !interruptedForWake) {
                 monitor?.stop();
                 await control.close();
+                await ownerChannel?.close().catch(() => undefined);
                 ownerBinder?.release();
                 await agentSession.close();
                 unsubscribeRecovery?.();
@@ -794,27 +873,8 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             else if (interruptedForWake)
                 deps.log(`[${name}] ${sessionLabel} startup prompt cancelled by ${started.cancellationSource}; `
                     + 'keeping temporary supervisor alive');
-            sessionStartupComplete = true;
-            if (ownerChannel) {
-                try {
-                    await ownerChannel.start();
-                }
-                catch (error) {
-                    monitor?.stop();
-                    if (monitorLoop)
-                        await monitorLoop;
-                    await ownerChannel.close().catch(() => undefined);
-                    await control.close();
-                    ownerBinder?.release();
-                    await agentSession.close();
-                    unsubscribeRecovery?.();
-                    throw new Error(`[${name}] owner channel failed to start: `
-                        + `${error?.message ?? String(error)}`);
-                }
-            }
-            if (ownerChannel) {
-                control.setOwnerChannel(ownerChannel);
-            }
+            startupRecoveryAllowed = interruptedForWake;
+            sessionStartupComplete = started.succeeded || (interruptedForWake && successfulTurnObserved);
             reloadLoopConfig = async () => {
                 const nextRole = findRole(loadConfig(configPath), name);
                 const definitions = nextRole.loops ?? [];
@@ -871,9 +931,10 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             }
         }
         deps.log(`[${name}] up; pid=${pid} cwd=${runCwd} harness=${role.harness} session=${sessionBackend} mode=${mode}`);
-        // The monitor loop lives exactly as long as the session: it starts once the
-        // pane pid is known and is stopped when that pid dies (task dies with runner).
-        monitorLoop ??= monitor?.run(pid);
+        // Keep arrivals behind the early prime() cursor; never re-prime at startup.
+        // Recoverable cancellation preserves the supervisor, not monitor readiness.
+        monitorMayStart = true;
+        startMonitorAfterStartup();
         recoveryController = new RoleRecoveryController({
             role: name, identity: role.identity, stateDir: dir, now: deps.now, sleep: deps.sleep,
             log: deps.log,
@@ -900,6 +961,14 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 }
             },
         });
+        let chatIdle;
+        try {
+            if (temp && !role.roomMemberStartup)
+                chatIdle = new TemporaryChatIdle(dir, deps.now());
+        }
+        catch {
+            deps.log(`[${name}] automatic idle closure disabled: activity state is unreadable`);
+        }
         const start = deps.now();
         let nextLoopReloadAt = deps.now() + 30_000;
         let nextIdentityPollAt = deps.now();
@@ -923,6 +992,19 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                     void recoveryController.recover(observation.generation).catch(error => deps.log(`[${name}] daemon recovery controller failed: ${error?.name ?? 'Error'}`));
                 }
             }
+            let idleExpired = false;
+            try {
+                idleExpired = chatIdle?.observe(sessionHandle.snapshot(), sessionHandle.conversationSnapshot?.().queueDepth ?? -1, now) ?? false;
+            }
+            catch {
+                chatIdle = undefined;
+                deps.log(`[${name}] automatic idle closure disabled: activity state could not be saved`);
+            }
+            if (idleExpired && await arbiter.retireIfIdle((snapshot, queue) => chatIdle.observe(snapshot, queue, deps.now()))) {
+                retirementReason = 'idle-timeout';
+                sessionClosed = true;
+                break;
+            }
             if (deps.shouldStop?.()) {
                 if (temp) {
                     retirementReason = requestedTempStopReason(dir) ?? 'supervisor-signal';
@@ -934,7 +1016,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             }
             if (temp && now >= nextIdentityPollAt) {
                 nextIdentityPollAt = now + TEMP_IDENTITY_POLL_MS;
-                const presence = await probeIdentityPresence(role.identity, deps.fetch, resolvedMonitorDeps.env);
+                const presence = await probeIdentityPresence(role.identity, deps.fetch, resolvedMonitorDeps.env, deps.identityProbeDeps);
                 if (presence.state === 'present') {
                     identityObserved = true;
                     identityAbsentSince = undefined;
@@ -971,6 +1053,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 }
             }
         }
+        monitorMayStart = false;
         if (loopManager) {
             control?.setLoopManager(undefined);
             await loopManager.stop();
@@ -1051,11 +1134,11 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             throw new SupervisorRecycleRequiredError();
         return {
             elapsedSecs: elapsed, exit: exitRecord, rotated, mode, modelRecovery,
-            ...(retirementReason ? { retirementReason } : {}),
+            ...(layoutRetiring ? { retirementReason: 'operator-stop' } : retirementReason ? { retirementReason } : {}),
         };
     }
     finally {
-        await managedService.close(false);
+        await managedService.close(layoutRetiring);
     }
 }
 /**

package/dist/session/acp.d.ts

@@ -1,3 +1,4 @@
+import { type TaskNoticeBinding, type TaskCreatedNotice } from './task-notice.js';
 import * as acp from '@agentclientprotocol/sdk';
 import type { CommonPermissions } from '../config.js';
 import type { AcpMcpServer } from '../harness/types.js';
@@ -271,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;
     /**
@@ -338,8 +341,13 @@ export declare class AcpSession implements AgentSession {
      * signal. Never infer commentary from text, message order, or unknown meta.
      */
     private codexMessagePhase;
-    /** Normalize every ACP update losslessly into the durable ledger. */
+    /**
+     * Normalize every ACP update losslessly into the durable ledger. The ledger is the conversation the
+     * owner reads, so the agent's commentary between its tools is kept as written, like its final answer.
+     */
     private recordConversationUpdate;
+    taskNoticeBinding(): TaskNoticeBinding | undefined;
+    recordTaskCreated(binding: TaskNoticeBinding, notice: TaskCreatedNotice): void;
     conversationPage(request?: {
         after?: string;
         limit?: number;

package/dist/session/acp.js

@@ -1,3 +1,4 @@
+import { appendTaskCreated } from './task-notice.js';
 import { spawn } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
 import { existsSync, lstatSync, readFileSync, readlinkSync, realpathSync, writeFileSync, } from 'node:fs';
@@ -7,6 +8,7 @@ import * as acp from '@agentclientprotocol/sdk';
 import { normalizeSessionUpdate } from './conversation-normalizer.js';
 import { ConversationEventStore } from './conversation-store.js';
 import { SessionEvents } from './events.js';
+import { recordClaudeRateLimit } from '../subscriptions/observed.js';
 import { DEFAULT_STALL_TIMEOUT_MS, STALL_RECOVERY_PROMPT, StallWatchdog, StallToolHistory, hasStallRecoveryClaim } from './stall-watchdog.js';
 import { ACP_CANCEL_DEADLINE_EXCEEDED, SessionControlError, classifyChildExit, sessionBackendCapabilities, turnResult, } from './types.js';
 const CANCEL_SETTLE_GRACE_MS = 15_000;
@@ -36,7 +38,6 @@ const TERMINAL_TOOL_STATUSES = new Set(['completed', 'failed']);
 /** Consumed only by Fleet's authenticated bundled-Codex app-server proxy. */
 export const CODEX_DISABLE_INHERITED_MCP_ENV = 'OURS_FLEET_CODEX_DISABLE_INHERITED_MCP';
 const SCHEDULED_LOOP_REDACTION = '[scheduled-loop content redacted]';
-const OWNER_COMMENTARY_REDACTION = '[assistant commentary redacted]';
 const MAX_CANONICAL_SYMLINK_DEPTH = 40;
 const scheduledTurn = (turn) => turn?.origin?.kind === 'scheduled-loop';
 /**
@@ -760,6 +761,10 @@ export class AcpSession {
         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 },
@@ -792,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);
@@ -1707,9 +1720,15 @@ export class AcpSession {
         const scheduled = this.activeTurn?.origin?.kind === 'scheduled-loop';
         const messagePhase = update.sessionUpdate === 'agent_message_chunk'
             ? this.codexMessagePhase(update) : undefined;
-        this.recordConversationUpdate(update, scheduled, messagePhase === 'commentary');
+        this.recordConversationUpdate(update, scheduled);
         if (update.sessionUpdate === 'config_option_update')
             this.captureRuntimeMetadata(update.configOptions);
+        if (update.sessionUpdate === 'usage_update') {
+            // Claude subscription rate-limit snapshot (claude-agent-acp forwards the SDK rate_limit_event).
+            const rateLimit = update._meta?.['_claude/rateLimit'];
+            if (rateLimit)
+                recordClaudeRateLimit(this.options.stateDir, rateLimit);
+        }
         switch (update.sessionUpdate) {
             case 'agent_message_chunk': {
                 const phase = messagePhase;
@@ -1785,13 +1804,15 @@ export class AcpSession {
             return undefined;
         return phase === 'commentary' || phase === 'final_answer' ? phase : 'ambiguous';
     }
-    /** Normalize every ACP update losslessly into the durable ledger. */
-    recordConversationUpdate(update, scheduled, commentary = false) {
+    /**
+     * Normalize every ACP update losslessly into the durable ledger. The ledger is the conversation the
+     * owner reads, so the agent's commentary between its tools is kept as written, like its final answer.
+     */
+    recordConversationUpdate(update, scheduled) {
         const normalized = normalizeSessionUpdate(update, scheduled ? {
             redactText: SCHEDULED_LOOP_REDACTION,
             redactToolCallId: 'scheduled-loop-tool',
-        }
-            : commentary ? { redactText: OWNER_COMMENTARY_REDACTION } : {});
+        } : {});
         this.conversation.appendSafe({
             kind: normalized.kind,
             sessionGeneration: this.sessionGeneration,
@@ -1805,6 +1826,10 @@ export class AcpSession {
         });
     }
     // ── conversation ledger access (AgentSession) ─────────────────────────────
+    taskNoticeBinding() {
+        return this.activeTurn && this.sessionId ? { sessionGeneration: this.sessionGeneration, acpSessionId: this.sessionId, promptId: this.activeTurn.id } : undefined;
+    }
+    recordTaskCreated(binding, notice) { appendTaskCreated(this.conversation, binding, notice); }
     conversationPage(request = {}) {
         const floor = Number(this.conversationStartCursor ?? 0);
         const requested = Number(request.after ?? 0);

package/dist/session/arbiter.d.ts

@@ -23,6 +23,7 @@ export declare class RoleTurnArbiter implements AgentSession {
     private tail;
     private unsettled;
     private stopping;
+    private retiring;
     /** Bumped by `retireStalledAdmission`; every claim carries the one it was made under. */
     private generation;
     /** Resolves the instant the CURRENT generation is retired. */
@@ -62,6 +63,8 @@ export declare class RoleTurnArbiter implements AgentSession {
     tryScheduled(text: string, origin: Extract<PromptOrigin, {
         kind: 'scheduled-loop';
     }>, beforeQueue?: () => void | Promise<void>): Promise<ScheduledAttempt>;
+    /** Retire only at the same admission boundary used by all prompt producers. */
+    retireIfIdle(expired: (snapshot: SessionSnapshot, queueDepth: number) => boolean): Promise<boolean>;
     stopScheduledAdmission(): void;
     isAlive(): boolean;
     snapshot(): SessionSnapshot;
@@ -72,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

@@ -29,6 +29,7 @@ export class RoleTurnArbiter {
     tail = Promise.resolve();
     unsettled = 0;
     stopping = false;
+    retiring = false;
     /** Bumped by `retireStalledAdmission`; every claim carries the one it was made under. */
     generation = 0;
     /** Resolves the instant the CURRENT generation is retired. */
@@ -89,7 +90,8 @@ export class RoleTurnArbiter {
         retired.retire();
     }
     queuePrompt(text, options = {}) {
-        return this.exclusive(async () => this.track(await this.session.queuePrompt(text, options)));
+        return this.exclusive(async () => { if (this.retiring)
+            throw new Error('Chat is closing'); return this.track(await this.session.queuePrompt(text, options)); });
     }
     async submitPrompt(text, options = {}) {
         return (await this.queuePrompt(text, options)).completion;
@@ -99,6 +101,8 @@ export class RoleTurnArbiter {
      * answers and explicit interrupts must remain able to pass immediately.
      */
     submitPromptAfterTool(text, options = {}) {
+        if (this.retiring)
+            return Promise.reject(new Error('Chat is closing'));
         return this.session.submitPromptAfterTool?.(text, options)
             ?? this.session.submitPrompt(text, { ...options, interrupt: false, steer: false });
     }
@@ -136,6 +140,19 @@ export class RoleTurnArbiter {
             throw error;
         });
     }
+    /** Retire only at the same admission boundary used by all prompt producers. */
+    retireIfIdle(expired) {
+        return this.exclusive(async () => {
+            const snapshot = this.session.snapshot();
+            const queue = this.session.conversationSnapshot?.().queueDepth ?? -1;
+            if (this.retiring || this.unsettled > 0 || snapshot.readiness !== 'idle' || !expired(snapshot, queue))
+                return false;
+            this.retiring = true;
+            this.stopping = true;
+            await this.session.close();
+            return true;
+        });
+    }
     stopScheduledAdmission() { this.stopping = true; }
     isAlive() { return this.session.isAlive(); }
     snapshot() { return this.session.snapshot(); }
@@ -157,7 +174,16 @@ export class RoleTurnArbiter {
     submitPromptBrowser(command) {
         if (!this.session.submitPromptBrowser)
             return Promise.reject(new Error('browser prompt admission is unavailable'));
-        return this.exclusive(() => this.session.submitPromptBrowser(command));
+        return this.exclusive(() => { if (this.retiring)
+            throw new Error('Chat is closing'); return this.session.submitPromptBrowser(command); });
+    }
+    get liveVoiceSupported() { return this.session.liveVoiceSupported === true; }
+    interruptPrompt(generation, promptId) {
+        return this.exclusive(async () => {
+            if (!this.session.interruptPrompt)
+                throw new Error('targeted voice interrupt is unavailable');
+            return interruptOutcome(await this.session.interruptPrompt(generation, promptId));
+        });
     }
     interrupt(source = 'local-console') {
         return this.exclusive(async () => interruptOutcome(await this.session.interrupt(source)));