maka-agent 0.2.0-dev.46.20260922 → 0.2.0-dev.48.20260923

package/node_modules/@maka/runtime/dist/session-manager.js

@@ -36,7 +36,7 @@ import { readLogicalRuntimeExecutionForRun } from '@maka/core/runtime-logical-ex
 import { buildInvocationOpenedEvent, isSessionInlineInvocation, runtimeInvocationOutcome, } from '@maka/core/runtime-invocation';
 import { isArtifactChildResultOutput } from '@maka/core/artifacts';
 import { invocationMatchesClaimTarget } from '@maka/core/runtime-boundary';
-import { readRunInvocation, } from '@maka/core/runtime-event-store';
+import { readRunInvocation, runtimeInvocationRecoveryInventoryFromInvocations, } from '@maka/core/runtime-event-store';
 import { AGENT_GRAPH_OPERATOR_PROVISION_SCHEMA_VERSION } from '@maka/core/agent-graph-topology';
 import { runtimeInvocationFailureClass, } from './runtime-event-read-model.js';
 import { RuntimeReadModel, RuntimeReadModelError, } from './runtime-read-model.js';
@@ -381,6 +381,8 @@ export class SessionManager {
             if (current.revision !== input.expectedRevision) {
                 throw new SessionConfigurationRevisionConflictError(input.expectedRevision, current.revision);
             }
+            if (current.header.executorId)
+                throw new SessionConfigurationTransitionError('operation_unavailable', 'External executor workspace is fixed. Start a new task.');
             if (current.header.isArchived) {
                 throw new SessionConfigurationTransitionError('operation_conflict', 'Archived Session workspace cannot be relocated');
             }
@@ -547,15 +549,63 @@ export class SessionManager {
     async recoverInterruptedSessions() {
         return this.recoverInterruptedSessionsWithPolicy({ kind: 'best_effort' });
     }
+    /**
+     * Recover only the Sessions named by an already-held quiescent operation.
+     *
+     * Bundle export uses this after fencing a Session subtree. A persisted open
+     * invocation can survive a Host restart even though no live execution claim
+     * remains; settling that invocation is safe under the fence and lets export
+     * distinguish an interrupted run from a live one without scanning or
+     * mutating unrelated Sessions.
+     */
+    async recoverInterruptedSessionsForSessions(sessionIds) {
+        const scope = new Set(sessionIds);
+        return this.recoverInterruptedSessionsWithPolicy({ kind: 'best_effort' }, scope);
+    }
     async recoverInterruptedSessionsStrict(stores) {
         if (stores.sessionStore !== this.deps.store || stores.agentRunStore !== this.deps.runStore) {
             throw new Error('Strict recovery stores must match the SessionManager composition');
         }
         return this.recoverInterruptedSessionsWithPolicy({ kind: 'strict', stores });
     }
-    async recoverInterruptedSessionsWithPolicy(policy) {
-        const interrupted = (await listSessionsForRecovery(this.deps.store, policy)).filter((session) => !session.isArchived);
+    async recoverInterruptedSessionsWithPolicy(policy, scope) {
+        const profileEnabled = process.env.MAKA_STARTUP_PROFILE === '1';
+        const profileTotals = new Map();
+        const profileCalls = new Map();
+        const measure = async (label, operation) => {
+            if (!profileEnabled)
+                return operation();
+            const started = performance.now();
+            try {
+                return await operation();
+            }
+            finally {
+                profileTotals.set(label, (profileTotals.get(label) ?? 0) + performance.now() - started);
+                profileCalls.set(label, (profileCalls.get(label) ?? 0) + 1);
+            }
+        };
+        const interrupted = (await measure('list-sessions', () => listSessionsForRecovery(this.deps.store, policy))).filter((session) => !session.isArchived && (scope === undefined || scope.has(session.id)));
+        const recoveryCandidateSet = async (label, operation) => {
+            if (!operation)
+                return undefined;
+            const sessionIds = await measure(label, () => recoverOr(policy, operation, undefined));
+            return sessionIds ? new Set(sessionIds) : undefined;
+        };
+        const continuationAuthority = runtimeContinuationAuthority(this.deps.runtimeEventStore);
+        const [shellRecoverySessions, unsettledContinuationClaims, planRecoverySessions] = await Promise.all([
+            recoveryCandidateSet('shell-inventory', this.deps.shellRuns ? () => this.deps.shellRuns.listRecoverySessionIds() : undefined),
+            continuationAuthority?.listUnsettledContinuationClaimsForRecovery
+                ? measure('continuation-inventory', () => recoverOr(policy, () => continuationAuthority.listUnsettledContinuationClaimsForRecovery(interrupted.map((session) => session.id)), undefined))
+                : Promise.resolve(undefined),
+            recoveryCandidateSet('plan-inventory', this.deps.planStore?.listPlanRecoverySessionIds
+                ? () => this.deps.planStore.listPlanRecoverySessionIds()
+                : undefined),
+        ]);
+        const continuationClaimsBySession = unsettledContinuationClaims
+            ? groupContinuationClaimsBySession(unsettledContinuationClaims)
+            : undefined;
         const recovered = new Set();
+        const runRecoveryQueue = [];
         for (const session of interrupted) {
             if (this.runtimeKernel.hasActiveRuns(session.id))
                 continue;
@@ -576,8 +626,9 @@ export class SessionManager {
                     }), undefined);
                 }
             }
-            if (this.deps.shellRuns) {
-                const recoveredShellRuns = await recoverOr(policy, () => this.deps.shellRuns.recoverOrphanedSession(session.id), 0);
+            if (this.deps.shellRuns &&
+                (!shellRecoverySessions || shellRecoverySessions.has(session.id))) {
+                const recoveredShellRuns = await measure('shell', () => recoverOr(policy, () => this.deps.shellRuns.recoverOrphanedSession(session.id), 0));
                 if (recoveredShellRuns > 0)
                     recovered.add(session.id);
             }
@@ -586,10 +637,13 @@ export class SessionManager {
             // recovery. Deciding it a second time here — off a transcript scan, and
             // ending in `remove()` — could only ever contradict it.
             let continuationClaimRecovered = false;
-            const continuationAuthority = runtimeContinuationAuthority(this.deps.runtimeEventStore);
-            if (this.deps.runStore && continuationAuthority) {
+            const unsettledClaims = continuationClaimsBySession?.get(session.id);
+            if (this.deps.runStore &&
+                continuationAuthority &&
+                (!continuationClaimsBySession ||
+                    unsettledClaims?.some((state) => state.startEventId === undefined || state.startKind === 'claim_repair'))) {
                 try {
-                    continuationClaimRecovered = await this.recoverContinuationClaimsBeforeProvider(session.id, continuationAuthority, policy);
+                    continuationClaimRecovered = await measure('continuation', () => this.recoverContinuationClaimsBeforeProvider(session.id, continuationAuthority, policy, unsettledClaims));
                 }
                 catch (error) {
                     if (policy.kind === 'strict')
@@ -603,26 +657,62 @@ export class SessionManager {
                 if (continuationClaimRecovered)
                     recovered.add(session.id);
             }
-            if (this.deps.planStore) {
-                const preservesHandoff = await recoverOr(policy, async () => {
-                    if (!continuationAuthority)
-                        return false;
-                    const latest = latestInvocation((await this.listInvocations(session.id)).filter((run) => isSessionInlineInvocation(run.opening)));
-                    if (!latest)
-                        return false;
-                    // Only the current logical execution may preserve a session-owned Plan.
-                    // Read after claim repair: an abandoned successor now has a real failure.
-                    return Boolean((await readLogicalRuntimeExecutionForRun(continuationAuthority, latest))
-                        ?.pendingHandoff);
-                }, false);
-                if (!preservesHandoff) {
-                    const planRecovery = await recoverOr(policy, () => this.deps.planStore.interruptActiveExecution(session.id, 'runtime_recovery'), null);
-                    if (planRecovery)
-                        recovered.add(session.id);
+            if (this.deps.planStore && (!planRecoverySessions || planRecoverySessions.has(session.id))) {
+                // Plan events are the domain authority for whether there is a Plan
+                // obligation at all. Runtime evidence is needed only to decide whether
+                // an existing active Plan belongs to a pending handoff and must survive.
+                const planState = await measure('plan-state', () => recoverOr(policy, () => this.deps.planStore.readState(session.id), undefined));
+                if (planState?.activeExecutionId) {
+                    const preservesHandoff = await measure('plan-handoff', () => recoverOr(policy, async () => {
+                        if (!continuationAuthority)
+                            return false;
+                        const latest = latestInvocation((await this.listInvocations(session.id)).filter((run) => isSessionInlineInvocation(run.opening)));
+                        if (!latest)
+                            return false;
+                        // Only the current logical execution may preserve a session-owned Plan.
+                        // Read after claim repair: an abandoned successor now has a real failure.
+                        return Boolean((await readLogicalRuntimeExecutionForRun(continuationAuthority, latest))
+                            ?.pendingHandoff);
+                    }, false));
+                    if (!preservesHandoff) {
+                        const planRecovery = await measure('plan-interrupt', () => recoverOr(policy, () => this.deps.planStore.interruptActiveExecution(session.id, 'runtime_recovery'), null));
+                        if (planRecovery)
+                            recovered.add(session.id);
+                    }
+                }
+            }
+            runRecoveryQueue.push({
+                session,
+                continuationClaimRecovered,
+                ...(continuationClaimsBySession
+                    ? {
+                        claimOwnedUnsettledRunIds: new Set((unsettledClaims ?? []).map((state) => state.claim.target.runId)),
+                    }
+                    : {}),
+            });
+        }
+        let inventoryBySession;
+        if (this.deps.runStore &&
+            this.deps.runtimeEventStore?.listInvocationRecoveryInventory &&
+            runRecoveryQueue.length > 0) {
+            try {
+                const inventory = await measure('run-inventory', () => this.deps.runtimeEventStore.listInvocationRecoveryInventory(runRecoveryQueue.map(({ session }) => session.id)));
+                const mutable = new Map();
+                for (const entry of inventory) {
+                    const entries = mutable.get(entry.sessionId) ?? [];
+                    entries.push(entry);
+                    mutable.set(entry.sessionId, entries);
                 }
+                inventoryBySession = mutable;
+            }
+            catch (error) {
+                if (policy.kind === 'strict')
+                    throw error;
             }
+        }
+        for (const { session, continuationClaimRecovered, claimOwnedUnsettledRunIds, } of runRecoveryQueue) {
             if (this.deps.runStore) {
-                const runRecovery = await recoverOr(policy, () => this.recoverAgentRunsFromLedger(session.id, policy), undefined);
+                const runRecovery = await measure('runs', () => recoverOr(policy, () => this.recoverAgentRunsFromLedger(session.id, policy, inventoryBySession ? (inventoryBySession.get(session.id) ?? []) : undefined, claimOwnedUnsettledRunIds), undefined));
                 if (runRecovery?.hasLedger) {
                     if (runRecovery.recovered || continuationClaimRecovered) {
                         await recoverOr(policy, () => this.updateStatus(session.id, 'active'), undefined);
@@ -646,6 +736,15 @@ export class SessionManager {
                 recovered.add(session.id);
             }
         }
+        if (profileEnabled) {
+            console.error(`[startup-profile] session-recovery ${JSON.stringify({
+                sessions: interrupted.length,
+                totals: Object.fromEntries([...profileTotals].map(([label, ms]) => [
+                    label,
+                    { calls: profileCalls.get(label) ?? 0, ms },
+                ])),
+            })}`);
+        }
         return [...recovered];
     }
     async setSessionStatus(sessionId, status, blockedReason) {
@@ -680,66 +779,6 @@ export class SessionManager {
         await this.deps.store.readHeader(sessionId);
         return this.runtimeKernel.listActiveInteractions?.(sessionId) ?? [];
     }
-    async setPermissionMode(sessionId, mode) {
-        const readHeaderRecordSnapshot = this.deps.store.readHeaderRecordSnapshot?.bind(this.deps.store);
-        if (!readHeaderRecordSnapshot || !this.deps.store.updateSessionConfiguration) {
-            // Temporary compatibility bridge for SessionStore embeddings that predate
-            // versioned configuration authority. A follow-up PR will shortly remove
-            // setPermissionMode and this redundant fallback after callers migrate.
-            return this.setPermissionModeWithLegacyStore(sessionId, mode);
-        }
-        const current = await readHeaderRecordSnapshot(sessionId);
-        const next = await this.transitionSessionConfiguration(sessionId, {
-            expectedRevision: current.revision,
-            clearConnectionBlock: false,
-            permissionModeOnly: true,
-            configuration: sessionConfigurationWithPermissionMode(current.header, mode),
-        });
-        return headerToSummary(next.header);
-    }
-    async setPermissionModeWithLegacyStore(sessionId, mode) {
-        const previous = await this.deps.store.readHeader(sessionId);
-        const boundary = await this.deps.store.readExecutionBoundary(sessionId);
-        if (previous.permissionMode === mode &&
-            executionBoundaryMatchesPermissionMode(boundary, mode)) {
-            return headerToSummary(previous);
-        }
-        const labels = previous.labels;
-        const kind = mode === 'bypass' ? 'bypass' : 'managed';
-        await this.commitExecutionBoundaryTransition(sessionId, boundary, mode, async () => {
-            const current = await this.deps.store.readHeader(sessionId);
-            if (current.status === 'waiting_for_user') {
-                throw new SessionConfigurationTransitionError('session_busy', 'Session has a pending Interaction');
-            }
-            return () => this.deps.store.setExecutionBoundaryKind(sessionId, kind, {
-                permissionMode: mode,
-                labels,
-            });
-        });
-        const next = await this.deps.store.readHeader(sessionId);
-        this.runtimeKernel.updateCachedHeader(sessionId, next);
-        return headerToSummary(next);
-    }
-    async setExecutionBoundaryKind(sessionId, kind) {
-        const current = await this.deps.store.readExecutionBoundary(sessionId);
-        const header = await this.deps.store.readHeader(sessionId);
-        // Managed includes Explore. Match Storage's default projection, then pass
-        // it explicitly so classification and commit describe the same transition.
-        const permissionMode = kind === 'bypass'
-            ? 'bypass'
-            : header.permissionMode === 'bypass'
-                ? 'ask'
-                : header.permissionMode;
-        const narrows = narrowsExecutionAuthority(current, permissionMode);
-        if (narrows && this.runtimeKernel.hasActiveRuns(sessionId)) {
-            throw new SessionConfigurationTransitionError('session_busy', 'Execution boundary cannot change while a Turn is running');
-        }
-        if (header.status === 'waiting_for_user') {
-            throw new SessionConfigurationTransitionError('session_busy', 'Execution boundary cannot change while an Interaction is pending');
-        }
-        const boundary = await this.commitExecutionBoundaryTransition(sessionId, current, permissionMode, async () => () => this.deps.store.setExecutionBoundaryKind(sessionId, kind, { permissionMode }));
-        return boundary;
-    }
     async commitExecutionBoundaryTransition(sessionId, current, nextPermissionMode, prepareCommit) {
         const prepareBoundaryCommit = async () => {
             const latest = await this.deps.store.readExecutionBoundary(sessionId);
@@ -3010,10 +3049,10 @@ export class SessionManager {
      * dead, so that state remains `continuation_started_indeterminate` and is
      * deliberately left non-terminal.
      */
-    async recoverContinuationClaimsBeforeProvider(sessionId, authority, _policy) {
+    async recoverContinuationClaimsBeforeProvider(sessionId, authority, _policy, recoveryStates) {
         if (!this.deps.runStore)
             return false;
-        const states = await authority.listContinuationClaimsForRecovery(sessionId);
+        const states = recoveryStates ?? (await authority.listContinuationClaimsForRecovery(sessionId));
         let recovered = false;
         for (const initialState of states) {
             const { claim } = initialState;
@@ -3084,24 +3123,41 @@ export class SessionManager {
         }
         return recovered;
     }
-    async recoverAgentRunsFromLedger(sessionId, policy = { kind: 'best_effort' }) {
+    async recoverAgentRunsFromLedger(sessionId, policy = { kind: 'best_effort' }, recoveryInventory, recoveryClaimRunIds) {
         if (!this.deps.runStore || !this.deps.runtimeEventStore)
             return { hasLedger: false, recovered: false };
         // The importer may have committed only a prefix before a restart. Sealing
         // that prefix here would make the next read skip the unconverted history.
-        const runs = (await this.listInvocations(sessionId)).filter((run) => !isTranscriptLedgerInvocation(run));
-        if (runs.length === 0)
+        const inventory = recoveryInventory
+            ? recoveryInventory
+            : this.deps.runtimeEventStore.listInvocationRecoveryInventory
+                ? await this.deps.runtimeEventStore.listInvocationRecoveryInventory([sessionId])
+                : runtimeInvocationRecoveryInventoryFromInvocations(await this.listInvocations(sessionId));
+        const ownedInventory = inventory.filter((entry) => {
+            const identity = entry.candidate ?? entry.identity;
+            return !identity || !isTranscriptLedgerInvocation(identity);
+        });
+        if (ownedInventory.length === 0)
             return { hasLedger: false, recovered: false };
+        let claimOwnedUnsettledRunIds = recoveryClaimRunIds;
         const continuationAuthority = runtimeContinuationAuthority(this.deps.runtimeEventStore);
-        const claimOwnedUnsettledRunIds = new Set();
-        if (continuationAuthority) {
+        if (!claimOwnedUnsettledRunIds && continuationAuthority) {
+            const discovered = new Set();
             for (const state of await continuationAuthority.listContinuationClaimsForRecovery(sessionId)) {
                 const events = await continuationAuthority.readImmutableRuntimeEvents(state.claim.target.sessionId, state.claim.target.runId);
-                if (!events.some(isTerminalRuntimeEvent)) {
-                    claimOwnedUnsettledRunIds.add(state.claim.target.runId);
-                }
+                if (!events.some(isTerminalRuntimeEvent))
+                    discovered.add(state.claim.target.runId);
             }
+            claimOwnedUnsettledRunIds = discovered;
         }
+        const runsNeedingRecovery = ownedInventory.flatMap((entry) => entry.candidate ? [entry.candidate] : []);
+        if (runsNeedingRecovery.length === 0)
+            return { hasLedger: true, recovered: false };
+        const recoveryRunStore = policy.kind === 'strict'
+            ? {
+                readEvents: (candidateSessionId, runId) => policy.stores.agentRunStore.readEventsForRecovery(candidateSessionId, runId),
+            }
+            : this.deps.runStore;
         // Read once per recovered session, and only when a failure actually needs
         // attributing, so healthy sessions pay nothing for the query.
         let boundaryClosures;
@@ -3114,11 +3170,14 @@ export class SessionManager {
             return boundaryClosures;
         };
         let recovered = false;
-        for (const run of runs) {
-            if (policy.kind === 'strict') {
-                await policy.stores.agentRunStore.readEventsForRecovery(sessionId, run.runId);
-            }
-            let inspected = await inspectAgentRunReadModel(this.deps.runStore, this.deps.runtimeEventStore, { sessionId, runId: run.runId, invocation: run });
+        for (const run of runsNeedingRecovery) {
+            let inspected = await inspectAgentRunReadModel(recoveryRunStore, this.deps.runtimeEventStore, {
+                sessionId,
+                runId: run.runId,
+                invocation: run,
+                includeModelReplay: false,
+                includeProjection: false,
+            });
             if (inspected.sourceHealth.runtimeLedger === 'read_failed') {
                 if (policy.kind === 'strict') {
                     throw new Error(`RuntimeEvent ledger is unreadable for run ${run.runId}`);
@@ -3138,7 +3197,7 @@ export class SessionManager {
                 // restart repair must neither replay its tools nor manufacture failure.
                 continue;
             }
-            if (claimOwnedUnsettledRunIds.has(run.runId) &&
+            if (claimOwnedUnsettledRunIds?.has(run.runId) &&
                 !inspected.runtimeEvents.some(isTerminalRuntimeEvent)) {
                 // Every unresolved claim target belongs to the claim saga. This
                 // includes claim-only, deterministic repair-start, and live provider
@@ -3163,7 +3222,13 @@ export class SessionManager {
                     continue;
                 }
                 if (interruptedOutcomes.length > 0) {
-                    inspected = await inspectAgentRunReadModel(this.deps.runStore, this.deps.runtimeEventStore, { sessionId, runId: run.runId, invocation: run });
+                    inspected = await inspectAgentRunReadModel(recoveryRunStore, this.deps.runtimeEventStore, {
+                        sessionId,
+                        runId: run.runId,
+                        invocation: run,
+                        includeModelReplay: false,
+                        includeProjection: false,
+                    });
                 }
             }
             const terminalLedger = classifyTerminalRuntimeLedger(run, inspected.runtimeEvents);
@@ -3260,6 +3325,16 @@ function continuationExecutionErrorClass(error) {
     }
     return error instanceof Error ? error.name : 'unknown';
 }
+function groupContinuationClaimsBySession(states) {
+    const grouped = new Map();
+    for (const state of states) {
+        const sessionId = state.claim.target.sessionId;
+        const sessionStates = grouped.get(sessionId) ?? [];
+        sessionStates.push(state);
+        grouped.set(sessionId, sessionStates);
+    }
+    return grouped;
+}
 const MAX_BEST_EFFORT_OUTCOME_COMMIT_ATTEMPTS = 2;
 function listSessionsForRecovery(store, policy) {
     return policy.kind === 'strict' ? policy.stores.sessionStore.listForRecovery() : store.list();
@@ -3391,7 +3466,12 @@ export function headerToSummary(h) {
         ...(h.revisionIndex !== undefined ? { revisionIndex: h.revisionIndex } : {}),
         ...(h.revisionState ? { revisionState: h.revisionState } : {}),
         backend: h.backend,
-        ...(h.executorId ? { executorId: h.executorId } : {}),
+        ...(h.executorId
+            ? {
+                executorId: h.executorId,
+                ...(h.executorConfig ? { executorConfig: h.executorConfig } : {}),
+            }
+            : {}),
         ...(h.llmConnectionId === undefined ? {} : { llmConnectionId: h.llmConnectionId }),
         llmConnectionSlug: h.llmConnectionSlug,
         connectionLocked: h.connectionLocked,
@@ -3527,23 +3607,10 @@ function claimedAgentGraphIntentResult(claim, result) {
         ...result,
     };
 }
-function sessionConfigurationWithPermissionMode(header, permissionMode) {
-    return {
-        backend: header.backend,
-        executorId: header.executorId,
-        llmConnectionId: header.llmConnectionId,
-        llmConnectionSlug: header.llmConnectionSlug,
-        connectionLocked: header.connectionLocked,
-        model: header.model,
-        thinkingLevel: header.thinkingLevel,
-        permissionMode,
-        collaborationMode: header.collaborationMode ?? 'agent',
-        orchestrationMode: header.orchestrationMode ?? 'default',
-    };
-}
 function sessionConfigurationMatchesExceptPermissionMode(header, configuration) {
     return (header.backend === configuration.backend &&
         header.executorId === configuration.executorId &&
+        header.executorConfig?.model === configuration.executorConfig?.model &&
         header.llmConnectionId === configuration.llmConnectionId &&
         header.llmConnectionSlug === configuration.llmConnectionSlug &&
         header.connectionLocked === configuration.connectionLocked &&
@@ -3556,15 +3623,6 @@ function sessionConfigurationMatches(header, configuration) {
     return (header.permissionMode === configuration.permissionMode &&
         sessionConfigurationMatchesExceptPermissionMode(header, configuration));
 }
-function executionBoundaryMatchesPermissionMode(boundary, mode) {
-    if (mode === 'bypass')
-        return boundary.kind === 'bypass';
-    if (boundary.kind !== 'managed')
-        return false;
-    return mode === 'explore'
-        ? boundary.profile.name === 'read-only'
-        : boundary.profile.name !== 'read-only';
-}
 function narrowsExecutionAuthority(boundary, nextPermissionMode) {
     if (nextPermissionMode === 'bypass')
         return false;

package/node_modules/@maka/runtime/dist/shell-run-manager.js

@@ -424,6 +424,9 @@ export class ShellRunProcessManager {
         const records = await this.input.store.listSessionShellRuns(sessionId);
         return records.map(shellRunUpdate);
     }
+    listRecoverySessionIds() {
+        return this.input.store.listShellRunRecoverySessionIds?.() ?? Promise.resolve(undefined);
+    }
     async getSessionUpdate(sessionId, ref) {
         const target = parseShellRunResourceRef(ref);
         if (!target)

package/node_modules/@maka/runtime/dist/stream-graph-coordinator.js

@@ -324,16 +324,41 @@ export class AgentGraphCoordinator {
      */
     async recover() {
         const recovered = [];
+        const listedRecoveryGraphIds = this.#input.controlStore.listAgentGraphScheduleRecoveryGraphIds
+            ? await this.#input.controlStore.listAgentGraphScheduleRecoveryGraphIds()
+            : undefined;
+        const recoveryGraphIds = listedRecoveryGraphIds ? new Set(listedRecoveryGraphIds) : undefined;
+        if (recoveryGraphIds?.size === 0)
+            return recovered;
+        const recoveryRootSessionIds = new Set();
+        if (recoveryGraphIds && this.#input.epochStore) {
+            for (const graphId of recoveryGraphIds) {
+                const binding = await this.#input.epochStore.readAgentGraphEpochByGraphId(graphId);
+                if (binding)
+                    recoveryRootSessionIds.add(binding.rootSessionId);
+            }
+        }
         for (const header of await this.#input.sessionStore.listForRecovery()) {
             if (this.#input.rootSessionId && header.id !== this.#input.rootSessionId)
                 continue;
             if (header.subagentParent || header.isArchived)
                 continue;
-            const graphId = await this.currentGraphId(header.id);
-            const updates = await this.#input.controlStore.listAgentGraphScheduleUpdates(graphId);
-            if (updates.length === 0)
+            if (recoveryGraphIds &&
+                !recoveryGraphIds.has(agentGraphIdForRootSession(header.id)) &&
+                !recoveryRootSessionIds.has(header.id)) {
                 continue;
-            updates.forEach((update) => this.#assertScheduleOwnedByRoot(update, header.id, graphId));
+            }
+            const graphId = await this.currentGraphId(header.id);
+            if (recoveryGraphIds) {
+                if (!recoveryGraphIds.has(graphId))
+                    continue;
+            }
+            else {
+                const updates = await this.#input.controlStore.listAgentGraphScheduleUpdates(graphId);
+                if (updates.length === 0)
+                    continue;
+                updates.forEach((update) => this.#assertScheduleOwnedByRoot(update, header.id, graphId));
+            }
             await this.reconcile(header.id);
             recovered.push(header.id);
         }

package/node_modules/@maka/runtime-host/dist/candidate-entry.js

@@ -21,7 +21,6 @@ import { fileURLToPath } from 'node:url';
 import { candidateStartupFailureExitCode, classifyCandidateStartupFailure, } from './candidate-startup-failure.js';
 import { createRuntimeHostLaunchOwnerGuard } from './candidate-launch-owner-guard.js';
 import { parseInteractiveRuntimeHostCandidateArguments } from './candidate-cli.js';
-import { writeCandidateStartupDiagnostic } from './control/startup-diagnostic.js';
 import { installRuntimeHostLogCapture, runtimeHostLogBuffer } from './process-diagnostics.js';
 import { startExecutionRuntimeHostCandidate, } from './server/execution-candidate.js';
 import { runRuntimeHostProcessLifecycle } from './server/process-lifecycle.js';
@@ -60,13 +59,17 @@ export async function runExecutionCandidateEntry(argv, entrypointUrl, hooks = {}
         const logs = runtimeHostLogBuffer.snapshot();
         console.error('[runtime-host] startup failed:', error);
         if (rootId && startupAttemptId) {
-            await writeCandidateStartupDiagnostic({
-                rootId,
-                startupAttemptId,
+            const diagnosticRootId = rootId;
+            const diagnosticStartupAttemptId = startupAttemptId;
+            await import('./control/startup-diagnostic.js')
+                .then(({ writeCandidateStartupDiagnostic }) => writeCandidateStartupDiagnostic({
+                rootId: diagnosticRootId,
+                startupAttemptId: diagnosticStartupAttemptId,
                 failure,
                 error,
                 logs,
-            }).catch(() => undefined);
+            }))
+                .catch(() => undefined);
         }
         process.exit(candidateStartupFailureExitCode(failure));
     }

package/node_modules/@maka/runtime-host/dist/client/capability-provider-service.js

@@ -140,12 +140,14 @@ function snapshotProvider(provider) {
     const call = provider.call?.bind(provider);
     const callService = provider.callService?.bind(provider);
     const close = provider.close?.bind(provider);
+    const currentRegistrationRetired = provider.currentRegistrationRetired?.bind(provider);
     return {
         offers: () => canonical.offers,
         ...(canonical.services === undefined ? {} : { services: () => canonical.services ?? [] }),
         ...(call ? { call } : {}),
         ...(callService ? { callService } : {}),
         ...(close ? { close } : {}),
+        ...(currentRegistrationRetired ? { currentRegistrationRetired } : {}),
     };
 }
 async function closeProvider(provider) {