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

package/dist/agent-recovery-gate.d.ts

@@ -0,0 +1,17 @@
+import type { ConversationEventV1 } from './session/conversation-types.js';
+import type { AgentSession } from './session/types.js';
+export interface AgentRecoveryEvidence {
+    ok: boolean;
+    reason: 'RECOVERY_TOOLS_VERIFIED' | 'RECOVERY_PROMPT_MISSING' | 'RECOVERY_TURN_INCOMPLETE' | 'RECOVERY_TURN_FAILED' | 'RECOVERY_CHOOSE_MISSING' | 'RECOVERY_CURRENT_MISSING' | 'RECOVERY_GET_MESSAGES_MISSING' | 'RECOVERY_TOOL_ORDER_INVALID';
+    chooseIdentity: boolean;
+    currentIdentity: boolean;
+    getMessages: boolean;
+    turnCompleted: boolean;
+}
+/**
+ * Verify one exact recovery turn from its durable conversation ledger. Tool
+ * arguments/results are inspected only to derive these booleans and are never
+ * returned or persisted by this gate.
+ */
+export declare function evaluateAgentRecovery(events: readonly ConversationEventV1[], promptId: string, identity: string): AgentRecoveryEvidence;
+export declare function recoverAgentIdentity(session: AgentSession, identity: string): Promise<AgentRecoveryEvidence>;

package/dist/agent-recovery-gate.js

@@ -0,0 +1,135 @@
+const TOOL_NAMES = {
+    choose: new Set(['choose_identity', 'ours.choose_identity', 'mcp__ours__choose_identity']),
+    current: new Set(['current_identity', 'ours.current_identity', 'mcp__ours__current_identity']),
+    messages: new Set(['get_messages', 'ours.get_messages', 'mcp__ours__get_messages']),
+};
+function recordFor(records, event) {
+    if (event.kind !== 'tool.upsert' || !event.toolCallId)
+        return undefined;
+    const payload = event.payload;
+    const previous = records.get(event.toolCallId) ?? {};
+    const next = {
+        ...previous,
+        ...(payload.title !== undefined ? { title: payload.title } : {}),
+        ...(payload.status !== undefined ? { status: payload.status } : {}),
+        ...(payload.rawInput !== undefined ? { rawInput: payload.rawInput } : {}),
+        ...(payload.status === 'completed' ? { completedSeq: event.seq } : {}),
+    };
+    records.set(event.toolCallId, next);
+    return next;
+}
+function objectInput(input) {
+    if (!input || input.truncated || input.redacted || !input.json
+        || typeof input.json !== 'object' || Array.isArray(input.json))
+        return undefined;
+    return input.json;
+}
+function safeChoose(record, identity) {
+    if (!record.title || !TOOL_NAMES.choose.has(record.title) || record.status !== 'completed')
+        return false;
+    const input = objectInput(record.rawInput);
+    if (!input)
+        return false;
+    const keys = Object.keys(input).sort();
+    if (keys.some(key => key !== 'force' && key !== 'name'))
+        return false;
+    return input.name === identity && (input.force === undefined || input.force === false);
+}
+function safeNoOrBoundedInput(record, names, allowed) {
+    if (!record.title || !names.has(record.title) || record.status !== 'completed')
+        return false;
+    if (!record.rawInput)
+        return allowed({});
+    const input = objectInput(record.rawInput);
+    return input !== undefined && allowed(input);
+}
+function safeCurrent(record) {
+    return safeNoOrBoundedInput(record, TOOL_NAMES.current, input => Object.keys(input).length === 0);
+}
+function safeMessages(record) {
+    return safeNoOrBoundedInput(record, TOOL_NAMES.messages, input => {
+        const keys = Object.keys(input);
+        if (keys.some(key => key !== 'limit'))
+            return false;
+        return input.limit === undefined
+            || (Number.isSafeInteger(input.limit) && input.limit >= 1 && input.limit <= 200);
+    });
+}
+/**
+ * Verify one exact recovery turn from its durable conversation ledger. Tool
+ * arguments/results are inspected only to derive these booleans and are never
+ * returned or persisted by this gate.
+ */
+export function evaluateAgentRecovery(events, promptId, identity) {
+    const ordered = [...events].sort((a, b) => a.seq - b.seq);
+    const admitted = ordered.find(event => event.kind === 'prompt.admitted' && event.promptId === promptId);
+    const empty = (reason) => ({
+        ok: false, reason, chooseIdentity: false, currentIdentity: false,
+        getMessages: false, turnCompleted: false,
+    });
+    if (!admitted)
+        return empty('RECOVERY_PROMPT_MISSING');
+    const terminal = ordered.find(event => event.seq > admitted.seq
+        && event.kind === 'turn.completed'
+        && event.promptId === promptId
+        && event.sessionGeneration === admitted.sessionGeneration);
+    if (!terminal)
+        return empty('RECOVERY_TURN_INCOMPLETE');
+    const outcome = terminal.payload.outcome;
+    if (outcome !== 'completed')
+        return empty('RECOVERY_TURN_FAILED');
+    const records = new Map();
+    for (const event of ordered) {
+        if (event.seq <= admitted.seq || event.seq >= terminal.seq
+            || event.promptId !== promptId
+            || event.sessionGeneration !== admitted.sessionGeneration)
+            continue;
+        recordFor(records, event);
+    }
+    const values = [...records.values()];
+    const chooses = values.filter(record => safeChoose(record, identity));
+    const currents = values.filter(safeCurrent);
+    const messages = values.filter(safeMessages);
+    const chooseIdentity = chooses.length > 0;
+    const currentIdentity = currents.length > 0;
+    const getMessages = messages.length > 0;
+    const base = { chooseIdentity, currentIdentity, getMessages, turnCompleted: true };
+    if (!chooseIdentity)
+        return { ok: false, reason: 'RECOVERY_CHOOSE_MISSING', ...base };
+    if (!currentIdentity)
+        return { ok: false, reason: 'RECOVERY_CURRENT_MISSING', ...base };
+    if (!getMessages)
+        return { ok: false, reason: 'RECOVERY_GET_MESSAGES_MISSING', ...base };
+    const orderedChain = chooses.some(choose => currents.some(current => messages.some(message => choose.completedSeq !== undefined && current.completedSeq !== undefined
+        && message.completedSeq !== undefined
+        && choose.completedSeq < current.completedSeq
+        && current.completedSeq < message.completedSeq)));
+    if (!orderedChain)
+        return { ok: false, reason: 'RECOVERY_TOOL_ORDER_INVALID', ...base };
+    return { ok: true, reason: 'RECOVERY_TOOLS_VERIFIED', ...base };
+}
+export async function recoverAgentIdentity(session, identity) {
+    if (!session.subscribeConversation)
+        return {
+            ok: false, reason: 'RECOVERY_PROMPT_MISSING', chooseIdentity: false,
+            currentIdentity: false, getMessages: false, turnCompleted: false,
+        };
+    const events = [];
+    const unsubscribe = session.subscribeConversation(event => events.push(event));
+    try {
+        const queued = await session.queuePrompt([
+            '[fleet-recovery] The shared ours daemon restarted.',
+            `Call ours choose_identity with name ${JSON.stringify(identity)} and force false.`,
+            'Then call current_identity, then get_messages. Complete all three in that order.',
+            'Do not create/delete identities, force-bind, interrupt, or restart any service/session.',
+        ].join('\n'), { origin: { kind: 'fleet-monitor' } });
+        await queued.completion;
+        // Conversation publication is synchronous with terminal settlement in the
+        // in-tree ACP store; filtering by exact promptId/sessionGeneration remains
+        // the authority even if unrelated events arrived concurrently.
+        return evaluateAgentRecovery(events, queued.promptId, identity);
+    }
+    finally {
+        unsubscribe();
+    }
+}

package/dist/application/fleet-query-service.js

@@ -4,6 +4,7 @@ import { classifyActivity } from '../session/activity.js';
 import { controlRequest } from '../session/control.js';
 import { SessionControlError } from '../session/types.js';
 import { readExitRecord, readRestartLedger } from '../runner.js';
+import { readDaemonRecoveryStatus } from '../daemon-recovery.js';
 import { roleCapabilities } from './capabilities.js';
 import { FleetError } from './errors.js';
 const clean = (value, max = 512) => value.replace(/[\0-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '').trim().slice(0, max);
@@ -46,7 +47,8 @@ function readIsolation(dir) {
 function sessionOverall(supervisor, session, restart, monitor, isolation, problems) {
     if (restart.circuit === 'open' || monitor.health === 'failed' || monitor.health === 'degraded'
         || isolation.degraded
-        || problems.some(problem => problem.severity === 'error' || problem.source === 'watchdog')
+        || problems.some(problem => problem.severity === 'error'
+            || problem.source === 'watchdog' || problem.source === 'daemon-recovery')
         || session.readiness === 'failed')
         return 'attention';
     // A reachable agent session is the user's live interaction surface. Its
@@ -103,6 +105,16 @@ export class FleetQueryService {
         const lastExit = dir ? readExitRecord(join(dir, '.exit-status')) ?? undefined : undefined;
         const session = await this.session(role, dir, live.state);
         const problems = [...role.problems];
+        const recovery = dir ? readDaemonRecoveryStatus(dir) : undefined;
+        if (recovery && recovery.state !== 'recovered') {
+            const paths = ['agent', 'owner']
+                .filter(name => recovery.paths[name].state !== 'recovered')
+                .map(name => `${name}:${recovery.paths[name].state}`);
+            problems.push({
+                code: 'daemon_recovery', severity: 'warning', source: 'daemon-recovery',
+                detail: `${recovery.state}; ${paths.join(', ') || 'no degraded path'}; epoch ${recovery.epoch || 'unavailable'}`,
+            });
+        }
         if (live.state === 'running' && session.reachability !== 'online')
             problems.push({
                 code: 'supervisor_session_disagreement', severity: 'warning',

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.1.0-nightly.6",
-  "buildId": "e174f2cdb42c",
-  "commit": "53aa98d46005a693784fbc11957d6118048249c8",
+  "version": "1.1.0-nightly.7",
+  "buildId": "a09aa98e92aa",
+  "commit": "d79160ae66847305a109bed339d8c8830a20bba7",
   "dirty": true,
-  "builtAt": "2026-08-31T06:49:46.839Z",
+  "builtAt": "2026-08-31T07:32:26.852Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/daemon-recovery.d.ts

@@ -0,0 +1,93 @@
+import { type FetchLike } from './monitor.js';
+export declare const DAEMON_RECOVERY_MAX_ATTEMPTS = 6;
+export declare const DAEMON_RECOVERY_INITIAL_BACKOFF_MS = 1000;
+export declare const DAEMON_RECOVERY_MAX_BACKOFF_MS = 5000;
+export declare const DAEMON_RECOVERY_DEADLINE_MS = 60000;
+export interface DaemonGeneration {
+    bootId: string;
+    pid: number;
+    startedAt: number;
+    stateDir: string;
+}
+export type DaemonGenerationProbe = {
+    state: 'ready';
+    generation: DaemonGeneration;
+} | {
+    state: 'unavailable';
+    reason: string;
+};
+export type DaemonGenerationObservation = {
+    kind: 'baseline' | 'stable' | 'available';
+    generation: DaemonGeneration;
+} | {
+    kind: 'changed';
+    previous: DaemonGeneration;
+    generation: DaemonGeneration;
+} | {
+    kind: 'lost' | 'unavailable';
+    previous?: DaemonGeneration;
+    reason: string;
+};
+interface GenerationProbeDeps {
+    readText?(path: string): string;
+    canonicalize?(path: string): string;
+}
+/**
+ * Corroborate the loopback daemon's unauthenticated `/info`, its credentialed
+ * identity-index readiness route, and its local boot-generation record. The
+ * index enforces auth when the daemon visibility requires it; open visibility
+ * deliberately does not. No source is sufficient
+ * alone: `/info` has no boot id, the identity index has no generation, and a
+ * stale `ready` file can outlive the process that wrote it.
+ */
+export declare function probeDaemonGeneration(fetch: FetchLike, env: NodeJS.ProcessEnv, deps?: GenerationProbeDeps): Promise<DaemonGenerationProbe>;
+export declare class DaemonGenerationObserver {
+    private current?;
+    private unavailable;
+    observe(probe: DaemonGenerationProbe): DaemonGenerationObservation;
+}
+export declare function daemonRecoveryBackoff(attempt: number): number;
+export type RecoveryPath = 'agent' | 'owner';
+export type RecoveryPathResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+export interface RoleRecoveryControllerOptions {
+    role: string;
+    identity: string;
+    stateDir: string;
+    now(): number;
+    sleep(ms: number): Promise<void>;
+    recoverAgent(epoch: string): Promise<RecoveryPathResult>;
+    recoverOwner(epoch: string): Promise<RecoveryPathResult>;
+    log(line: string): void;
+}
+export interface RecoveryStatus {
+    version: 1;
+    identity: string;
+    epoch: string;
+    state: 'recovering' | 'recovered' | 'degraded' | 'cancelled';
+    paths: Record<RecoveryPath, {
+        state: 'pending' | 'recovered' | 'degraded';
+        attempts: number;
+        reason?: string;
+    }>;
+    updatedAt: string;
+}
+export declare function readDaemonRecoveryStatus(dir: string): RecoveryStatus | undefined;
+/** Per-role, per-generation bounded recovery with path-level fault isolation. */
+export declare class RoleRecoveryController {
+    private readonly options;
+    private token;
+    private activeEpoch?;
+    private active?;
+    private status?;
+    constructor(options: RoleRecoveryControllerOptions);
+    recover(generation: DaemonGeneration): Promise<RecoveryStatus>;
+    cancel(): void;
+    noteLoss(reason: string): void;
+    private write;
+}
+export {};

package/dist/daemon-recovery.js

@@ -0,0 +1,328 @@
+import { readFileSync, realpathSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { createHash } from 'node:crypto';
+import { resolveEndpoint } from './monitor.js';
+import { replaceFileAtomically } from './atomic-file.js';
+export const DAEMON_RECOVERY_MAX_ATTEMPTS = 6;
+export const DAEMON_RECOVERY_INITIAL_BACKOFF_MS = 1_000;
+export const DAEMON_RECOVERY_MAX_BACKOFF_MS = 5_000;
+export const DAEMON_RECOVERY_DEADLINE_MS = 60_000;
+const STARTUP_PHASES = new Set([
+    'initializing', 'wrapper', 'registrar', 'identities', 'reconciliation',
+    'server', 'ready', 'failed',
+]);
+function positiveInteger(value) {
+    return Number.isSafeInteger(value) && value > 0;
+}
+function finiteTimestamp(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
+function startupProgress(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const row = value;
+    if (row.version !== 1 || !positiveInteger(row.pid)
+        || typeof row.bootId !== 'string' || row.bootId.length === 0
+        || typeof row.phase !== 'string' || !STARTUP_PHASES.has(row.phase)
+        || !finiteTimestamp(row.startedAt) || !finiteTimestamp(row.updatedAt))
+        return undefined;
+    if (row.updatedAt < row.startedAt)
+        return undefined;
+    if ((row.completed === undefined) !== (row.total === undefined))
+        return undefined;
+    if (row.completed !== undefined
+        && (!Number.isSafeInteger(row.completed) || row.completed < 0
+            || !Number.isSafeInteger(row.total) || row.total < 0
+            || row.completed > row.total))
+        return undefined;
+    return row;
+}
+function canonical(path, deps) {
+    const absolute = resolve(path);
+    return deps.canonicalize?.(absolute) ?? realpathSync.native(absolute);
+}
+/**
+ * Corroborate the loopback daemon's unauthenticated `/info`, its credentialed
+ * identity-index readiness route, and its local boot-generation record. The
+ * index enforces auth when the daemon visibility requires it; open visibility
+ * deliberately does not. No source is sufficient
+ * alone: `/info` has no boot id, the identity index has no generation, and a
+ * stale `ready` file can outlive the process that wrote it.
+ */
+export async function probeDaemonGeneration(fetch, env, deps = {}) {
+    const endpoint = resolveEndpoint(env);
+    let response;
+    try {
+        response = await fetch(`${endpoint.origin}/info`, { headers: endpoint.headers });
+    }
+    catch {
+        return { state: 'unavailable', reason: 'DAEMON_INFO_UNREACHABLE' };
+    }
+    if (!response.ok)
+        return {
+            state: 'unavailable',
+            reason: response.status === 401 ? 'DAEMON_INFO_UNAUTHORIZED' : 'DAEMON_INFO_HTTP_ERROR',
+        };
+    let info;
+    try {
+        const value = await response.json();
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error('shape');
+        info = value;
+    }
+    catch {
+        return { state: 'unavailable', reason: 'DAEMON_INFO_INVALID' };
+    }
+    if (info.name !== 'ours' || !positiveInteger(info.pid)
+        || typeof info.stateDir !== 'string' || info.stateDir.length === 0)
+        return { state: 'unavailable', reason: 'DAEMON_INFO_INVALID' };
+    let reportedStateDir;
+    let expectedStateDir;
+    try {
+        reportedStateDir = canonical(info.stateDir, deps);
+        expectedStateDir = canonical(endpoint.stateDir, deps);
+    }
+    catch {
+        return { state: 'unavailable', reason: 'DAEMON_STATE_DIR_UNAVAILABLE' };
+    }
+    if (reportedStateDir !== expectedStateDir)
+        return { state: 'unavailable', reason: 'DAEMON_STATE_DIR_MISMATCH' };
+    // `/identities` is the daemon's credential-capable readiness route. A
+    // valid-but-empty index is a documented intermediate startup state, never
+    // proof of readiness.
+    let identitiesResponse;
+    try {
+        identitiesResponse = await fetch(`${endpoint.origin}/identities`, { headers: endpoint.headers });
+    }
+    catch {
+        return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_UNREACHABLE' };
+    }
+    if (!identitiesResponse.ok)
+        return {
+            state: 'unavailable',
+            reason: identitiesResponse.status === 401
+                ? 'DAEMON_IDENTITIES_UNAUTHORIZED' : 'DAEMON_IDENTITIES_HTTP_ERROR',
+        };
+    try {
+        const body = await identitiesResponse.json();
+        if (!body || typeof body !== 'object' || Array.isArray(body)
+            || !Array.isArray(body.identities))
+            return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_INVALID' };
+        if (body.identities.length === 0)
+            return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_NOT_READY' };
+    }
+    catch {
+        return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_INVALID' };
+    }
+    let progress;
+    try {
+        const text = deps.readText?.(join(reportedStateDir, 'startup-progress.json'))
+            ?? readFileSync(join(reportedStateDir, 'startup-progress.json'), 'utf8');
+        progress = startupProgress(JSON.parse(text));
+    }
+    catch {
+        return { state: 'unavailable', reason: 'DAEMON_PROGRESS_UNAVAILABLE' };
+    }
+    if (!progress)
+        return { state: 'unavailable', reason: 'DAEMON_PROGRESS_INVALID' };
+    if (progress.phase !== 'ready')
+        return { state: 'unavailable', reason: 'DAEMON_PROGRESS_NOT_READY' };
+    if (progress.pid !== info.pid)
+        return { state: 'unavailable', reason: 'DAEMON_GENERATION_MISMATCH' };
+    return {
+        state: 'ready',
+        generation: {
+            // Keep bootId opaque. Its current writer uses `${pid}-${startedAt}`, but
+            // equality—not its formatting—is the generation contract Fleet needs.
+            bootId: progress.bootId,
+            pid: progress.pid,
+            startedAt: progress.startedAt,
+            stateDir: reportedStateDir,
+        },
+    };
+}
+export class DaemonGenerationObserver {
+    current;
+    unavailable = false;
+    observe(probe) {
+        if (probe.state === 'unavailable') {
+            // Cold startup has no generation to lose. Do not manufacture a recovery
+            // epoch before the first corroborated ready observation.
+            if (!this.current)
+                return { kind: 'unavailable', reason: probe.reason };
+            const kind = this.unavailable ? 'unavailable' : 'lost';
+            this.unavailable = true;
+            return { kind, previous: this.current, reason: probe.reason };
+        }
+        const next = probe.generation;
+        const previous = this.current;
+        this.current = next;
+        if (!previous) {
+            this.unavailable = false;
+            return { kind: 'baseline', generation: next };
+        }
+        const changed = previous.bootId !== next.bootId
+            || previous.pid !== next.pid
+            || previous.startedAt !== next.startedAt
+            || previous.stateDir !== next.stateDir;
+        const wasUnavailable = this.unavailable;
+        this.unavailable = false;
+        if (changed)
+            return { kind: 'changed', previous, generation: next };
+        return { kind: wasUnavailable ? 'available' : 'stable', generation: next };
+    }
+}
+export function daemonRecoveryBackoff(attempt) {
+    const exponent = Math.max(0, Math.min(attempt - 1, 30));
+    return Math.min(DAEMON_RECOVERY_INITIAL_BACKOFF_MS * 2 ** exponent, DAEMON_RECOVERY_MAX_BACKOFF_MS);
+}
+function safeRecoveryReason(reason, fallback = 'RECOVERY_PATH_FAILED') {
+    return /^[A-Z][A-Z0-9_]{0,95}$/.test(reason) ? reason : fallback;
+}
+export function readDaemonRecoveryStatus(dir) {
+    try {
+        const raw = readFileSync(join(dir, '.daemon-recovery.json'), 'utf8');
+        if (raw.length > 16 * 1024)
+            return undefined;
+        const value = JSON.parse(raw);
+        if (value.version !== 1 || typeof value.epoch !== 'string'
+            || !['recovering', 'recovered', 'degraded', 'cancelled'].includes(value.state ?? '')
+            || !value.paths || typeof value.paths !== 'object')
+            return undefined;
+        for (const name of ['agent', 'owner']) {
+            const path = value.paths[name];
+            if (!path || !['pending', 'recovered', 'degraded'].includes(path.state)
+                || !Number.isSafeInteger(path.attempts) || path.attempts < 0
+                || (path.reason !== undefined && !/^[A-Z0-9_]{1,96}$/.test(path.reason)))
+                return undefined;
+        }
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Per-role, per-generation bounded recovery with path-level fault isolation. */
+export class RoleRecoveryController {
+    options;
+    token = 0;
+    activeEpoch;
+    active;
+    status;
+    constructor(options) {
+        this.options = options;
+    }
+    recover(generation) {
+        const epoch = createHash('sha256').update([
+            generation.bootId, generation.pid, generation.startedAt, generation.stateDir,
+        ].join('\0')).digest('hex').slice(0, 24);
+        if (this.activeEpoch === epoch && this.active)
+            return this.active;
+        const token = ++this.token;
+        this.activeEpoch = epoch;
+        const deadline = this.options.now() + DAEMON_RECOVERY_DEADLINE_MS;
+        const status = {
+            version: 1, identity: this.options.identity, epoch, state: 'recovering',
+            paths: {
+                agent: { state: 'pending', attempts: 0 },
+                owner: { state: 'pending', attempts: 0 },
+            },
+            updatedAt: new Date(this.options.now()).toISOString(),
+        };
+        this.status = status;
+        this.write(status, token);
+        const runPath = async (path, operation) => {
+            let lastReason = 'RECOVERY_ATTEMPTS_EXHAUSTED';
+            for (let attempt = 1; attempt <= DAEMON_RECOVERY_MAX_ATTEMPTS; attempt++) {
+                if (token !== this.token)
+                    return;
+                if (this.options.now() >= deadline) {
+                    lastReason = 'RECOVERY_DEADLINE_EXCEEDED';
+                    break;
+                }
+                status.paths[path] = { state: 'pending', attempts: attempt };
+                this.write(status, token);
+                try {
+                    const remaining = Math.max(0, deadline - this.options.now());
+                    let timer;
+                    const result = await Promise.race([
+                        operation(epoch),
+                        new Promise(resolve => {
+                            timer = setTimeout(() => resolve({ ok: false, reason: 'RECOVERY_DEADLINE_EXCEEDED' }), remaining);
+                            timer.unref?.();
+                        }),
+                    ]).finally(() => { if (timer)
+                        clearTimeout(timer); });
+                    if (token !== this.token)
+                        return;
+                    if (result.ok) {
+                        status.paths[path] = { state: 'recovered', attempts: attempt };
+                        this.write(status, token);
+                        return;
+                    }
+                    lastReason = safeRecoveryReason(result.reason);
+                }
+                catch (error) {
+                    lastReason = safeRecoveryReason(error instanceof Error && error.name
+                        ? `RECOVERY_${error.name.toUpperCase()}` : 'RECOVERY_UNKNOWN_ERROR', 'RECOVERY_UNKNOWN_ERROR');
+                }
+                if (attempt < DAEMON_RECOVERY_MAX_ATTEMPTS) {
+                    const wait = Math.min(daemonRecoveryBackoff(attempt), Math.max(0, deadline - this.options.now()));
+                    await this.options.sleep(wait);
+                }
+            }
+            if (token !== this.token)
+                return;
+            status.paths[path] = {
+                state: 'degraded', attempts: status.paths[path].attempts, reason: lastReason,
+            };
+            this.write(status, token);
+        };
+        const active = Promise.all([
+            runPath('agent', this.options.recoverAgent),
+            runPath('owner', this.options.recoverOwner),
+        ]).then(() => {
+            if (token !== this.token) {
+                status.state = 'cancelled';
+                return status;
+            }
+            status.state = Object.values(status.paths).every(path => path.state === 'recovered')
+                ? 'recovered' : 'degraded';
+            this.write(status, token);
+            return status;
+        });
+        this.active = active;
+        return active;
+    }
+    cancel() {
+        const token = ++this.token;
+        this.activeEpoch = undefined;
+        this.active = undefined;
+        if (this.status?.state === 'recovering') {
+            this.status.state = 'cancelled';
+            this.write(this.status, token);
+        }
+    }
+    noteLoss(reason) {
+        const token = ++this.token;
+        this.activeEpoch = undefined;
+        this.active = undefined;
+        const status = {
+            version: 1, identity: this.options.identity, epoch: '', state: 'degraded',
+            paths: {
+                agent: { state: 'degraded', attempts: 0, reason: safeRecoveryReason(reason, 'DAEMON_UNAVAILABLE') },
+                owner: { state: 'degraded', attempts: 0, reason: safeRecoveryReason(reason, 'DAEMON_UNAVAILABLE') },
+            },
+            updatedAt: new Date(this.options.now()).toISOString(),
+        };
+        this.status = status;
+        this.write(status, token);
+    }
+    write(status, token) {
+        if (token !== this.token)
+            return;
+        status.updatedAt = new Date(this.options.now()).toISOString();
+        replaceFileAtomically(join(this.options.stateDir, '.daemon-recovery.json'), JSON.stringify(status, null, 2) + '\n', 0o600);
+        this.options.log(`[${this.options.role}] daemon recovery ${status.state} epoch=${status.epoch || 'unavailable'}`);
+    }
+}

package/dist/doctor.js

@@ -13,6 +13,7 @@ import { authResolutionHint, resolveEndpoint, } from './monitor.js';
 import { readScheduledLoops, storedLoopHealth } from './loops/state.js';
 import { controlSocketPath } from './session/control.js';
 import { analyzeInstalls, buildInfo, buildLabel, discoverInstalls, BIN_NAME, } from './provenance.js';
+import { readDaemonRecoveryStatus } from './daemon-recovery.js';
 /** Which cgroup-v2 controllers are delegated to this user manager (advisory). */
 function cgroupDelegationDetail() {
     try {
@@ -106,6 +107,19 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
                 ok: true,
                 detail: `warning: ${diagnostic.message}`,
             });
+    for (const role of roles) {
+        const recovery = readDaemonRecoveryStatus(agentDir(role.name));
+        if (!recovery)
+            continue;
+        const paths = ['agent', 'owner']
+            .map(name => `${name}=${recovery.paths[name].state}`)
+            .join(', ');
+        checks.push({
+            name: `daemon recovery: ${role.name}`,
+            ok: recovery.state === 'recovered',
+            detail: `${recovery.state}; ${paths}; epoch ${recovery.epoch || 'unavailable'}`,
+        });
+    }
     // ── Rooms/tasks checks ────────────────────────────────────────
     if (loaded.ok && loaded.rooms) {
         const rooms = loaded.rooms;

package/dist/owner-channel/channel.d.ts

@@ -1,6 +1,7 @@
 import { type OwnerChannelConfig } from '../config.js';
 import { type AgentSession } from '../session/types.js';
 import { type OwnerFleetOps } from './commands.js';
+import type { ManagedFleetSpawnResult } from '../fleet-proxy.js';
 import { type FleetAuditAttempt, type FleetAuditPresentation, type FleetCommandOutcomeClass } from '../fleet-command-audit.js';
 import { type OursOps } from './ours-client.js';
 import { type OwnerUpdatePhase } from './notices.js';
@@ -27,12 +28,24 @@ export interface OwnerChannelOptions {
     binderDeps?: OwnerBinderDeps;
     /** Pre-acquired by the runner so the predecessor control socket remains reachable while waiting. */
     binderLease?: OwnerBinderLease;
+    recoveryDeps?: {
+        now(): number;
+        setTimer(fn: () => void, ms: number): ReturnType<typeof setTimeout>;
+        clearTimer(timer: ReturnType<typeof setTimeout>): void;
+        deadlineMs?: number;
+    };
 }
 export interface OwnerChannelHandle {
     start(): Promise<void>;
     drain(): Promise<void>;
     close(): Promise<void>;
+    /** Reattach this same supervisor-owned channel after a daemon generation change. */
+    recover?(epoch: string): Promise<void>;
+    /** False when shutdown skipped client disposal because quiescence was unproven. */
+    binderReleaseSafe?(): boolean;
     manage(request: OwnerChannelManagementRequest): Promise<OwnerChannelManagementResult>;
+    /** Fleet-owned deterministic lifecycle notice; absent on legacy test doubles. */
+    notifyFleetSpawn?(event: ManagedFleetSpawnResult): Promise<void>;
     beginFleetCommandAudit?(requestId: string, argv: string[]): Promise<FleetAuditAttempt>;
     finishFleetCommandAudit?(input: {
         correlationId: string;
@@ -43,6 +56,17 @@ export interface OwnerChannelHandle {
         presentation?: FleetAuditPresentation;
     }): Promise<FleetAuditAttempt>;
 }
+export declare const OWNER_RECOVERY_QUEUE_CAPACITY = 32;
+export declare const OWNER_RECOVERY_DEGRADED = "OWNER_RECOVERY_DEGRADED";
+export declare class OwnerRecoveryDegradedError extends Error {
+    readonly code = "OWNER_RECOVERY_DEGRADED";
+    constructor();
+}
+export declare class OwnerRecoveryTimeoutError extends Error {
+    readonly stage: string;
+    readonly code = "OWNER_RECOVERY_DEGRADED";
+    constructor(stage: string);
+}
 export type OwnerChannelManagementRequest = {
     action: 'contact_list';
 } | {
@@ -169,7 +193,17 @@ export declare class OwnerChannel implements OwnerChannelHandle {
     private readonly completionTasks;
     private readonly activeRequests;
     private managementTail;
+    private recoveryEpoch?;
+    private recoveryTask?;
+    private recoveryToken;
+    private recoveryQueued;
+    private watchGeneration;
+    /** A timed-out client operation that must settle before replacement is safe. */
+    private recoveryQuiescence?;
+    private releaseSafe;
     private ready;
+    private startedOnce;
+    private shutdownDegraded;
     private binder?;
     private binderOwnedInternally;
     private readonly fleetOps;
@@ -179,7 +213,9 @@ export declare class OwnerChannel implements OwnerChannelHandle {
     start(): Promise<void>;
     drain(): Promise<void>;
     close(): Promise<void>;
+    binderReleaseSafe(): boolean;
     manage(request: OwnerChannelManagementRequest): Promise<OwnerChannelManagementResult>;
+    notifyFleetSpawn(event: ManagedFleetSpawnResult): Promise<void>;
     beginFleetCommandAudit(requestId: string, argv: string[]): Promise<FleetAuditAttempt>;
     finishFleetCommandAudit(input: {
         correlationId: string;
@@ -189,6 +225,10 @@ export declare class OwnerChannel implements OwnerChannelHandle {
         resourceIds?: Record<string, string>;
         presentation?: FleetAuditPresentation;
     }): Promise<FleetAuditAttempt>;
+    recover(epoch: string): Promise<void>;
+    private recoveryStage;
+    private writeShutdownState;
+    private queueManagement;
     private manageNow;
     /**
      * The daemon reports established contacts and pending introductions as two

package/dist/owner-channel/channel.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { mkdir, readFile, readdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { canonicalCid } from '../config.js';
+import { DAEMON_RECOVERY_DEADLINE_MS } from '../daemon-recovery.js';
 import { replaceFileAtomically } from '../atomic-file.js';
 import { TaskRoomApplicationService } from '../application/task-room-service.js';
 import { RoleLifecycleService } from '../application/role-command-service.js';
@@ -22,6 +23,24 @@ import { OwnerTaskState, ownerTaskAuditId, ownerTaskDigest, } from './tasks.js';
 import { AttachmentRecoveryState, admitAttachments, cleanupAttachmentRoot, parseIncomingAttachments, parseRetrievedAttachments, prepareAttachmentDirectory, recoveredAttachment, removeRequestDirectory, safeField, validateAttachmentSelection, validateAttachmentRelaySelection, writeRecoveredAttachment, } from './attachments.js';
 import { acquireOwnerBinderLease, OWNER_BIND_HANDOFF_TIMEOUT_MS, } from './binder.js';
 import { MessageRecoveryState } from './message-recovery.js';
+export const OWNER_RECOVERY_QUEUE_CAPACITY = 32;
+export const OWNER_RECOVERY_DEGRADED = 'OWNER_RECOVERY_DEGRADED';
+export class OwnerRecoveryDegradedError extends Error {
+    code = OWNER_RECOVERY_DEGRADED;
+    constructor() {
+        super('owner channel recovery is degraded');
+        this.name = 'OwnerRecoveryDegradedError';
+    }
+}
+export class OwnerRecoveryTimeoutError extends Error {
+    stage;
+    code = OWNER_RECOVERY_DEGRADED;
+    constructor(stage) {
+        super(`owner channel recovery timed out at ${stage}`);
+        this.stage = stage;
+        this.name = 'OwnerRecoveryTimeoutError';
+    }
+}
 const OWNER_UPDATE_MIN_INTERVAL_MS = 5_000;
 const OWNER_UPDATE_MAX_COUNT = 20;
 const OWNER_UPDATE_MAX_CHARS = 280;
@@ -77,7 +96,17 @@ export class OwnerChannel {
     completionTasks = new Set();
     activeRequests = new Map();
     managementTail = Promise.resolve();
+    recoveryEpoch;
+    recoveryTask;
+    recoveryToken = 0;
+    recoveryQueued = 0;
+    watchGeneration = 0;
+    /** A timed-out client operation that must settle before replacement is safe. */
+    recoveryQuiescence;
+    releaseSafe = true;
     ready = false;
+    startedOnce = false;
+    shutdownDegraded = false;
     binder;
     binderOwnedInternally = false;
     fleetOps;
@@ -127,6 +156,7 @@ export class OwnerChannel {
     }
     async start() {
         this.stopping = false;
+        this.shutdownDegraded = false;
         this.binderOwnedInternally = !this.options.binderLease;
         this.binder = this.options.binderLease ?? await acquireOwnerBinderLease(this.options.stateDir, this.options.role, this.options.config.identity, this.options.binderDeps);
         try {
@@ -167,11 +197,12 @@ export class OwnerChannel {
             this.attachmentRecovery.cleanup(Date.now(), this.attachmentConfig.retention_ms);
             void cleanupAttachmentRoot(this.attachmentRoot, Date.now(), this.attachmentConfig.retention_ms).catch(error => this.logError('attachment crash cleanup failed', error));
         }
+        this.startedOnce = true;
         this.ready = true;
         // Do not make role startup wait for an old owner request to finish a turn.
         // watchLoop itself drains before every establishment, including this first
         // one, so there is no drain-to-tip race.
-        this.watchTask = this.watchLoop();
+        this.watchTask = this.watchLoop(++this.watchGeneration);
     }
     drain() {
         this.drainRequested = true;
@@ -186,25 +217,65 @@ export class OwnerChannel {
         return this.drainTask;
     }
     async close() {
+        if (this.recoveryTask)
+            this.shutdownDegraded = true;
         this.stopping = true;
         this.ready = false;
-        this.watchAbort?.abort();
-        await this.watchTask?.catch(error => this.logError('watch shutdown failed', error));
+        this.recoveryToken++;
+        this.watchGeneration++;
+        const staleWatch = this.watchTask;
         this.watchTask = undefined;
-        await this.managementTail;
+        this.watchAbort?.abort();
+        const now = this.options.recoveryDeps?.now ?? (() => Date.now());
+        const deadlineAt = now()
+            + (this.options.recoveryDeps?.deadlineMs ?? DAEMON_RECOVERY_DEADLINE_MS);
+        let disposed = false;
         try {
-            await this.client.close();
+            await this.recoveryStage('shutdown_quiescence', Promise.all([
+                staleWatch?.catch(error => this.logError('watch shutdown failed', error)),
+                this.drainTask?.catch(error => this.logError('drain shutdown failed', error)),
+                this.managementTail.then(() => undefined),
+                this.recoveryQuiescence,
+            ]), deadlineAt);
+            await this.recoveryStage('shutdown_close', this.client.close(), deadlineAt);
+            disposed = true;
+            this.writeShutdownState('closed', 'OWNER_SHUTDOWN_CLOSED', now());
+        }
+        catch (error) {
+            this.shutdownDegraded = true;
+            this.releaseSafe = false;
+            const stage = error instanceof OwnerRecoveryTimeoutError ? error.stage : 'shutdown_unknown';
+            this.writeShutdownState('degraded', `OWNER_${stage.toUpperCase()}_TIMEOUT`, now());
+            this.options.log(`[${this.options.role}] owner shutdown degraded stage=${stage}`);
         }
         finally {
-            if (this.binderOwnedInternally)
+            if (disposed && this.binderOwnedInternally)
                 this.binder?.release();
-            this.binder = undefined;
+            if (disposed)
+                this.binder = undefined;
         }
     }
+    binderReleaseSafe() { return this.releaseSafe; }
     manage(request) {
-        const run = this.managementTail.then(() => this.manageNow(request));
-        this.managementTail = run.then(() => undefined, () => undefined);
-        return run;
+        return this.queueManagement(() => this.manageNow(request));
+    }
+    notifyFleetSpawn(event) {
+        return this.queueManagement(async () => {
+            if (!this.ready || this.stopping)
+                throw new Error('owner-channel MCP client is unavailable');
+            const model = event.model ? `, model ${event.model}` : '';
+            const monitorPolicy = event.monitor.interrupt === true
+                ? ' with interruption'
+                : event.monitor.interrupt === 'after_tool' ? ' with after-tool steering' : '';
+            const monitor = `${event.monitor.mode} monitor${monitorPolicy}`;
+            const permission = event.permissionMode
+                ? `; permission ${event.permissionMode.fleetMode}, native ${event.permissionMode.nativeMode}`
+                : '';
+            const inherited = event.inherited.length
+                ? ` Supervisor inherited omitted defaults: ${event.inherited.join(', ')}.` : '';
+            await this.sendProactiveMessage(`🧑‍💻 ${event.caller} spawned ${event.lifetime} agent ${event.role} `
+                + `(${event.harness}/${event.session}${model}; ${monitor}${permission}).${inherited}`, `fleet-spawn\0${event.creationActionId}`, 0);
+        });
     }
     beginFleetCommandAudit(requestId, argv) {
         const run = this.managementTail.then(async () => {
@@ -263,6 +334,129 @@ export class OwnerChannel {
         this.managementTail = run.then(() => undefined, () => undefined);
         return run;
     }
+    recover(epoch) {
+        if (this.stopping)
+            return Promise.reject(new Error('owner channel is stopping'));
+        if (this.recoveryEpoch === epoch && this.recoveryTask)
+            return this.recoveryTask;
+        this.recoveryEpoch = epoch;
+        this.ready = false;
+        const token = ++this.recoveryToken;
+        const watchGeneration = ++this.watchGeneration;
+        const staleWatch = this.watchTask;
+        this.watchTask = undefined;
+        this.watchAbort?.abort();
+        const superseded = () => this.stopping || token !== this.recoveryToken;
+        const now = this.options.recoveryDeps?.now ?? (() => Date.now());
+        const deadlineAt = now()
+            + (this.options.recoveryDeps?.deadlineMs ?? DAEMON_RECOVERY_DEADLINE_MS);
+        const run = this.managementTail.then(async () => {
+            if (superseded())
+                throw new Error('owner recovery epoch superseded');
+            if (this.recoveryQuiescence) {
+                const debt = this.recoveryQuiescence;
+                await this.recoveryStage('prior_quiescence', debt, deadlineAt);
+                if (this.recoveryQuiescence === debt)
+                    this.recoveryQuiescence = undefined;
+            }
+            // Quiesce every stale-client reader before replacing its transport. A
+            // watch can be inside the shared drain task when its abort lands.
+            await this.recoveryStage('stale_quiescence', Promise.all([
+                staleWatch?.catch(error => this.logError('stale watch shutdown failed', error)),
+                this.drainTask?.catch(error => this.logError('stale drain shutdown failed', error)),
+            ]), deadlineAt);
+            if (superseded())
+                throw new Error('owner recovery epoch superseded');
+            await this.recoveryStage('close', this.client.close(), deadlineAt);
+            if (superseded())
+                throw new Error('owner recovery epoch superseded');
+            try {
+                await this.recoveryStage('start', this.client.start(), deadlineAt);
+                if (superseded())
+                    throw new Error('owner recovery epoch superseded');
+                await this.recoveryStage('bind', this.client.bindIdentity(this.options.config.identity), deadlineAt);
+                if (superseded())
+                    throw new Error('owner recovery epoch superseded');
+                // Journal-aware drain is the only operation allowed to mark owner mail
+                // read. The final listing is a typed, read-only channel probe.
+                await this.recoveryStage('drain', this.drain(), deadlineAt);
+                await this.recoveryStage('list', this.client.listIncomingMessages(), deadlineAt);
+                if (superseded())
+                    throw new Error('owner recovery epoch superseded');
+                this.ready = true;
+                this.watchTask = this.watchLoop(watchGeneration);
+            }
+            catch (error) {
+                this.ready = false;
+                if (token === this.recoveryToken)
+                    this.recoveryToken++;
+                // A timed-out operation may still be using this client. Never overlap
+                // its disposal; the recorded quiescence debt gates the next retry.
+                if (!this.recoveryQuiescence) {
+                    try {
+                        await this.recoveryStage('close_after_failure', this.client.close(), deadlineAt);
+                    }
+                    catch (closeError) {
+                        this.logError('recovery client close failed', closeError);
+                    }
+                }
+                throw error;
+            }
+        });
+        this.managementTail = run.then(() => undefined, () => undefined);
+        const task = run.finally(() => {
+            if (this.recoveryTask === task)
+                this.recoveryTask = undefined;
+        });
+        this.recoveryTask = task;
+        return task;
+    }
+    recoveryStage(stage, operation, deadlineAt) {
+        const now = this.options.recoveryDeps?.now ?? (() => Date.now());
+        const remaining = Math.max(0, deadlineAt - now());
+        const setTimer = this.options.recoveryDeps?.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+        const clearTimer = this.options.recoveryDeps?.clearTimer ?? (timer => clearTimeout(timer));
+        let timer;
+        const timeout = new Promise((_resolve, reject) => {
+            timer = setTimer(() => reject(new OwnerRecoveryTimeoutError(stage)), remaining);
+        });
+        return Promise.race([operation, timeout]).catch(error => {
+            if (error instanceof OwnerRecoveryTimeoutError) {
+                const debt = operation.then(() => undefined, () => undefined);
+                this.recoveryQuiescence = debt;
+            }
+            throw error;
+        }).finally(() => clearTimer(timer));
+    }
+    writeShutdownState(state, reason, at) {
+        try {
+            replaceFileAtomically(join(this.options.stateDir, '.owner-channel-shutdown.json'), JSON.stringify({ version: 1, state, reason, at: new Date(at).toISOString() }, null, 2) + '\n');
+        }
+        catch (error) {
+            this.logError('shutdown status write failed', error);
+        }
+    }
+    queueManagement(operation) {
+        const deferred = this.recoveryTask !== undefined && !this.ready;
+        if (!this.ready && !deferred)
+            return Promise.reject(!this.startedOnce || (this.stopping && !this.shutdownDegraded)
+                ? new Error('owner-channel MCP client is unavailable')
+                : new OwnerRecoveryDegradedError());
+        if (deferred && this.recoveryQueued >= OWNER_RECOVERY_QUEUE_CAPACITY)
+            return Promise.reject(new Error('owner recovery queue is full'));
+        if (deferred)
+            this.recoveryQueued++;
+        const run = this.managementTail.then(() => {
+            if (!this.ready || this.stopping)
+                throw new OwnerRecoveryDegradedError();
+            return operation();
+        });
+        this.managementTail = run.then(() => undefined, () => undefined);
+        return run.finally(() => {
+            if (deferred)
+                this.recoveryQueued = Math.max(0, this.recoveryQueued - 1);
+        });
+    }
     async manageNow(request) {
         if (!this.ready || this.stopping)
             throw new Error('owner-channel MCP client is unavailable');
@@ -1916,7 +2110,7 @@ export class OwnerChannel {
         }
         return undefined;
     }
-    async watchLoop() {
+    async watchLoop(generation) {
         const sleep = this.options.binderDeps?.sleep
             ?? (ms => new Promise(resolve => setTimeout(resolve, ms)));
         const restored = this.readWatchState();
@@ -1925,7 +2119,7 @@ export class OwnerChannel {
             state = this.writeWatchState(state, 'OWNER_WATCH_STATE_RECOVERED');
         let delayMs = 1_000;
         let attempts = 0;
-        while (!this.stopping) {
+        while (!this.stopping && generation === this.watchGeneration) {
             const ctrl = new AbortController();
             this.watchAbort = ctrl;
             try {
@@ -1935,12 +2129,12 @@ export class OwnerChannel {
                 // fall into a gap. Persistent history plus fleet's body-free claim
                 // journal is authoritative; durable wire-ID dedupe makes hints harmless.
                 await this.drain();
-                if (this.stopping)
+                if (this.stopping || generation !== this.watchGeneration)
                     return;
                 state = this.writeWatchState(state, 'OWNER_WATCH_CONNECTING', { reconnected: attempts > 0 });
                 attempts++;
                 for await (const _event of this.client.watchNotifications(this.options.config.identity, { since: 0, signal: ctrl.signal })) {
-                    if (this.stopping)
+                    if (this.stopping || generation !== this.watchGeneration)
                         return;
                     state = this.writeWatchState(state, 'OWNER_WATCH_CONNECTED', { resetFailures: true });
                     delayMs = 1_000;
@@ -1949,11 +2143,11 @@ export class OwnerChannel {
                     // recorded before a managed request is dispatched.
                     await this.drain();
                 }
-                if (!this.stopping)
+                if (!this.stopping && generation === this.watchGeneration)
                     throw new Error('ours SDK notification stream ended');
             }
             catch (error) {
-                if (this.stopping)
+                if (this.stopping || generation !== this.watchGeneration)
                     return;
                 // SDK 2 deliberately hides transport status behind its typed stream.
                 // Do not parse error prose to rediscover it: every failure follows the

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). */
@@ -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 });
@@ -546,6 +560,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     let ownerBinder;
     let loopManager;
     let arbiter;
+    let recoveryController;
     let reloadLoopConfig;
     let loopGeneration = JSON.stringify((role.loops ?? []).map(loop => [
         loop.name, loop.definitionHash, loop.promptHash,
@@ -782,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})`);
@@ -842,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.
@@ -852,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;
@@ -901,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 } : {}),
@@ -977,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 = {
@@ -1070,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;
@@ -1081,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),
         });
@@ -1095,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

package/dist/temp-lifecycle.d.ts

@@ -5,7 +5,7 @@ export declare const TEMP_STOP_REQUEST_FILE = ".temp-stop-request.json";
 export declare const TEMP_RECLAIM_BATCH = 32;
 export declare const TEMP_LAUNCH_GRACE_MS = 60000;
 export type TempSupervisorKind = 'systemd-transient' | 'launchd-transient' | 'detached';
-export type TempTerminationReason = 'identity-closed' | 'session-ended' | 'operator-stop' | 'supervisor-signal' | 'startup-failure' | 'stale-supervisor';
+export type TempTerminationReason = 'identity-closed' | 'session-ended' | 'operator-stop' | 'supervisor-signal' | 'supervisor-recycle' | 'startup-failure' | 'stale-supervisor';
 export interface TempSupervisorRecord {
     version: 1;
     role: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.1.0-nightly.6",
+  "version": "1.1.0-nightly.7",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",