@ours.network/fleet 1.2.0-nightly.4 → 1.2.0-nightly.41

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,3 +1,5 @@
+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 { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, realpathSync } from 'node:fs';
@@ -6,12 +8,13 @@ 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 +78,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 +101,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 +434,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 +447,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');
@@ -506,6 +526,11 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     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 +541,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 +565,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
@@ -662,6 +689,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 +697,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) {
@@ -756,6 +791,26 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             // 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);
+            // 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 +823,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?.();
@@ -795,26 +851,6 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 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);
-            }
             reloadLoopConfig = async () => {
                 const nextRole = findRole(loadConfig(configPath), name);
                 const definitions = nextRole.loops ?? [];
@@ -900,6 +936,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 +967,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 +991,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;
@@ -1051,11 +1108,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';
@@ -338,8 +339,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,8 @@ 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.');
         const queued = await this.queuePrompt(command.text, {
             origin: { kind: 'owner-admin-console', commandId: command.commandId },
             actor: { browserSession: command.actorBrowserSession },
@@ -1707,9 +1710,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 +1794,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 +1816,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;

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,8 @@ 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); });
     }
     interrupt(source = 'local-console') {
         return this.exclusive(async () => interruptOutcome(await this.session.interrupt(source)));

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

@@ -1,3 +1,4 @@
+import { type TaskNoticeBinding, type TaskCreatedNotice } from './task-notice.js';
 import type { CommonPermissions } from '../config.js';
 import type { ConversationEventV1, ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
 import type { CodexAppServerTransportFactory } from './codex-app-server-transport.js';
@@ -76,6 +77,8 @@ export declare class CodexAppServerSession implements AgentSession {
     setControllerAttached(attached: boolean): void;
     exitResult(): ExitRecord | null;
     close(): Promise<void>;
+    taskNoticeBinding(): TaskNoticeBinding | undefined;
+    recordTaskCreated(binding: TaskNoticeBinding, notice: TaskCreatedNotice): void;
     conversationPage(request?: {
         after?: string;
         limit?: number;

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

@@ -1,6 +1,8 @@
+import { appendTaskCreated } from './task-notice.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, resolve } from 'node:path';
+import { boundedJson } from './conversation-normalizer.js';
 import { ConversationEventStore } from './conversation-store.js';
 import { SessionEvents } from './events.js';
 import { CodexAppServerTransport } from './codex-app-server-transport.js';
@@ -12,7 +14,6 @@ const INTERRUPT_TERMINATE_GRACE_MS = 5_000;
 const TERMINAL_RECONCILE_QUIET_MS = 2_000;
 const TERMINAL_RECONCILE_REQUEST_TIMEOUT_MS = 5_000;
 const SCHEDULED_REDACTION = '[scheduled-loop content redacted]';
-const COMMENTARY_REDACTION = '[assistant commentary redacted]';
 const OWNER_ADMIN_CONTEXT_KEY = 'ours-fleet://prompt-provenance?source=owner_admin_console';
 const OWNER_CHANNEL_CONTEXT_KEY = 'ours-fleet://prompt-provenance?source=owner_channel';
 const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -228,8 +229,10 @@ export class CodexAppServerSession {
     }
     async interrupt(source = 'local-console') {
         const active = this.activeTurn;
-        if (!active || !this.threadId || !active.nativeTurnId)
+        if (!active || !this.threadId)
             return { state: 'settled' };
+        if (!active.nativeTurnId)
+            throw new SessionControlError('backend', 'The operation is still pending without a native turn ID. Cancellation is not confirmed; inspect or restart the agent if it does not progress.');
         active.cancellationSource ??= source;
         this.events.emit('state', { turnId: active.promptId, status: 'running', origin: active.origin });
         this.conversation.appendSafe({
@@ -335,6 +338,10 @@ export class CodexAppServerSession {
         this.conversation.close();
         await this.transport.close();
     }
+    taskNoticeBinding() {
+        return this.activeTurn && this.threadId ? { sessionGeneration: this.sessionGeneration, acpSessionId: this.threadId, promptId: this.activeTurn.promptId } : undefined;
+    }
+    recordTaskCreated(binding, notice) { appendTaskCreated(this.conversation, binding, notice); }
     conversationPage(request = {}) {
         const floor = Number(this.conversationStartCursor ?? 0);
         const requested = Number(request.after ?? 0);
@@ -367,6 +374,8 @@ export class CodexAppServerSession {
         const existing = this.conversation.receiptFor(command.commandId, bodyDigest);
         if (existing)
             return existing;
+        if (command.expectedSessionGeneration !== undefined && command.expectedSessionGeneration !== this.conversationSnapshot().sessionGeneration)
+            throw new Error('session_changed: Agent session changed. Record a new voice message.');
         const queued = await this.queuePrompt(command.text, {
             origin: { kind: 'owner-admin-console', commandId: command.commandId },
             actor: { browserSession: command.actorBrowserSession },
@@ -415,6 +424,10 @@ export class CodexAppServerSession {
             this.reasoningEffort = { value: effort };
         this.readiness = 'idle';
         this.events.emit('state', { status: 'idle', text: `Codex thread ${this.threadId}` });
+        this.conversation.appendSafe({
+            kind: 'capabilities.updated', sessionGeneration: this.sessionGeneration,
+            payload: { commands: [{ name: 'compact', description: textBlock('Compact session context') }] },
+        });
         this.conversation.appendSafe({
             kind: 'session.state', sessionGeneration: this.sessionGeneration,
             payload: { status: 'idle' },
@@ -486,6 +499,12 @@ export class CodexAppServerSession {
             promptId, turnId: promptId, source: sourceFor(origin).source, payload: {},
         });
         try {
+            if (text.trim() === '/compact') {
+                // The acknowledgement is not completion. Standard turn notifications
+                // settle the same queued prompt and durable browser receipt.
+                await this.transport.request('thread/compact/start', { threadId: this.threadId });
+                return await settled;
+            }
             const response = await this.transport.request('turn/start', {
                 threadId: this.threadId,
                 input: [{ type: 'text', text, text_elements: [] }],
@@ -699,7 +718,7 @@ export class CodexAppServerSession {
             promptId: this.activeTurn?.promptId, turnId: this.activeTurn?.promptId,
             messageId: id, source: 'agent',
             payload: {
-                role: 'assistant', content: textBlock(delta, scheduled ? SCHEDULED_REDACTION : phase === 'commentary' ? COMMENTARY_REDACTION : undefined),
+                role: 'assistant', content: textBlock(delta, scheduled ? SCHEDULED_REDACTION : undefined),
             },
         });
     }
@@ -746,6 +765,10 @@ export class CodexAppServerSession {
                 toolCallId: scheduled ? 'scheduled-loop-tool' : id, snapshot,
                 title: scheduled ? 'scheduled-loop tool' : tool.title, status: tool.status,
                 kind: string(item.type),
+                ...(!scheduled && item.arguments !== undefined ? { rawInput: boundedJson(item.arguments) } : {}),
+                ...(!scheduled && item.type === 'commandExecution' ? { rawInput: boundedJson({ command: item.command, cwd: item.cwd }), ...(item.aggregatedOutput !== undefined ? { rawOutput: boundedJson({ output: item.aggregatedOutput, exitCode: item.exitCode }) } : {}) } : {}),
+                ...(!scheduled && item.type === 'fileChange' && item.changes !== undefined ? { rawOutput: boundedJson(item.changes) } : {}),
+                ...(!scheduled && (item.result !== undefined || item.error !== undefined) ? { rawOutput: boundedJson({ result: item.result, error: item.error }) } : {}),
             },
         });
     }

package/dist/session/control.d.ts

@@ -1,3 +1,5 @@
+import type { LayoutControlRequest } from '../rooms-tasks/layout-control.js';
+import type { SupervisorCorrespondence, AgentHistoryQuery } from '../agent-ours/correspondence.js';
 import { type Socket } from 'node:net';
 import type { AgentSession, ControlFailureKind, SessionEvent, SessionSnapshot } from './types.js';
 import type { OwnerChannelHandle, OwnerChannelManagementRequest } from '../owner-channel/channel.js';
@@ -9,8 +11,11 @@ export interface ControlRequest {
     version: 1 | 2 | 3;
     id: string;
     token: string;
-    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config' | 'conversation_page' | 'conversation_follow' | 'submit_prompt_v2' | 'interrupt_v2' | 'respond_permission_v2' | 'fleet_spawn' | 'fleet_audit_begin' | 'fleet_audit_present' | 'fleet_audit_finish';
+    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config' | 'conversation_page' | 'conversation_follow' | 'submit_prompt_v2' | 'submit_voice_prompt' | 'interrupt_v2' | '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;
     permissionId?: string;
     optionId?: string;
     since?: number;
@@ -112,9 +117,13 @@ export declare class RoleControlServer {
     private readonly sockets;
     /** Interrupt idempotency: same command id returns the first receipt. */
     private readonly interruptCommands;
+    private correspondence?;
+    setCorrespondence(value: SupervisorCorrespondence): void;
     private ownerChannel?;
     private loopManager?;
     private reloadConfig?;
+    private layoutControl?;
+    setLayoutControl(handler: (request: LayoutControlRequest) => Promise<unknown>): void;
     private fleetSpawner?;
     private fleetAuditor?;
     constructor(stateDir: string, session: AgentSession, log: (line: string) => void);