@ours.network/fleet 1.2.0-nightly.54 → 1.2.0-nightly.55

package/dist/runner.js

@@ -1,7 +1,10 @@
+import { readProvenance } from './creation.js';
+import { firstManagedSessionMayStart, managedRecoveryPath, readManagedRecovery, writeManagedRecovery } from './managed-recovery.js';
 import { StartupTelemetry } from './startup-telemetry.js';
 import { managedStartupPrompt, managedTaskPrompt } from './startup-prompt.js';
 import { createLayoutControl } from './rooms-tasks/layout-control.js';
 import { TemporaryChatIdle } from './temp-idle.js';
+import { taskSupervisorMayRun, taskMemberRetirementProof } from './task-supervision.js';
 import { prepareManagedAgent, releaseManagedAgent } from './agent-ours/service.js';
 import { prepareManagedHarness } from './agent-ours/harness.js';
 import { prepareManagedCliLaunch } from './managed-cli.js';
@@ -33,7 +36,7 @@ import { ScheduledLoopManager, } from './loops/manager.js';
 import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from './fleet-proxy.js';
 import { effectivePermissionMode } from './permissions.js';
 import { assertModelPinReachesChild, effectiveRoleModel, repinModelEnv } from './model-env.js';
-import { archiveTempState, markTempSupervisorActive, requestedTempStopReason, } from './temp-lifecycle.js';
+import { archiveTempState, markTempSupervisorActive, requestedTempStopReason, readTempSupervisor, } from './temp-lifecycle.js';
 import { FleetCommandAuditStore } from './fleet-command-audit.js';
 export const SUPERVISOR_RECYCLE_REQUIRED = 'OWNER_CHANNEL_SUPERVISOR_RECYCLE_REQUIRED';
 export class SupervisorRecycleRequiredError extends Error {
@@ -511,14 +514,43 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         deps.log(`[${name}] worklog rotation deferred: concurrent modification detected`);
     else if (rotation.rotated)
         deps.log(`[${name}] worklog rotated: ${rotation.beforeBytes} -> ${rotation.afterBytes} bytes`);
+    const durableTask = Boolean(readTempSupervisor(dir)?.taskOwner);
+    const retainedManaged = durableTask || Boolean(deps.suspendOnStop && adapter.supportsResume);
     const sidFile = join(dir, '.session-id');
+    const backendSidFile = join(dir, role.session === 'codex-app-server' ? '.session-id' : '.acp-session-id');
+    let recovery = retainedManaged ? readManagedRecovery(dir) : undefined;
+    // Native Codex shares .session-id with the runner's pre-launch UUID, so file
+    // existence alone is not evidence that its first backend thread was created.
+    const firstSessionRetry = retainedManaged && existsSync(join(dir, '.booted'))
+        && (!existsSync(backendSidFile) || (role.session === 'codex-app-server' && recovery?.session === 'pending'))
+        && firstManagedSessionMayStart(dir);
+    if (retainedManaged && existsSync(join(dir, '.booted'))
+        && (!existsSync(sidFile) || !existsSync(backendSidFile)) && !firstSessionRetry)
+        throw Error('TASK_CONTEXT_RESUME_UNAVAILABLE');
     if (!existsSync(sidFile))
         writeFileSync(sidFile, randomUUID() + '\n');
     const sessionId = readFileSync(sidFile, 'utf8').trim();
     const bootedFile = join(dir, '.booted');
     const exitFile = join(dir, '.exit-status');
     const booted = existsSync(bootedFile);
-    const mode = booted && adapter.supportsResume ? 'resume' : 'fresh';
+    if (durableTask && !adapter.supportsResume)
+        throw Error('TASK_HARNESS_RESUME_UNSUPPORTED');
+    const mode = booted && adapter.supportsResume && !firstSessionRetry ? 'resume' : 'fresh';
+    const requireResume = retainedManaged && mode === 'resume';
+    if (retainedManaged && !recovery) {
+        // Older admitted sessions have no cursor. Continue once, without replaying
+        // their assignment; fresh sessions record intent before the first attempt.
+        recovery = { version: 1, session: booted ? 'established' : 'pending', readiness: booted,
+            initial: booted ? 'dispatching' : 'pending', active: booted };
+        writeManagedRecovery(dir, recovery);
+    }
+    const recoveryBefore = recovery ? { ...recovery } : undefined;
+    const saveRecovery = (update) => {
+        if (!recovery)
+            return;
+        recovery = { ...recovery, ...update };
+        writeManagedRecovery(dir, recovery);
+    };
     // Stamp EVERY attempt, not just the first. `.booted` used to be written only
     // on the fresh path, so after a restart — including one the supervisor never
     // saw, like an OOM-kill — its mtime still read the original boot and any
@@ -672,11 +704,12 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 managedOurs: managedHarness.ours,
                 role, prep,
                 launch: { ...launch, argv: wrappedArgv, env: managedHarness.env },
-                cwd: runCwd, stateDir: dir, mode, permissions: perms,
+                cwd: runCwd, stateDir: dir, mode, requireResume, permissions: perms,
                 permissionMode: effectivePermissionMode(role), log: deps.log,
             }));
             managedService.setFileDelivery?.(agentSession.sendFileToChat?.bind(agentSession));
             startupTelemetry.mark('harness_ready');
+            saveRecovery({ session: 'established' });
             pid = agentSession.pid;
             arbiter = new RoleTurnArbiter(agentSession);
             sessionHandle = arbiter;
@@ -697,7 +730,25 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                     startMonitorAfterStartup();
                 }
             });
-            unsubscribeRecovery = () => { unsubscribeFailure(); unsubscribeStartup?.(); unsubscribeTelemetry?.(); };
+            const activePrompts = new Set();
+            const unsubscribeContinuity = agentSession.subscribeConversation?.(event => {
+                if (!recovery?.readiness)
+                    return;
+                if (event.kind === 'prompt.started') {
+                    if (event.promptId)
+                        activePrompts.add(event.promptId);
+                    saveRecovery({ active: true });
+                }
+                else if (event.kind === 'turn.completed' && 'outcome' in event.payload) {
+                    if (event.promptId)
+                        activePrompts.delete(event.promptId);
+                    // A shutdown/failed turn needs continuation; a successful terminal turn
+                    // proves it may stay idle. Never store prompt bodies in this cursor.
+                    if (event.payload.outcome === 'completed')
+                        saveRecovery({ active: activePrompts.size > 0 });
+                }
+            });
+            unsubscribeRecovery = () => { unsubscribeFailure(); unsubscribeStartup?.(); unsubscribeTelemetry?.(); unsubscribeContinuity?.(); };
             if (role.owner_channel) {
                 try {
                     ownerBinder = await deps.acquireOwnerBinder(dir, name, role.owner_channel.identity);
@@ -818,8 +869,14 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             // Wait for the first turn's TERMINAL result. An agent that accepts the
             // startup prompt and then refuses it has not started; logging the role as
             // up would hide a role that never completed its readiness turn.
-            startupTelemetry.mark('startup_submitted');
-            const starting = arbiter.submitPrompt(firstPrompt, { origin: { kind: 'startup' } });
+            const retainedResume = retainedManaged && mode === 'resume' && recoveryBefore?.readiness === true;
+            if (!retainedResume)
+                startupTelemetry.mark('startup_submitted');
+            // The backend already verified the saved conversation. Resuming a managed
+            // member admits new wakes/console input without replaying startup or work.
+            const starting = retainedResume
+                ? Promise.resolve({ accepted: false, succeeded: true, outcome: 'completed', detail: 'retained backend resumed; no readiness prompt submitted' })
+                : arbiter.submitPrompt(firstPrompt, { origin: { kind: 'startup' } });
             // 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
@@ -884,20 +941,36 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                     + 'keeping temporary supervisor alive');
             startupRecoveryAllowed = interruptedForWake;
             sessionStartupComplete = started.succeeded || (interruptedForWake && successfulTurnObserved);
-            if (started.succeeded)
+            if (started.succeeded && !retainedResume)
                 startupTelemetry.mark('readiness_turn_completed');
+            if (started.succeeded)
+                saveRecovery({ readiness: true });
             // Readiness is now complete. Configured work (or retained continuity) is
             // admitted as a distinct turn; its terminal result must not block console
             // readiness, mail delivery, or supervisor liveness. Empty fresh agents wait
             // for authenticated console input or the monitor's unread/arrival wake.
-            if (started.succeeded && !deps.shouldStop?.() && (role.mission?.trim() || role.roomMemberStartup?.task?.trim() || role.briefing_file?.trim() || booted)) {
-                const queued = await arbiter.queuePrompt(managedTaskPrompt(dir, mode, booted), {
+            const configuredWork = Boolean(role.mission?.trim() || role.roomMemberStartup?.task?.trim() || role.briefing_file?.trim());
+            const initialPending = retainedManaged && recoveryBefore?.initial === 'pending';
+            const interruptedWork = retainedManaged && (recoveryBefore?.active || recoveryBefore?.initial === 'dispatching');
+            const workPrompt = retainedManaged
+                ? initialPending && configuredWork ? managedTaskPrompt(dir, 'fresh', false)
+                    : interruptedWork ? 'Fleet supervisor restarted. Continue pending work in the restored conversation; do not redo completed steps. '
+                        + (recoveryBefore?.initial === 'dispatching' ? `If you have not yet received your assignment, read ${join(dir, 'briefing.md')} once before acting. ` : '')
+                        + 'Read the continuation log only as needed to recover your next action. If no work remains, end this turn and wait for a concrete task or supervisor wake.' : undefined
+                : configuredWork || booted ? managedTaskPrompt(dir, mode, booted) : undefined;
+            if (started.succeeded && !deps.shouldStop?.() && workPrompt) {
+                saveRecovery({ initial: 'dispatching', active: true });
+                const queued = await arbiter.queuePrompt(workPrompt, {
                     origin: { kind: 'startup' },
                 });
                 void queued.completion.then(result => {
+                    if (result.succeeded)
+                        saveRecovery({ initial: 'completed', active: activePrompts.size > 0 });
                     deps.log(`[${name}] configured task turn ${result.outcome}`);
                 }, () => deps.log(`[${name}] configured task turn failed`));
             }
+            else if (started.succeeded && initialPending && !configuredWork)
+                saveRecovery({ initial: 'completed' });
             reloadLoopConfig = async () => {
                 const nextRole = findRole(loadConfig(configPath), name);
                 const definitions = nextRole.loops ?? [];
@@ -986,7 +1059,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         });
         let chatIdle;
         try {
-            if (temp && !role.roomMemberStartup)
+            if (temp && !role.roomMemberStartup && !readTempSupervisor(dir)?.taskOwner)
                 chatIdle = new TemporaryChatIdle(dir, deps.now());
         }
         catch {
@@ -1122,11 +1195,12 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         const rotate = (why) => {
             writeFileSync(sidFile, randomUUID() + '\n');
             rmSync(bootedFile, { force: true });
+            rmSync(managedRecoveryPath(dir), { force: true });
             rotated = true;
             deps.log(`[${name}] ${why} -> rotated session-id; next start is FRESH`);
         };
-        if (!temp && deps.shouldStop?.())
-            deps.log(`[${name}] supervisor stop requested -> next start RESUMES context`);
+        if (readTempSupervisor(dir)?.taskOwner || ((!temp || deps.suspendOnStop) && deps.shouldStop?.()))
+            deps.log(`[${name}] supervisor/context retained -> next start RESUMES context`);
         else if (exitRecord.detail.includes(ACP_CANCEL_DEADLINE_EXCEEDED)
             || exitRecord.detail.includes(CODEX_APP_SERVER_CANCEL_DEADLINE_EXCEEDED))
             // This is a deliberate adapter reclamation, not evidence that resume state
@@ -1176,11 +1250,13 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
  */
 export async function runSupervised(name, opts = {}, partialDeps = {}, attempt = runOnce) {
     const deps = { ...defaultDeps(), ...partialDeps };
-    const dir = agentDir(name);
+    const taskMember = opts.temp === true;
+    const dir = agentDir(name, taskMember);
     mkdirSync(dir, { recursive: true });
     let stopping = false;
     const requestStop = () => { stopping = true; };
-    const shouldStop = () => stopping || (partialDeps.shouldStop?.() ?? false);
+    const shouldStop = () => stopping || (partialDeps.shouldStop?.() ?? false)
+        || (taskMember && requestedTempStopReason(dir) === 'operator-stop');
     deps.shouldStop = shouldStop;
     const stamp = () => new Date(deps.now()).toISOString();
     // Record how the PREVIOUS supervisor process ended before doing anything
@@ -1208,10 +1284,12 @@ export async function runSupervised(name, opts = {}, partialDeps = {}, attempt =
     process.on('SIGINT', requestStop);
     try {
         while (!shouldStop()) {
+            if (taskMember && !taskSupervisorMayRun(name))
+                break;
             let ledger = readRestartLedger(dir);
             try {
                 const configPath = resolveConfigPath(dir, opts.configPath);
-                const role = findRole(loadConfig(configPath), name);
+                const role = taskMember ? loadTempRole(name) : findRole(loadConfig(configPath), name);
                 reconcileModelRecovery(dir, role, stamp());
                 if (modelRecoveryHeld(dir)) {
                     await deps.sleep(HELD_DOWN_POLL_MS);
@@ -1227,18 +1305,26 @@ export async function runSupervised(name, opts = {}, partialDeps = {}, attempt =
                 await deps.sleep(HELD_DOWN_POLL_MS);
                 continue;
             }
+            if (attempt === runOnce && taskMember) {
+                // Boot-time daemon unavailability must not consume the harness crash budget.
+                const { waitForRoleDaemon } = await import('./startup-readiness.js');
+                await waitForRoleDaemon(name, undefined, {}, true);
+            }
+            if (taskMember && (shouldStop() || !taskSupervisorMayRun(name)))
+                break;
             let result;
             try {
                 // Service-manager boot and automatic retry bypass the operator-facing
                 // up/restart commands. Reconcile again immediately before every real
                 // permanent harness attempt; the operation is idempotent and releases its
                 // provisioning lease before the agent or owner channel binds.
-                if (attempt === runOnce) {
+                if (attempt === runOnce && !taskMember) {
                     const configPath = resolveConfigPath(dir, opts.configPath);
                     const role = findRole(loadConfig(configPath), name);
                     await reconcilePermanentRoleIdentities(role, undefined, deps.log);
                 }
-                result = await attempt(name, { configPath: opts.configPath, allowResumeRotation: !ledger.resumeDiscarded }, deps);
+                result = await attempt(name, { configPath: opts.configPath, ...(taskMember ? { temp: true } : {}),
+                    allowResumeRotation: taskMember ? false : !ledger.resumeDiscarded }, deps);
             }
             catch (e) {
                 if (e instanceof SupervisorRecycleRequiredError) {
@@ -1260,7 +1346,7 @@ export async function runSupervised(name, opts = {}, partialDeps = {}, attempt =
                     mode: 'fresh',
                 };
             }
-            if (stopping)
+            if (stopping || (taskMember && (shouldStop() || result.retirementReason)))
                 break;
             // Re-read: the attempt itself may have taken minutes, and an operator may
             // have reset the ledger meanwhile.
@@ -1278,7 +1364,8 @@ export async function runSupervised(name, opts = {}, partialDeps = {}, attempt =
                 await deps.sleep(HELD_DOWN_POLL_MS);
                 continue;
             }
-            const fastFailSecs = fastFailSecsFor(name, opts.configPath);
+            const fastFailSecs = taskMember ? getAdapter(loadTempRole(name).harness).exitPolicy.fastFailSecs
+                : fastFailSecsFor(name, opts.configPath);
             // The fast-fail boundary starts a recovery episode; it must not also be
             // the boundary that declares recovery successful. Otherwise alternating
             // 19s and 20s deaths erase one another forever. Require the configured
@@ -1315,7 +1402,7 @@ export async function runSupervised(name, opts = {}, partialDeps = {}, attempt =
                 next.nextDelayMs = 0;
                 writeRestartLedger(dir, next);
                 deps.log(`[${name}] HELD DOWN after ${failures} immediate failures at ${next.openedAt} — ` +
-                    `${reason}; the agent will not be restarted until: ours-fleet restart ${name}`);
+                    `${reason}; recover with: ${taskMember ? `ours-fleet task recover-members ${readTempSupervisor(dir).taskOwner.taskId}` : `ours-fleet restart ${name}`}`);
                 continue;
             }
             writeRestartLedger(dir, next);
@@ -1330,7 +1417,7 @@ export async function runSupervised(name, opts = {}, partialDeps = {}, attempt =
         process.off('SIGINT', requestStop);
         // An orderly shutdown clears the marker; an unhandled signal or OOM-kill
         // leaves it so the successor can identify an abrupt termination.
-        if (shouldStop())
+        if (!taskMember && shouldStop())
             await deps.releaseAgentOurs(findRole(loadConfig(opts.configPath), name));
         releaseSupervisorRun(dir);
     }
@@ -1350,8 +1437,58 @@ function fastFailSecsFor(name, configPath) {
     }
 }
 /** Temp-agent entrypoint: run once, journal why it ended, then archive its evidence. */
+/** The parent uses the same adapter-relative sustained-uptime reset boundary. */
+export function stableSupervisorWindow(name, temp, configPath) {
+    try {
+        const role = temp ? loadTempRole(name) : findRole(loadConfig(configPath), name);
+        return getAdapter(role.harness).exitPolicy.fastFailSecs * RESTART_FAIL_THRESHOLD;
+    }
+    catch {
+        return 20 * RESTART_FAIL_THRESHOLD;
+    }
+}
 export async function runTemp(name, deps = {}, attempt = runOnce) {
     const dir = agentDir(name, true);
+    const metadata = readTempSupervisor(dir);
+    // Non-resumable standalone temporaries retain their prior finite lifecycle:
+    // a parent stop retires them rather than promising retained conversation.
+    if (!metadata?.taskOwner && deps.suspendOnStop && !getAdapter(loadTempRole(name).harness).supportsResume)
+        deps = { ...deps, suspendOnStop: false };
+    if (!metadata?.taskOwner) {
+        const role = loadTempRole(name);
+        const provenance = readProvenance(dir);
+        if (role.roomMemberStartup?.task_id
+            || (name.startsWith('layout-') && provenance?.creationActionId?.startsWith('task-')))
+            throw Error('TASK_SUPERVISOR_OWNER_MISSING');
+    }
+    if (metadata?.taskOwner) {
+        // Serialize the entire process lifetime before metadata/session writes.
+        const lease = await acquireOwnerBinderLease(join(dir, '.task-supervisor'), 'task-supervisor', name);
+        let ownershipVerified = false;
+        try {
+            const mayRun = taskSupervisorMayRun(name);
+            ownershipVerified = true;
+            if (!mayRun)
+                return;
+            await markTempSupervisorActive(dir);
+            await runSupervised(name, { temp: true }, deps, attempt);
+        }
+        finally {
+            try {
+                if (ownershipVerified && requestedTempStopReason(dir)) {
+                    // Parent shutdown suspends; an explicit stop retires the exact saved
+                    // owner even when no harness attempt ran (for example held circuits).
+                    await (deps.releaseAgentOurs ?? releaseManagedAgent)(loadTempRole(name), taskMemberRetirementProof(name));
+                    const archived = archiveTempState(name, 'operator-stop', 'retired', 'explicit task member retirement');
+                    deps.log?.(`[${name}] task member retired: operator-stop${archived ? `; evidence archived at ${archived}` : ''}`);
+                }
+            }
+            finally {
+                lease.release();
+            }
+        }
+        return;
+    }
     await markTempSupervisorActive(dir);
     let signal;
     const onTerm = () => { signal = 'SIGTERM'; };
@@ -1378,7 +1515,8 @@ export async function runTemp(name, deps = {}, attempt = runOnce) {
         process.off('SIGTERM', onTerm);
         process.off('SIGINT', onInt);
         // A recycle replaces the supervisor process, not the logical temporary agent.
-        if (!(failure instanceof SupervisorRecycleRequiredError) || signal || deps.shouldStop?.()) {
+        if (!((signal || deps.shouldStop?.()) && deps.suspendOnStop && !requestedTempStopReason(dir))
+            && (!(failure instanceof SupervisorRecycleRequiredError) || signal || deps.shouldStop?.())) {
             const requested = requestedTempStopReason(dir);
             const reason = requested
                 ?? result?.retirementReason

package/dist/session/acp.d.ts

@@ -51,6 +51,7 @@ export interface AcpSessionOptions {
     inheritEnvironment?: boolean;
     stateDir: string;
     mode: 'fresh' | 'resume';
+    requireResume?: boolean;
     permissions: CommonPermissions;
     /** Native permission-mode id to request via session/set_mode; undefined keeps the agent default. */
     modeId?: string;

package/dist/session/acp.js

@@ -467,6 +467,7 @@ export class AcpSession {
             readiness: this.readiness === 'idle' && this.steeringOccupied
                 ? 'running' : this.readiness,
             sessionId: this.sessionId,
+            ...(this.activeTurn?.origin ? { activePromptSource: this.activeTurn.origin.kind } : {}),
             lastError: this.lastError,
             pendingPermissionId: this.pendingPermissions.keys().next().value,
             runtimeModel: this.runtimeModel,
@@ -581,6 +582,10 @@ export class AcpSession {
      * steering response from becoming a tight replay loop.
      */
     async steerOrQueueWake(text, options) {
+        // A tool-boundary wait may outlive its original turn. Recheck the current
+        // typed source at delivery, since an Owner turn can begin during the wait.
+        if (options.origin?.kind === 'fleet-monitor' && this.activeTurn?.origin?.kind === 'owner-admin-console')
+            return this.submitPrompt(text, { ...options, interrupt: false, steer: false });
         if (this.stallRecoveryClaimed)
             return this.submitPrompt(text, { ...options, interrupt: false, steer: false });
         const steered = await this.steerPrompt(text);
@@ -1130,6 +1135,8 @@ export class AcpSession {
         const persisted = this.options.mode === 'resume' && existsSync(this.sessionFile)
             ? readFileSync(this.sessionFile, 'utf8').trim()
             : '';
+        if (this.options.requireResume && (!persisted || !(this.agentCapabilities?.sessionCapabilities?.resume != null || this.agentCapabilities?.loadSession)))
+            throw new Error('TASK_CONTEXT_RESUME_UNAVAILABLE');
         let advertisedConfigOptions;
         let advertisedModes;
         let advertisedModelId;

package/dist/session/arbiter.d.ts

@@ -54,6 +54,11 @@ export declare class RoleTurnArbiter implements AgentSession {
      */
     retireStalledAdmission(): void;
     queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
+    /** Inbox traffic must not cancel or steer an active human console/voice turn.
+     * Queue it once; the monitor commits its cursor after that turn succeeds.
+     * Other origins retain their configured monitor policy.
+     */
+    private monitorAdmissionOptions;
     submitPrompt(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
     /**
      * Do not hold `exclusive` while ACP waits for a tool boundary: permission

package/dist/session/arbiter.js

@@ -90,8 +90,20 @@ export class RoleTurnArbiter {
         retired.retire();
     }
     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)); });
+        return this.exclusive(async () => {
+            if (this.retiring)
+                throw new Error('Chat is closing');
+            return this.track(await this.session.queuePrompt(text, this.monitorAdmissionOptions(options)));
+        });
+    }
+    /** Inbox traffic must not cancel or steer an active human console/voice turn.
+     * Queue it once; the monitor commits its cursor after that turn succeeds.
+     * Other origins retain their configured monitor policy.
+     */
+    monitorAdmissionOptions(options) {
+        return options.origin?.kind === 'fleet-monitor'
+            && this.session.snapshot().activePromptSource === 'owner-admin-console'
+            ? { ...options, interrupt: false, steer: false } : options;
     }
     async submitPrompt(text, options = {}) {
         return (await this.queuePrompt(text, options)).completion;
@@ -103,6 +115,8 @@ export class RoleTurnArbiter {
     submitPromptAfterTool(text, options = {}) {
         if (this.retiring)
             return Promise.reject(new Error('Chat is closing'));
+        if (this.monitorAdmissionOptions(options) !== options)
+            return this.submitPrompt(text, options);
         return this.session.submitPromptAfterTool?.(text, options)
             ?? this.session.submitPrompt(text, { ...options, interrupt: false, steer: false });
     }

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

@@ -11,6 +11,7 @@ export interface CodexAppServerSessionOptions {
     env: Record<string, string>;
     stateDir: string;
     mode: 'fresh' | 'resume';
+    requireResume?: boolean;
     permissions: CommonPermissions;
     permissionMode: NonNullable<SessionSnapshot['permissionMode']>;
     model?: string | null;

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

@@ -173,6 +173,7 @@ export class CodexAppServerSession {
             alive: this.isAlive(),
             readiness: this.readiness,
             sessionId: this.threadId,
+            ...(this.activeTurn?.origin ? { activePromptSource: this.activeTurn.origin.kind } : {}),
             lastError: this.lastError,
             pendingPermissionId: this.pendingPermissions.keys().next().value,
             runtimeModel: this.runtimeModel,
@@ -406,6 +407,8 @@ export class CodexAppServerSession {
         this.transport.notify('initialized');
         const persisted = this.options.mode === 'resume' && existsSync(this.threadFile)
             ? readFileSync(this.threadFile, 'utf8').trim() : '';
+        if (this.options.requireResume && !persisted)
+            throw new Error('TASK_CONTEXT_RESUME_UNAVAILABLE');
         const common = {
             cwd: this.options.cwd,
             approvalPolicy: this.options.approvalPolicy,
@@ -425,6 +428,8 @@ export class CodexAppServerSession {
         this.threadId = string(thread?.id);
         if (!this.threadId)
             throw new Error('Codex app-server did not return a thread id');
+        if (this.options.requireResume && this.threadId !== persisted)
+            throw new Error('TASK_CONTEXT_RESUME_MISMATCH');
         writeFileSync(this.threadFile, this.threadId + '\n', { mode: 0o600 });
         const model = string(response.model) ?? this.options.model ?? undefined;
         if (model)

package/dist/session/types.d.ts

@@ -186,6 +186,8 @@ export interface SessionSnapshot {
     backend: SessionBackendId;
     alive: boolean;
     readiness: SessionReadiness;
+    /** Typed source of the active prompt; excludes prompt bodies and command IDs. */
+    activePromptSource?: PromptOrigin['kind'];
     sessionId?: string;
     lastError?: string;
     pendingPermissionId?: string;

package/dist/spawn.d.ts

@@ -6,7 +6,7 @@ import { type CreationDeps, type CreationProvenance } from './creation.js';
 import './harness/claude-code.js';
 import './harness/codex.js';
 import './harness/hermes.js';
-import { type SupervisorLauncher } from './temp-lifecycle.js';
+import { type SupervisorLauncher, type TaskSupervisorOwner } from './temp-lifecycle.js';
 /**
  * The provenance record written by the most recent spawn in this process, so
  * the CLI can print the same summary it persisted rather than rebuilding it.
@@ -15,6 +15,8 @@ export declare let lastProvenance: CreationProvenance | undefined;
 export interface SpawnOpts {
     name: string;
     temp?: boolean;
+    /** Internal exact task-layout ownership, never a standalone manifest entry. */
+    taskOwner?: TaskSupervisorOwner;
     brain?: AgentSelection;
     role?: AgentSelection;
     /** Trusted canonical definition used by room provisioning; never a second schema. */
@@ -85,3 +87,5 @@ export declare function spawnPermanent(o: SpawnOpts, deps: OpsDeps, creation?: C
 export type { SupervisorLauncher } from './temp-lifecycle.js';
 /** Temp spawn: live state under ~/.ours-fleet/tmp, independent transient supervision. */
 export declare function spawnTemp(o: SpawnOpts, binPath: string, launch?: SupervisorLauncher, creation?: CreationDeps): Promise<string>;
+/** Resume the exact durable task launch; no creation, invite issuance or state rotation. */
+export declare function resumeTaskSupervisor(name: string, binPath: string): Promise<void>;

package/dist/spawn.js

@@ -1,3 +1,4 @@
+import { taskSupervisorMayRun } from './task-supervision.js';
 import { randomUUID } from 'node:crypto';
 import { storeRoomSecret, storeTemporaryLaunch, preparePermanentAssignment } from './agent-ours/service.js';
 import { ensureWorkspace } from './rooms-tasks/workspace.js';
@@ -16,7 +17,8 @@ import { recordGeneratedAgentSource } from './generated-agent-source.js';
 import './harness/claude-code.js';
 import './harness/codex.js';
 import './harness/hermes.js';
-import { archiveTempState, makeTempSupervisorLauncher, prepareTempSupervisor, reclaimStaleTempState, } from './temp-lifecycle.js';
+import { getAdapter } from './harness/registry.js';
+import { archiveTempState, makeTempSupervisorLauncher, prepareTempSupervisor, reclaimStaleTempState, stopTempSupervisor, secureStoppedTempArchive, readTempSupervisor, requestedTempStopReason, } from './temp-lifecycle.js';
 /**
  * The provenance record written by the most recent spawn in this process, so
  * the CLI can print the same summary it persisted rather than rebuilding it.
@@ -322,6 +324,8 @@ export async function spawnTemp(o, binPath, launch = independentSupervisor, crea
     if (o.isolationFile)
         readIsolationFile(o.isolationFile); // fail before reserving
     const prepared = resolvedSpawn(o); // canonical validation before mutation
+    if ((o.taskOwner || o.roomMemberStartup?.task_id) && !getAdapter(prepared.role.harness).supportsResume)
+        throw Error('TASK_HARNESS_RESUME_UNSUPPORTED: task agents require a resumable harness');
     if (o.roomMemberStartup?.workspace) {
         const workspace = o.roomMemberStartup.workspace;
         if (prepared.role.cwd !== workspace.path)
@@ -368,7 +372,14 @@ async function spawnTempInner(o, preparedRole, binPath, launch, tx, onStage) {
     lastProvenance = provenance;
     tx.record({
         stage: `temp state dir ${dir}`,
-        undo: () => {
+        undo: async () => {
+            if (o.taskOwner || role.roomMemberStartup?.task_id) {
+                await stopTempSupervisor(o.name);
+                const supervisor = readTempSupervisor(dir);
+                if (supervisor)
+                    await secureStoppedTempArchive(o.name, supervisor.launchId);
+                return;
+            }
             // A failed launch is still lifecycle evidence: briefing, provenance,
             // metadata and supervisor output explain what happened. Remove it from
             // the live roster by atomic archive, never recursive deletion.
@@ -381,7 +392,14 @@ async function spawnTempInner(o, preparedRole, binPath, launch, tx, onStage) {
     // out; a lone temp spawn still waits zero (time-based gate).
     if (cfg.startStaggerMs > 0)
         writeFileSync(join(dir, START_STAGGER_FILE), String(cfg.startStaggerMs));
-    prepareTempSupervisor(dir, o.name);
+    prepareTempSupervisor(dir, o.name, o.taskOwner ?? (o.roomMemberStartup?.task_id ? {
+        taskId: o.roomMemberStartup.task_id,
+        roomId: o.roomMemberStartup.room_id,
+        roomIdentityCid: o.roomMemberStartup.room_identity_cid,
+        creationActionId: o.creationActionId,
+    } : undefined));
+    if (o.taskOwner || o.roomMemberStartup?.task_id)
+        taskSupervisorMayRun(o.name);
     // Run the supervisor independently. On a service-managed host the temp
     // runner gets its own transient unit/job, so stopping the coordinator's unit
     // cannot kill a live worker in the coordinator's cgroup.
@@ -389,3 +407,14 @@ async function spawnTempInner(o, preparedRole, binPath, launch, tx, onStage) {
     await launch(binPath, ['_run-temp', o.name], dir);
     return dir;
 }
+/** Resume the exact durable task launch; no creation, invite issuance or state rotation. */
+export async function resumeTaskSupervisor(name, binPath) {
+    if (!taskSupervisorMayRun(name))
+        throw Error('TASK_SUPERVISOR_RETIRED');
+    const dir = agentDir(name, true);
+    if (requestedTempStopReason(dir))
+        throw Error('TASK_SUPERVISOR_STOP_REQUESTED');
+    const launcher = readTempSupervisor(dir)?.kind === 'detached'
+        ? makeTempSupervisorLauncher({ spawnDetached, supervisor: 'none' }) : independentSupervisor;
+    await launcher(binPath, ['_run-temp', name], dir);
+}

package/dist/startup-readiness.d.ts

@@ -9,5 +9,5 @@ interface ReadinessDeps {
     env: NodeJS.ProcessEnv;
 }
 /** Read-only preflight: never binds identities, starts a harness or edits its ledger. */
-export declare function waitForRoleDaemon(name: string, configPath?: string, partial?: Partial<ReadinessDeps>): Promise<void>;
+export declare function waitForRoleDaemon(name: string, configPath?: string, partial?: Partial<ReadinessDeps>, temp?: boolean): Promise<void>;
 export {};

package/dist/startup-readiness.js

@@ -1,11 +1,11 @@
 import { agentDir } from './paths.js';
 import { findRole, loadConfig } from './config.js';
-import { resolveConfigPath } from './runner.js';
+import { resolveConfigPath, loadTempRole } from './runner.js';
 import { probeDaemonGeneration } from './daemon-recovery.js';
 export const STARTUP_WAIT_MS = 240_000;
 export const STARTUP_RETRY_MS = 5_000;
 /** Read-only preflight: never binds identities, starts a harness or edits its ledger. */
-export async function waitForRoleDaemon(name, configPath, partial = {}) {
+export async function waitForRoleDaemon(name, configPath, partial = {}, temp = false) {
     const deps = {
         probe: env => probeDaemonGeneration(((url, init) => globalThis.fetch(url, {
             ...init, signal: AbortSignal.timeout(10_000),
@@ -17,7 +17,7 @@ export async function waitForRoleDaemon(name, configPath, partial = {}) {
         ...partial,
     };
     const path = resolveConfigPath(agentDir(name), configPath);
-    const role = findRole(loadConfig(path), name);
+    const role = temp ? loadTempRole(name) : findRole(loadConfig(path), name);
     const env = { ...deps.env, ...role.env };
     const deadline = deps.now() + STARTUP_WAIT_MS;
     let lastReason = '';

package/dist/supervisor/adoption.d.ts

@@ -0,0 +1,8 @@
+import { type Exec } from '../exec.js';
+export declare function adoptConfiguredFleet(binPath: string, exec: Exec, platform: NodeJS.Platform, configPath?: string, selectedRole?: string): Promise<void>;
+/** Boot resumes recorded transfers only. It does not rediscover removed agents
+ * or decide that every configured role should be started. */
+export declare function resumeFleetTransfers(binPath: string, exec?: Exec, platform?: NodeJS.Platform): Promise<void>;
+/** A remove racing the native-retired → registered seam must not be undone by
+ * boot receipt recovery. Serialize with that seam and close its cursor first. */
+export declare function retirePermanentRegistration(name: string, exec: Exec): Promise<boolean>;