@ours.network/fleet 1.1.0-nightly.5 → 1.1.0-nightly.7

package/dist/rooms-tasks/cli.js

@@ -1,4 +1,5 @@
 import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { loadConfig, ConfigError } from '../config.js';
 import { provisionMembers, getBinPath } from './provision.js';
 import { launchFleetWorker } from './external-worker.js';
@@ -9,6 +10,7 @@ import { createCoworkAdapter, CoworkProtocolError } from './cowork-adapter.js';
 import { markdownCode, markdownProse, renderMarkdownFailure, renderMarkdownList, renderMarkdownResult, roomStatus, taskStatus, } from './markdown.js';
 import { TaskRoomApplicationError, TaskRoomApplicationService } from '../application/task-room-service.js';
 import { TaskListError } from './task-lists.js';
+import { recordFleetAuditFailure, recordFleetAuditPresentation, recordFleetAuditResource, } from '../fleet-command-audit.js';
 class TaskRoomPublicError extends Error {
     code;
     fields;
@@ -89,8 +91,29 @@ function die(e) {
     const msg = e instanceof TaskRoomPublicError
         ? taskRoomPublicFailure(e).legacy : e instanceof Error ? e.message : String(e);
     process.stderr.write(`error: ${msg}\n`);
+    recordFleetAuditFailure(classifyTaskRoomFailure(e));
     process.exit(1);
 }
+function classifyTaskRoomFailure(e) {
+    if (e instanceof TaskRoomApplicationError)
+        e = taskRoomPublicError(e.code, e.fields);
+    if (e instanceof TaskRoomPublicError || e instanceof TaskListError || e instanceof ConfigError)
+        return { class: 'validation', effect: 'not_started' };
+    if (e instanceof TaskStateError) {
+        const known = /^task not found: [A-Za-z0-9_-]{1,128}$/u.test(e.message)
+            || e.message === 'invalid task ID: expected the canonical 17-character lowercase ID'
+            || isKnownTaskStateMessage(e.message);
+        return known ? { class: 'validation', effect: 'not_started' }
+            : { class: 'runtime', effect: 'unknown' };
+    }
+    if (e instanceof RoomStateError) {
+        const known = /^room not found: [A-Za-z0-9_-]{1,128}$/u.test(e.message)
+            || isKnownRoomStateMessage(e.message);
+        return known ? { class: 'validation', effect: 'not_started' }
+            : { class: 'runtime', effect: 'unknown' };
+    }
+    return { class: 'runtime', effect: 'unknown' };
+}
 const TASK_STATE_WORD = '(?:backlog|provisioning|active|review|done|cancelled|failed)';
 const SAFE_ID_WORD = '[A-Za-z0-9_-]{1,128}';
 function isKnownTaskStateMessage(message) {
@@ -127,6 +150,7 @@ function dieTaskRoom(e) {
             action: failure.action,
         });
         process.stderr.write(`${output}\n`);
+        recordFleetAuditFailure({ class: 'validation', effect: 'not_started' });
         process.exit(1);
     }
     if (e instanceof TaskListError) {
@@ -142,6 +166,7 @@ function dieTaskRoom(e) {
                     : 'Use a valid NFC-normalized name of at most 64 Unicode code points.',
         });
         process.stderr.write(`${output}\n`);
+        recordFleetAuditFailure({ class: 'validation', effect: 'not_started' });
         process.exit(1);
     }
     const taskMissing = e instanceof TaskStateError
@@ -167,6 +192,7 @@ function dieTaskRoom(e) {
                     : 'Retry once; if it repeats, run ours-fleet doctor and inspect the role logs.',
     });
     process.stderr.write(`${output}\n`);
+    recordFleetAuditFailure(classifyTaskRoomFailure(e));
     process.exit(1);
 }
 const taskListMarkdown = (tasks, title = 'Tasks') => renderMarkdownList({
@@ -175,23 +201,61 @@ const taskListMarkdown = (tasks, title = 'Tasks') => renderMarkdownList({
         + ` — List ${markdownCode(t.list_name ?? 'default')}`
         + (t.blocked ? ` — 🚧 Blocked: ${markdownProse(t.blocked.reason)}` : '')),
 });
-const taskActionMarkdown = (title, task, fields = []) => renderMarkdownResult({
-    icon: '📋', title,
-    fields: [
-        { label: 'ID', value: task.task_id, kind: 'code' },
-        { label: 'Status', value: taskStatus(task.state), kind: 'markdown' },
-        { label: 'List', value: task.list_name ?? 'default', kind: 'code' },
-        ...fields,
-    ],
-});
-const roomActionMarkdown = (title, room, fields = []) => renderMarkdownResult({
-    icon: '🏠', title,
-    fields: [
-        { label: 'ID', value: room.room_id, kind: 'code' },
-        { label: 'Status', value: roomStatus(room.state), kind: 'markdown' },
-        ...fields,
-    ],
-});
+const taskActionMarkdown = (title, task, fields = []) => {
+    recordFleetAuditResource('task', task.task_id);
+    if (task.room_id)
+        recordFleetAuditResource('room', task.room_id);
+    return renderMarkdownResult({
+        icon: '📋', title,
+        fields: [
+            { label: 'ID', value: task.task_id, kind: 'code' },
+            { label: 'Status', value: taskStatus(task.state), kind: 'markdown' },
+            { label: 'List', value: task.list_name ?? 'default', kind: 'code' },
+            ...fields,
+        ],
+    });
+};
+function safeBrainSummary(definition) {
+    const brain = definition?.brain;
+    if (!brain || typeof brain !== 'object' || Array.isArray(brain))
+        return 'unresolved';
+    const selection = brain;
+    if (typeof selection.ref === 'string')
+        return `ref:${selection.ref}`;
+    if (!Object.hasOwn(selection, 'inline'))
+        return 'unresolved';
+    const fingerprint = createHash('sha256').update(JSON.stringify(selection.inline)).digest('hex').slice(0, 16);
+    return `inline:sha256:${fingerprint}`;
+}
+function auditTask(operation, task, previousState, newState = task.state) {
+    recordFleetAuditResource('task', task.task_id);
+    if (task.room_id)
+        recordFleetAuditResource('room', task.room_id);
+    const room = task.room_id ? getRoomRecord(task.room_id) : undefined;
+    const brains = new Map(room?.member_seats.map(seat => [seat.role_name, safeBrainSummary(seat.launch?.agent_definition)]) ?? []);
+    recordFleetAuditPresentation({ kind: 'task', operation, id: task.task_id, title: task.title,
+        previousState, newState,
+        template: task.template ? `${task.template.name}@${task.template.version}` : undefined,
+        roomId: task.room_id, agents: task.member_roles.map(member => ({ name: member.name,
+            brain: brains.get(member.name) ?? 'unresolved', role: member.cowork_role })) });
+}
+function auditRoom(operation, room, previousState, newState = room.state) {
+    recordFleetAuditResource('room', room.room_id);
+    recordFleetAuditPresentation({ kind: 'room', operation, id: room.room_id, previousState, newState,
+        template: room.template_snapshot ? `${room.template_snapshot.name}@${room.template_snapshot.version}` : undefined,
+        participants: room.member_seats.map(member => ({ name: member.role_name, role: member.cowork_role })) });
+}
+const roomActionMarkdown = (title, room, fields = []) => {
+    recordFleetAuditResource('room', room.room_id);
+    return renderMarkdownResult({
+        icon: '🏠', title,
+        fields: [
+            { label: 'ID', value: room.room_id, kind: 'code' },
+            { label: 'Status', value: roomStatus(room.state), kind: 'markdown' },
+            ...fields,
+        ],
+    });
+};
 const PUBLIC_SETTLE_WAIT_MS = 60_000;
 const PUBLIC_SETTLE_POLL_MS = 100;
 const sleep = (ms) => new Promise(resolve => { setTimeout(resolve, ms); });
@@ -465,6 +529,7 @@ export function registerTaskCommands(parent, cOpt) {
                 idempotencyKey: opts.idempotencyKey, origin: { type: 'cli' },
                 list: opts.list,
             });
+            auditTask('create', record, 'none');
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: record }, null, 2));
                 return;
@@ -651,9 +716,11 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getTask(id).state;
             const t = await taskRoomService(opts.configuration).startTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
+            auditTask('start', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -677,9 +744,11 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((id, opts) => {
         try {
+            const previous = getTask(id).state;
             const t = taskRoomService().blockTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id, reason: opts.reason,
             });
+            auditTask('block', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -697,9 +766,11 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((id, opts) => {
         try {
+            const previous = getTask(id).state;
             const t = taskRoomService().unblockTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
+            auditTask('unblock', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -717,9 +788,11 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((id, opts) => {
         try {
+            const previous = getTask(id).state;
             const t = taskRoomService().reviewTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
+            auditTask('review', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -739,6 +812,7 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getTask(id).state;
             let summary = opts.summary;
             if (opts.summaryFile)
                 summary = readFileSync(opts.summaryFile, 'utf8');
@@ -750,6 +824,7 @@ export function registerTaskCommands(parent, cOpt) {
                 ? await launchTaskSettleWorker(id, opts.configuration)
                 : { task: plan.task, timedOut: false };
             const t = settled.task;
+            auditTask('done', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -777,6 +852,7 @@ export function registerTaskCommands(parent, cOpt) {
         try {
             if (id !== confirmId)
                 throw taskRoomPublicError('task_confirmation_mismatch');
+            const previous = getTask(id).state;
             const plan = await taskRoomService(opts.configuration).cancelTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
@@ -784,6 +860,7 @@ export function registerTaskCommands(parent, cOpt) {
                 ? await launchTaskSettleWorker(id, opts.configuration)
                 : { task: plan.task, timedOut: false };
             const t = settled.task;
+            auditTask('cancel', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -811,9 +888,16 @@ export function registerTaskCommands(parent, cOpt) {
         try {
             if (id !== confirmId)
                 throw taskRoomPublicError('task_confirmation_mismatch');
+            let prior;
+            try {
+                prior = getTask(id);
+            }
+            catch { /* idempotent already-absent delete */ }
             const deleted = taskRoomService().deleteTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
+            if (prior)
+                auditTask('delete', prior, prior.state, 'deleted');
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task_id: id, deleted }, null, 2));
                 return;
@@ -834,6 +918,7 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getTask(id).state;
             const app = taskRoomService(opts.configuration);
             const actor = { kind: 'local_control', surface: 'cli' };
             const begin = await app.beginTaskRecovery({ actor, taskId: id });
@@ -844,6 +929,7 @@ export function registerTaskCommands(parent, cOpt) {
                 })()
                 : begin.result;
             const t = recovered.task;
+            auditTask('recover', t, previous);
             const room = recovered.room;
             const recoveryActions = recovered.issues.map(issue => {
                 if (issue.code === 'terminal_pending')
@@ -951,10 +1037,12 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getTask(id).state;
             const result = await taskRoomService(opts.configuration).ensureTaskWork({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id, template: opts.template,
             });
             const t = result.task;
+            auditTask('work', t, previous);
             if (result.status === 'already_active') {
                 if (opts.json) {
                     console.log(JSON.stringify({ schema_version: 1, task: t, status: 'already_active' }, null, 2));
@@ -993,6 +1081,7 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getTask(id).state;
             let summary = opts.summary;
             if (opts.summaryFile)
                 summary = readFileSync(opts.summaryFile, 'utf8');
@@ -1004,6 +1093,7 @@ export function registerTaskCommands(parent, cOpt) {
                 ? await launchTaskSettleWorker(id, opts.configuration)
                 : { task: plan.task, timedOut: false };
             const t = settled.task;
+            auditTask('finish', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -1043,6 +1133,7 @@ export function registerRoomCommands(parent, cOpt) {
                 actor: { kind: 'local_control', surface: 'cli' }, name: opts.name,
                 template: opts.template, goal: opts.goal, brief: opts.brief, briefFile: opts.briefFile,
             });
+            auditRoom('create', record, 'none');
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room: record }, null, 2));
                 return;
@@ -1127,7 +1218,9 @@ export function registerRoomCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
-            const { room } = await taskRoomService(opts.configuration).getRoomDetail(id);
+            const { room, orchestration } = await taskRoomService(opts.configuration).getRoomDetail(id);
+            if (orchestration)
+                auditRoom('open', orchestration, orchestration.state);
             const url = `http://localhost:4460/room/${id}`;
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room_id: id, url, room_name: room.room_name }, null, 2));
@@ -1154,6 +1247,8 @@ export function registerRoomCommands(parent, cOpt) {
         .action(async (id, opts) => {
         try {
             const { orchestration: r, members } = await taskRoomService(opts.configuration).getRoomMembers(id);
+            if (r)
+                auditRoom('members', r, r.state);
             if (opts.json) {
                 console.log(JSON.stringify({
                     schema_version: 1,
@@ -1187,10 +1282,13 @@ export function registerRoomCommands(parent, cOpt) {
         try {
             if (id !== confirmId)
                 throw taskRoomPublicError('room_confirmation_mismatch');
+            const previous = getRoomRecord(id);
             await taskRoomService(opts.configuration).requestRoomDeletion({
                 actor: { kind: 'local_control', surface: 'cli' }, roomId: id,
             });
             const settled = await launchRoomDeleteWorker(id, opts.configuration);
+            if (previous)
+                auditRoom('delete', previous, previous.state, settled.deleted ? 'deleted' : 'closing');
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room_id: id, deleted: settled.deleted }, null, 2));
                 return;
@@ -1227,11 +1325,14 @@ export function registerRoomCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getRoomRecord(id);
             const recovered = await taskRoomService(opts.configuration).recoverRoom({
                 actor: { kind: 'local_control', surface: 'cli' }, roomId: id,
             });
             if (recovered.kind === 'deletion_worker_required') {
                 const settled = await launchRoomDeleteWorker(id, opts.configuration);
+                if (previous)
+                    auditRoom('recover', previous, previous.state, settled.deleted ? 'deleted' : 'closing');
                 if (opts.json) {
                     console.log(JSON.stringify({
                         schema_version: 1, room: null, orchestration: null,
@@ -1252,6 +1353,8 @@ export function registerRoomCommands(parent, cOpt) {
                 return;
             }
             const { room: cowork, orchestration: r, issues: actions } = recovered;
+            if (r)
+                auditRoom('recover', r, previous?.state ?? 'unresolved', r.state);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room: cowork, orchestration: r ?? null, recovery_actions: actions }, null, 2));
                 return;

package/dist/rooms-tasks/external-worker.d.ts

@@ -1,2 +1,3 @@
+export declare function fleetWorkerEnv(source?: NodeJS.ProcessEnv): Record<string, string>;
 /** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
 export declare function launchFleetWorker(args: string[], operation: string, configPath?: string): Promise<void>;

package/dist/rooms-tasks/external-worker.js

@@ -1,14 +1,23 @@
 import { execFile, spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
-/** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
-export function launchFleetWorker(args, operation, configPath) {
-    const cli = [process.argv[1], ...args, ...(configPath ? ['-c', configPath] : [])];
+import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV } from '../fleet-proxy.js';
+export function fleetWorkerEnv(source = process.env) {
     const inheritedKeys = [
         'HOME', 'PATH', 'XDG_RUNTIME_DIR', 'OURS_FLEET_HOME', 'OURS_CONFIG',
         'OURS_PORT', 'OURS_STATE_DIR', 'OURS_API_TOKEN', 'OURS_COWORK_CONFIG',
     ];
-    const inherited = inheritedKeys
-        .flatMap(key => process.env[key] === undefined ? [] : [`${key}=${process.env[key]}`]);
+    const env = Object.fromEntries(inheritedKeys.flatMap(key => source[key] === undefined ? [] : [[key, source[key]]]));
+    // Explicit defense: trusted settle/recover/delete/close workers are effects
+    // nested inside the outer audited command, never fresh agent attempts.
+    delete env[FLEET_PROXY_STATE_DIR_ENV];
+    delete env[FLEET_PROXY_CALLER_ENV];
+    return env;
+}
+/** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
+export function launchFleetWorker(args, operation, configPath) {
+    const cli = [process.argv[1], ...args, ...(configPath ? ['-c', configPath] : [])];
+    const env = fleetWorkerEnv();
+    const inherited = Object.entries(env).map(([key, value]) => `${key}=${value}`);
     const suffix = randomUUID().slice(0, 8);
     const safeOperation = operation.replace(/[^A-Za-z0-9_.-]/g, '-');
     return new Promise((resolve, reject) => {
@@ -29,10 +38,6 @@ export function launchFleetWorker(args, operation, configPath) {
             ], { timeout: 15_000 }, error => error ? reject(error) : resolve());
             return;
         }
-        const env = Object.fromEntries(inherited.map(value => {
-            const split = value.indexOf('=');
-            return [value.slice(0, split), value.slice(split + 1)];
-        }));
         const child = spawn(process.execPath, cli, { detached: true, stdio: 'ignore', env });
         child.once('error', reject);
         child.once('spawn', () => { child.unref(); resolve(); });

package/dist/runner.d.ts

@@ -1,5 +1,6 @@
 import { type ResolvedRole } from './config.js';
 import { 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';
 import type { AgentSession, ExitRecord, TurnResult } from './session/types.js';
@@ -15,6 +16,7 @@ export interface RunnerDeps {
     log(line: string): void;
     /** HTTP transport for the monitor's daemon long-poll (injectable for tests). */
     fetch: FetchLike;
+    probeGeneration(env: NodeJS.ProcessEnv): Promise<DaemonGenerationProbe>;
     /** Construct the supervisor mail monitor (injectable so tests stub it out). */
     createMonitor(opts: MonitorOpts): MonitorHandle;
     /** Construct trusted owner ingress (injectable for lifecycle tests). */
@@ -23,7 +25,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' | 'setOwnerChannel' | 'setConfigReloader' | 'setLoopManager'>;
+    createControlServer(stateDir: string, session: AgentSession, log: (line: string) => void): Pick<RoleControlServer, 'start' | 'close' | 'setFleetSpawner' | 'setFleetAuditor' | 'setOwnerChannel' | 'setConfigReloader' | 'setLoopManager'>;
     /** Acquire the cross-process owner-channel binder lease before replacing the control socket. */
     acquireOwnerBinder(stateDir: string, role: string, identity: string): Promise<OwnerBinderLease>;
     /** Ask the still-authenticated predecessor to emit the fixed recovery notice. */
@@ -31,6 +33,11 @@ export interface RunnerDeps {
     /** Lets a test (or a shutdown path) end the supervised restart loop. */
     shouldStop?(): boolean;
 }
+export declare const SUPERVISOR_RECYCLE_REQUIRED = "OWNER_CHANNEL_SUPERVISOR_RECYCLE_REQUIRED";
+export declare class SupervisorRecycleRequiredError extends Error {
+    readonly code = "OWNER_CHANNEL_SUPERVISOR_RECYCLE_REQUIRED";
+    constructor();
+}
 /** Environment injected only into the managed harness process. */
 export declare function managedFleetProxyEnv(role: ResolvedRole, stateDir: string): Record<string, string>;
 /**
@@ -176,4 +183,4 @@ export declare function runSupervised(name: string, opts?: {
     allowResumeRotation?: boolean;
 }, d: Partial<RunnerDeps>) => Promise<AttemptResult>): Promise<RestartLedger>;
 /** Temp-agent entrypoint: run once, journal why it ended, then archive its evidence. */
-export declare function runTemp(name: string, deps?: Partial<RunnerDeps>): Promise<void>;
+export declare function runTemp(name: string, deps?: Partial<RunnerDeps>, attempt?: typeof runOnce): Promise<void>;

package/dist/runner.js

@@ -6,6 +6,8 @@ import { agentDir, stateRoot } from './paths.js';
 import { loadConfig, findRole, isolationContextFor, resolveMonitorConfig, 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 { recoverAgentIdentity } from './agent-recovery-gate.js';
 import { realExec } from './exec.js';
 import { resolveIsolation } from './isolation/policy.js';
 import { selectIsolationBackend } from './isolation/registry.js';
@@ -24,6 +26,14 @@ import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from './fleet-prox
 import { effectivePermissionMode } from './permissions.js';
 import { assertModelPinReachesChild, effectiveRoleModel, repinModelEnv } from './model-env.js';
 import { archiveTempState, markTempSupervisorActive, requestedTempStopReason, } from './temp-lifecycle.js';
+export const SUPERVISOR_RECYCLE_REQUIRED = 'OWNER_CHANNEL_SUPERVISOR_RECYCLE_REQUIRED';
+export class SupervisorRecycleRequiredError extends Error {
+    code = SUPERVISOR_RECYCLE_REQUIRED;
+    constructor() {
+        super('owner channel requires a fresh supervisor process after unproven client quiescence');
+        this.name = 'SupervisorRecycleRequiredError';
+    }
+}
 const defaultDeps = () => ({
     exec: realExec,
     cpuDelegated: () => cpuControllerDelegated(),
@@ -38,6 +48,7 @@ const defaultDeps = () => ({
     now: () => Date.now(),
     log: line => process.stderr.write(line + '\n'),
     fetch: (url, init) => globalThis.fetch(url, init),
+    probeGeneration: env => probeDaemonGeneration((url, init) => globalThis.fetch(url, init), env),
     createMonitor: opts => createMonitor(opts),
     createOwnerChannel: opts => new OwnerChannel(opts),
     startAgentSession: (adapter, options) => adapter.start(options),
@@ -532,6 +543,9 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         name, identity: role.identity, agentDir: dir, cfg: role.monitor,
         deps: resolvedMonitorDeps,
     }) : null;
+    const daemonObserver = new DaemonGenerationObserver();
+    const initialDaemon = daemonObserver.observe(await deps.probeGeneration(resolvedMonitorDeps.env));
+    let sessionStartedWithoutDaemonBaseline = initialDaemon.kind !== 'baseline';
     if (monitor)
         await monitor.prime({ resetCursor: resetMonitorCursor });
     rmSync(exitFile, { force: true });
@@ -544,9 +558,9 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     let sessionClosed = false;
     let ownerChannel;
     let ownerBinder;
-    const pendingFleetSpawnNotices = [];
     let loopManager;
     let arbiter;
+    let recoveryController;
     let reloadLoopConfig;
     let loopGeneration = JSON.stringify((role.loops ?? []).map(loop => [
         loop.name, loop.definitionHash, loop.promptHash,
@@ -607,21 +621,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             throw error;
         }
         control.setFleetSpawner(async (requested) => {
-            const event = await executeManagedSpawn(role, configPath, requested, deps.log);
-            if (!role.owner_channel)
-                return event;
-            if (ownerChannel?.notifyFleetSpawn) {
-                try {
-                    await ownerChannel.notifyFleetSpawn(event);
-                }
-                catch (error) {
-                    deps.log(`[${name}] spawned-agent owner notice failed: `
-                        + `${error?.message ?? String(error)}`);
-                }
-            }
-            else
-                pendingFleetSpawnNotices.push(event);
-            return event;
+            return executeManagedSpawn(role, configPath, requested, deps.log);
         });
         resolvedMonitorDeps.delivery = {
             // A wake is only delivered when its turn TERMINATES successfully. A
@@ -743,18 +743,14 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 throw new Error(`[${name}] owner channel failed to start: `
                     + `${error?.message ?? String(error)}`);
             }
-            for (const event of pendingFleetSpawnNotices.splice(0)) {
-                try {
-                    await ownerChannel.notifyFleetSpawn?.(event);
-                }
-                catch (error) {
-                    deps.log(`[${name}] deferred spawned-agent owner notice failed: `
-                        + `${error?.message ?? String(error)}`);
-                }
-            }
         }
-        if (ownerChannel)
+        if (ownerChannel) {
             control.setOwnerChannel(ownerChannel);
+            control.setFleetAuditor({
+                begin: (requestId, argv) => ownerChannel.beginFleetCommandAudit(requestId, argv),
+                finish: input => ownerChannel.finishFleetCommandAudit(input),
+            });
+        }
         reloadLoopConfig = async () => {
             const nextRole = findRole(loadConfig(configPath), name);
             const definitions = nextRole.loops ?? [];
@@ -801,16 +797,49 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     // 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);
+    recoveryController = new RoleRecoveryController({
+        role: name, identity: role.identity, stateDir: dir, now: deps.now, sleep: deps.sleep,
+        log: deps.log,
+        recoverAgent: async () => {
+            const evidence = await recoverAgentIdentity(arbiter, role.identity);
+            return evidence.ok ? { ok: true } : { ok: false, reason: evidence.reason };
+        },
+        recoverOwner: async (epoch) => {
+            if (!ownerChannel?.recover)
+                return { ok: true };
+            try {
+                await ownerChannel.recover(epoch);
+                return { ok: true };
+            }
+            catch (error) {
+                return { ok: false, reason: error instanceof Error
+                        ? `OWNER_${error.name.toUpperCase()}` : 'OWNER_UNKNOWN_ERROR' };
+            }
+        },
+    });
     const start = deps.now();
     let nextLoopReloadAt = deps.now() + 30_000;
     let nextIdentityPollAt = deps.now();
+    let nextDaemonProbeAt = deps.now();
     let lastReloadError = '';
     let identityObserved = false;
     let identityAbsentSince;
     let retirementReason;
+    let supervisorRecycleRequired = false;
     while (sessionHandle.isAlive()) {
         await deps.sleep(temp ? 500 : 2000);
         const now = deps.now();
+        if (now >= nextDaemonProbeAt) {
+            nextDaemonProbeAt = now + 2_000;
+            const observation = daemonObserver.observe(await deps.probeGeneration(resolvedMonitorDeps.env));
+            if (observation.kind === 'lost')
+                recoveryController.noteLoss(observation.reason);
+            if (observation.kind === 'changed' || observation.kind === 'available'
+                || (observation.kind === 'baseline' && sessionStartedWithoutDaemonBaseline)) {
+                sessionStartedWithoutDaemonBaseline = false;
+                void recoveryController.recover(observation.generation).catch(error => deps.log(`[${name}] daemon recovery controller failed: ${error?.name ?? 'Error'}`));
+            }
+        }
         if (temp && deps.shouldStop?.()) {
             retirementReason = requestedTempStopReason(dir) ?? 'supervisor-signal';
             deps.log(`[${name}] temporary supervisor retirement requested (${retirementReason})`);
@@ -861,6 +890,11 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         control?.setLoopManager(undefined);
         await loopManager.stop();
     }
+    // Let already-settled path operations publish their aggregate result before
+    // the shutdown fence invalidates the epoch. This never waits on I/O.
+    await Promise.resolve();
+    await Promise.resolve();
+    recoveryController?.cancel();
     control?.setConfigReloader(undefined);
     // Close the authenticated control route before releasing the binder lease;
     // otherwise the predecessor can unlink the replacement's new socket.
@@ -871,7 +905,12 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     }
     if (ownerChannel)
         await ownerChannel.close();
-    ownerBinder?.release();
+    if (ownerChannel?.binderReleaseSafe?.() === false) {
+        deps.log(`[${name}] owner binder retained because client quiescence was not proven at shutdown`);
+        supervisorRecycleRequired = true;
+    }
+    else
+        ownerBinder?.release();
     if (monitor) {
         monitor.stop();
         await monitorLoop;
@@ -920,6 +959,8 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     }
     else
         deps.log(`[${name}] ${exitRecord.detail} (${elapsed.toFixed(0)}s) -> next start RESUMES context`);
+    if (supervisorRecycleRequired)
+        throw new SupervisorRecycleRequiredError();
     return {
         elapsedSecs: elapsed, exit: exitRecord, rotated, mode, modelRecovery,
         ...(retirementReason ? { retirementReason } : {}),
@@ -996,6 +1037,16 @@ export async function runSupervised(name, opts = {}, partialDeps = {}, attempt =
                 result = await attempt(name, { configPath: opts.configPath, allowResumeRotation: !ledger.resumeDiscarded }, deps);
             }
             catch (e) {
+                if (e instanceof SupervisorRecycleRequiredError) {
+                    writeRestartLedger(dir, {
+                        ...ledger,
+                        lastReason: SUPERVISOR_RECYCLE_REQUIRED,
+                        nextDelayMs: 0,
+                        updatedAt: stamp(),
+                    });
+                    deps.log(`[${name}] supervisor recycle required: ${SUPERVISOR_RECYCLE_REQUIRED}`);
+                    throw e;
+                }
                 // A session that could not even start is an immediate failure like any
                 // other; it must count, or an unstartable role loops forever.
                 result = {
@@ -1089,7 +1140,7 @@ function fastFailSecsFor(name, configPath) {
     }
 }
 /** Temp-agent entrypoint: run once, journal why it ended, then archive its evidence. */
-export async function runTemp(name, deps = {}) {
+export async function runTemp(name, deps = {}, attempt = runOnce) {
     const dir = agentDir(name, true);
     await markTempSupervisorActive(dir);
     let signal;
@@ -1100,7 +1151,7 @@ export async function runTemp(name, deps = {}) {
     let result;
     let failure;
     try {
-        result = await runOnce(name, { temp: true }, {
+        result = await attempt(name, { temp: true }, {
             ...deps,
             shouldStop: () => Boolean(signal) || (deps.shouldStop?.() ?? false),
         });
@@ -1114,6 +1165,7 @@ export async function runTemp(name, deps = {}) {
         const requested = requestedTempStopReason(dir);
         const reason = requested
             ?? result?.retirementReason
+            ?? (failure instanceof SupervisorRecycleRequiredError ? 'supervisor-recycle' : undefined)
             ?? (signal ? 'supervisor-signal' : failure ? 'startup-failure' : 'session-ended');
         // A service-manager stop can make the child connection close before the
         // runner reaches its normal loop. That is still a successful requested