@agents-ensemble/core 0.20.0 → 0.22.0

package/dist/conductor/conductor-session.js

@@ -1,3 +1,5 @@
+import { stat } from 'node:fs/promises';
+import { resolve as resolvePath } from 'node:path';
 import { computeAcpModelConfigDigest, computeEnsembleConfigDigest, computeResumeFeasibilityConfigDigest, } from '../config/ensemble-config-digest.js';
 import { loadEnsembleConfig } from '../config/load-ensemble-config.js';
 import { computeMcpConfigDigest, resolveMcpServers, } from '../mcp/load-mcp-config.js';
@@ -12,6 +14,7 @@ import { createPermissionDeadlockMonitor, } from '../permission/permission-deadl
 import { createResolvePermissionTool } from '../permission/resolve-permission-tool.js';
 import { buildPermissionBrief, getPermissionToolCallId, } from '../permission/permission-brief.js';
 import { acpSpawnFingerprint, resolveWorkerAcpSpawn, resolvedAcpSpawnToOptions, } from '../acp/resolve-acp-spawn.js';
+import { configurePiWorkerRuntime } from '../acp/pi-runtime.js';
 import { finalizeResolvedAcpSpawn, validateWorkerAcpPrerequisites, } from '../acp/validate-acp-preset-prerequisites.js';
 import { profileWorkersToSessionSpecs, sessionStateFromProfile, resolveAgentPromptModule, } from '../profile/types.js';
 import { WorkerSession } from '../runtime/worker-session.js';
@@ -31,25 +34,31 @@ import { createConductorAgentFactory } from './conductor-agent-factory.js';
 import { resolveConductorReasoning } from './resolve-conductor-reasoning.js';
 import { formatConductorAuthRecoveryHint, isConductorSendAuthError, } from './conductor-auth.js';
 import { resolvePiConductorProvider } from './conductor-pi-auth.js';
+import { closeConductorAgentOnce } from './conductor-send-reconnect.js';
+import { escapeTerminalControlCharacters } from '../representation/escape-terminal-control-characters.js';
+import { cursorBootstrapCompleteForStore } from './cursor-bootstrap-state.js';
 import { SessionLogger } from './session/session-logger.js';
 import { SessionEventQueue } from './session/session-event-queue.js';
 import { bufferDispatchHoldEvents, createDispatchHoldState, pruneStalePermissionEvents, } from './session/dispatch-hold.js';
 import { createDispatchHoldReminderMonitor, formatDispatchHoldReminderMessage, } from './session/dispatch-hold-reminder-monitor.js';
 import { operatorInputMaxTurns, resolveMaxTurns, } from './session-policy.js';
-import { runConductorSessionDriver } from './conductor-session-driver.js';
+import { runConductorSessionDriver, } from './conductor-session-driver.js';
 import { isOperatorExitCommand } from './operator-exit.js';
 import { isOperatorCloseCommand } from './operator-close.js';
 import { isOperatorReconnectCommand } from './operator-reconnect.js';
 import { parseOperatorMessageDelivery } from './operator-command.js';
-import { assertSessionResumeStoreMatches, requireLocatedSessionResumeStoreForResume, saveSessionResumeStore, SESSION_RESUME_STORE_VERSION, sessionResumeStorePath, } from '../session/session-resume-store.js';
+import { assertSessionResumeStoreMatches, canonicalSessionResumeStorePath, requireLocatedSessionResumeStoreForResume, saveSessionResumeStore, SESSION_RESUME_STORE_VERSION, } from '../session/session-resume-store.js';
 import { buildSessionModelsSummary, } from '../session/build-session-models-summary.js';
-import { saveSessionStatusLine, sessionStateStorePath, loadSessionStateStore, legacySessionStateStorePath, } from '../session/session-state-store.js';
+import { saveSessionStatusLine, sessionStateStorePath, loadSessionStateStore, } from '../session/session-state-store.js';
 import { loadToolCallSnapshotHistory, pruneExpiredToolCallSnapshotHistoryFiles, saveToolCallSnapshotHistory, toolCallSnapshotHistoryPath, } from '../session/tool-call-snapshot-history.js';
-import { loadOpenQuestionsStore, legacyOpenQuestionsStorePath, openQuestionsStorePath, saveOpenQuestionsStore, } from '../session/open-questions-store.js';
+import { loadOpenQuestionsStore, openQuestionsStorePath, saveOpenQuestionsStore, } from '../session/open-questions-store.js';
+import { sessionSnapshotPaths } from '../session/session-snapshot-paths.js';
 import { CONDUCTOR_MESSAGE_HISTORY_MAX_ENTRIES, OpenQuestionControlOperationError, startOpenQuestionControlServer, } from '../session/open-question-control.js';
 import { formatPermissionSummaryForOperator } from '../permission/format-permission-summary-for-operator.js';
 import { enrichSessionUsageWithCost } from '../usage/enrich-session-usage-cost.js';
 import { SessionUsageTracker } from '../usage/session-usage-tracker.js';
+import { ConductorDispatchLifecycle } from './conductor-dispatch-lifecycle.js';
+import { ConductorRecoveryInbox } from './conductor-recovery-inbox.js';
 import { enqueueOperatorMessage as enqueueOperatorMessageEvent, submitOperatorInput, } from './submit-operator-input.js';
 import { createGitHubMonitor, } from '../github/github-monitor.js';
 import { resolveConductorBackendSetting, resolveConductorPiResourcePaths, resolveGitHubMonitorEnabled, } from '../config/resolve-settings.js';
@@ -63,7 +72,6 @@ import { createRegisterGitHubWatchTool } from '../github/register-github-watch-t
 import { createUnregisterGitHubWatchTool } from '../github/unregister-github-watch-tool.js';
 import { compileConductorSystemPrompt } from '../prompt/compile-system-prompt.js';
 import { loadUserInstructions } from '../prompt/load-user-instructions.js';
-import { resolveEnsemblePaths } from '../ensemble-paths.js';
 const OPEN_QUESTION_CONTROL_DRAIN_TIMEOUT_MS = 5_000;
 const RECORDED_ANSWER_UNKNOWN_DISPATCH = {
     outcome: 'unknown',
@@ -168,7 +176,7 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
         });
     });
     attachLegacySessionCallbacks(sessionLogger, options);
-    const expiredHistory = await pruneExpiredToolCallSnapshotHistoryFiles(options.repoRoot);
+    const expiredHistory = await pruneExpiredToolCallSnapshotHistoryFiles({ repoRoot: options.repoRoot, issueUrl: options.issueUrl });
     if (expiredHistory.failedCount > 0) {
         sessionLogger.emit({
             type: 'harness.warning',
@@ -185,6 +193,16 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
     let lastConductorMessage = null;
     const conductorMessages = [];
     const eventQueue = new SessionEventQueue();
+    const resumeNoticeDetails = new Set();
+    const reportResumeNotice = (message) => {
+        if (resumeNoticeDetails.has(message))
+            return;
+        resumeNoticeDetails.add(message);
+        sessionLogger.emit({ type: 'harness.warning', message });
+    };
+    const recoveryInbox = new ConductorRecoveryInbox();
+    const dispatchLifecycle = new ConductorDispatchLifecycle();
+    startupCleanup.add(() => recoveryInbox.dispose());
     const openQuestionDispatchReceipts = new WeakMap();
     const pendingOpenQuestionDispatchReceipts = new Set();
     const dispatchHoldState = createDispatchHoldState();
@@ -207,11 +225,13 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
     let githubMonitorCursor;
     let githubMonitor;
     let activeResumeStorePath;
-    let activeStoreLocation = 'user-path-hash';
+    let activeLocatedResumeStore;
+    let createdHarnessCliVersion = options.cliPackageVersion;
     let drainStartupResumeStoreWrites = async () => { };
     const pendingGitHubRecoveries = [];
     const conductorCwd = options.conductorCwd ?? process.cwd();
     let cursorBootstrapRunId;
+    const cursorBootstrapState = conductorBackend === 'cursor' ? { status: 'incomplete' } : undefined;
     const mcpServers = await resolveMcpServers(options.repoRoot, options.mcpConfigOptions);
     const mcpConfigDigest = computeMcpConfigDigest(mcpServers);
     const mcpConfigConfigured = Object.keys(mcpServers).length > 0;
@@ -221,10 +241,13 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
         const locatedResumeStore = await requireLocatedSessionResumeStoreForResume({
             repoRoot: options.repoRoot,
             conductorAgentId: options.resumeAgentId,
+            issueUrl: options.issueUrl,
         });
         const loadedResumeStore = locatedResumeStore.resumeStore;
+        activeLocatedResumeStore = locatedResumeStore;
+        // A resume keeps its origin version; a legacy store stays without one.
+        createdHarnessCliVersion = loadedResumeStore.createdHarnessCliVersion;
         activeResumeStorePath = locatedResumeStore.path;
-        activeStoreLocation = locatedResumeStore.location;
         const savedConfigDigestScheme = loadedResumeStore.ensembleConfigDigestScheme;
         const effectiveConfigDigestScheme = savedConfigDigestScheme ?? 'full';
         const currentEnsembleConfigDigest = effectiveConfigDigestScheme === 'resume-feasibility'
@@ -233,17 +256,39 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
         assertSessionResumeStoreMatches(loadedResumeStore, {
             conductorAgentId: options.resumeAgentId,
             issueUrl: options.issueUrl,
-            repoRoot: options.repoRoot,
-            conductorBackend,
-            mcpConfigDigest,
-            mcpConfigConfigured,
-            ensembleConfigDigest: currentEnsembleConfigDigest,
         });
-        if (loadedResumeStore.ensembleConfigDigest === undefined) {
-            sessionLogger.emit({
-                type: 'harness.warning',
-                message: 'SessionResumeStore has no ensemble config digest; config consistency cannot be verified for this legacy session.',
-            });
+        if (resolvePath(loadedResumeStore.repoRoot) !== resolvePath(options.repoRoot)) {
+            reportResumeNotice(`保存時の repoRoot ${loadedResumeStore.repoRoot} と現在の repoRoot ${options.repoRoot} が異なります。現在の clone を使って再開します。Store に commit SHA がないため、保存時 clone にだけある local commit / 未コミット変更は照合・復元できません。`);
+            if (!(await pathExists(loadedResumeStore.repoRoot))) {
+                reportResumeNotice(`保存時の clone ${loadedResumeStore.repoRoot} は現在参照できません。そこにだけあった未コミット変更は復元できず、Store に commit SHA がないため欠落した commit の有無も照合できません。`);
+            }
+        }
+        if (loadedResumeStore.conductorCwd !== undefined &&
+            resolvePath(loadedResumeStore.conductorCwd) !== resolvePath(conductorCwd)) {
+            reportResumeNotice(`保存時の conductor cwd ${loadedResumeStore.conductorCwd} は現在の cwd ${conductorCwd} とは異なります。現在の cwd で backend resume を試みます。以前の cwd にだけある local state は引き継がれず、Store に commit SHA がないため commit の差も照合できません。`);
+            if (!(await pathExists(loadedResumeStore.conductorCwd))) {
+                reportResumeNotice(`保存時の conductor cwd ${loadedResumeStore.conductorCwd} は見つからないため、以前の workspace のローカル状態は復元できません。`);
+            }
+        }
+        const savedBackend = loadedResumeStore.conductorBackend ?? 'cursor';
+        if (savedBackend !== conductorBackend) {
+            reportResumeNotice(`保存時の conductor backend は ${savedBackend}、現在の設定は ${conductorBackend} です。現在の backend で復元を試みます。復元できなければ session は失敗として扱います。`);
+        }
+        if (loadedResumeStore.ensembleConfigDigest !== undefined &&
+            loadedResumeStore.ensembleConfigDigest !== currentEnsembleConfigDigest) {
+            reportResumeNotice('保存時と現在の Ensemble config が異なります。保存時の設定には戻さず、現在の clone の config で復元を試みます。');
+        }
+        else if (loadedResumeStore.ensembleConfigDigest === undefined) {
+            reportResumeNotice('SessionResumeStore に config digest がないため差分を比較できません。現在の clone の config で復元します。');
+        }
+        if (loadedResumeStore.mcpConfigDigest === undefined
+            ? mcpConfigConfigured
+            : loadedResumeStore.mcpConfigDigest !== mcpConfigDigest) {
+            reportResumeNotice('保存時と現在の MCP config が異なるか、保存時の digest がありません。現在の clone の MCP config を使って復元を試みます。');
+        }
+        if (JSON.stringify(loadedResumeStore.profile) !==
+            JSON.stringify(options.profile)) {
+            reportResumeNotice('保存時の team profile と現在の clone で解決した profile が異なります。以降は現在の profile を使います。');
         }
         const hasComparableLegacyFullDigest = effectiveConfigDigestScheme === 'full' &&
             loadedResumeStore.ensembleConfigDigest !== undefined;
@@ -270,6 +315,35 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
         // acquired resource is released successfully; otherwise keep this record
         // marked unknown/running so it does not claim a possibly active session is
         // closed.
+        cursorBootstrapRunId = loadedResumeStore.cursorBootstrapRunId;
+        if (cursorBootstrapState) {
+            const savedBootstrapComplete = loadedResumeStore.cursorBootstrapComplete;
+            cursorBootstrapState.status =
+                savedBootstrapComplete === undefined
+                    ? 'unknown'
+                    : savedBootstrapComplete
+                        ? 'complete'
+                        : 'incomplete';
+            if (cursorBootstrapState.status === 'unknown') {
+                if (options.operatorCanInspectRecovery !== true ||
+                    !options.bindOperatorInput) {
+                    throw new Error([
+                        '旧 Cursor session の SessionResumeStore に bootstrap 状態がなく、compiled prompt が provider に届いたか判定できません。',
+                        '安全のため backend resume と event dispatch は開始しませんでした。',
+                        'stdin / stdout / stderr がすべて対話 TTY の環境で `--continue` し、`/recovery bootstrap assume-complete` または `/recovery bootstrap assume-incomplete` を明示してください。',
+                        'complete は prompt を再送せず、incomplete は次の新しい event に prompt を添えます。どちらも失敗 input や旧 queue は再送しません。',
+                    ].join('\n'));
+                }
+                sessionLogger.emit({
+                    type: 'harness.warning',
+                    message: [
+                        '旧 Cursor session の SessionResumeStore に bootstrap 状態がなく、compiled prompt が provider に届いたか判定できません。',
+                        'operator が `/recovery bootstrap assume-complete` または `/recovery bootstrap assume-incomplete` を選んで判断を保存するまで、すべての event dispatch を停止します。',
+                        'どちらの選択も失敗 input や旧 queue を復元・再送しません。',
+                    ].join(' '),
+                });
+            }
+        }
         const resumeStore = {
             ...loadedResumeStore,
             lifecycle: 'unknown',
@@ -278,7 +352,6 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
             harnessSocketPath: undefined,
             updatedAt: Date.now(),
         };
-        cursorBootstrapRunId = loadedResumeStore.cursorBootstrapRunId;
         harnessPhase = 'running';
         harnessModifiedAt = resumeStore.modifiedAt;
         let resumeStoreActivationCommitted = false;
@@ -300,6 +373,7 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
         const history = await loadToolCallSnapshotHistory({
             repoRoot: options.repoRoot,
             conductorAgentId: options.resumeAgentId,
+            issueUrl: options.issueUrl,
         });
         resumeToolCallSnapshots = history.entries;
         toolCallHistoryNeedsRewrite = history.needsRewrite;
@@ -309,47 +383,8 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
                 message: `${history.warning}; the session will continue without affected history`,
             });
         }
-        const openQuestionsPath = openQuestionsStorePath({
-            repoRoot: options.repoRoot,
-            conductorAgentId: options.resumeAgentId,
-            issueUrl: options.issueUrl,
-            location: activeStoreLocation,
-        });
+        const openQuestionsPath = sessionSnapshotPaths(options.repoRoot, locatedResumeStore, 'open-questions')[0];
         let openQuestionsSnapshot = await loadOpenQuestionsStore(openQuestionsPath);
-        if (!openQuestionsSnapshot) {
-            const fallbackPaths = [
-                ...(activeStoreLocation === 'canonical-slug'
-                    ? [
-                        openQuestionsStorePath({
-                            repoRoot: options.repoRoot,
-                            conductorAgentId: options.resumeAgentId,
-                            location: 'user-path-hash',
-                        }),
-                    ]
-                    : []),
-                legacyOpenQuestionsStorePath({
-                    repoRoot: options.repoRoot,
-                    conductorAgentId: options.resumeAgentId,
-                }),
-            ];
-            for (const fallbackPath of fallbackPaths) {
-                openQuestionsSnapshot = await loadOpenQuestionsStore(fallbackPath);
-                if (openQuestionsSnapshot)
-                    break;
-            }
-            if (openQuestionsSnapshot) {
-                try {
-                    await saveOpenQuestionsStore(openQuestionsPath, openQuestionsSnapshot);
-                }
-                catch (error) {
-                    const detail = error instanceof Error ? error.message : String(error);
-                    sessionLogger.emit({
-                        type: 'harness.warning',
-                        message: `旧保存先の open question を user 保存先へ移行できませんでした。今回のセッションでは旧 YAML を読み込みます。 error=${detail}`,
-                    });
-                }
-            }
-        }
         if (openQuestionsSnapshot) {
             openQuestions.restore(openQuestionsSnapshot);
         }
@@ -370,9 +405,6 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
                 });
             }
         }
-        activeProfile = resumeStore.profile;
-        // ResumeStores written before this setting always started every worker eagerly.
-        activeLazyWorkers = resumeStore.lazyWorkers ?? false;
         githubMonitorCursor = resumeStore.githubMonitor;
         for (const [name, worker] of Object.entries(resumeStore.workers)) {
             workerSessions.set(name, {
@@ -499,23 +531,70 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
             });
         },
     };
+    const piAgentDir = resolveConductorPiResourcePaths({
+        repoRoot: options.repoRoot,
+        config: ensembleConfig,
+    }).agentDir;
     const workers = profileWorkersToSessionSpecs(activeProfile, {
         defaultAcp: options.defaultAcp,
         spawnBase,
+        repoRoot: options.repoRoot,
+        issueNumber: issue.number,
+        ...(piAgentDir ? { piAgentDir } : {}),
+        onWarning: (message) => sessionLogger.emit({ type: 'harness.warning', message }),
     });
     if (workers.length > 0) {
         validateWorkerAcpPrerequisites(workers.map((worker) => resolveWorkerAcpSpawn({
             defaultOptions: options.defaultAcp,
             modelTag: worker.modelTag,
         })));
-        finalizeSessionWorkerSpecs(workers, options.defaultAcp);
+        finalizeSessionWorkerSpecs(workers, options.repoRoot, issue.number, options.defaultAcp, piAgentDir);
     }
     const workerAcpFingerprints = new Map(workers.map((worker) => [worker.name, worker.acpFingerprint]));
     let teardownStarted = false;
     const workerWorktree = options.workerWorktree ??
         (workers.length > 0
-            ? await resolveWorkerWorkspace(options.repoRoot, issue, options.workerWorktreeMode ?? 'isolated')
+            ? await resolveWorkerWorkspace(options.repoRoot, issue, options.workerWorktreeMode ?? 'isolated', {
+                resume: Boolean(options.resumeAgentId),
+                onNotice: reportResumeNotice,
+            })
             : undefined);
+    if (options.resumeAgentId) {
+        const currentWorkers = new Map(workers.map((worker) => [worker.name, worker]));
+        for (const [name, savedWorker] of workerSessions) {
+            if (!currentWorkers.has(name)) {
+                reportResumeNotice(`保存 session に worker「${name}」がありますが、現在の profile には定義がありません。この worker session は復元対象から外れます。`);
+                continue;
+            }
+            const currentWorker = currentWorkers.get(name);
+            const savedAcpSpawn = savedWorker.acpSpawn;
+            const currentAcpSpawn = currentWorker.acpFingerprint;
+            if (savedAcpSpawn &&
+                currentAcpSpawn &&
+                (savedAcpSpawn.preset !== currentAcpSpawn.preset ||
+                    (savedAcpSpawn.preset === 'pi' &&
+                        currentAcpSpawn.preset === 'pi' &&
+                        (savedAcpSpawn.piRuntime ?? 'byo') !==
+                            (currentAcpSpawn.piRuntime ?? 'byo')) ||
+                    (savedAcpSpawn.preset === 'custom' &&
+                        currentAcpSpawn.preset === 'custom' &&
+                        (savedAcpSpawn.command !== currentAcpSpawn.command ||
+                            JSON.stringify(savedAcpSpawn.args) !==
+                                JSON.stringify(currentAcpSpawn.args))))) {
+                reportResumeNotice(`worker「${name}」の保存時 ACP preset/runtime と現在の設定が異なります。現在の設定で ACP session/load を試みます。`);
+            }
+            if (!savedWorker.acpCwd)
+                continue;
+            const currentCwd = currentWorker.resolvedWorkspacePath ?? workerWorktree?.path;
+            if (currentCwd &&
+                resolvePath(savedWorker.acpCwd) !== resolvePath(currentCwd)) {
+                reportResumeNotice(`worker「${name}」の保存時 ACP cwd ${savedWorker.acpCwd} と現在の workspace ${currentCwd} が異なります。現在の workspace で ACP session/load を試みます。以前の cwd にだけある local changes はコピーされず、Store に commit SHA がないため commit の差も照合できません。`);
+                if (!(await pathExists(savedWorker.acpCwd))) {
+                    reportResumeNotice(`worker「${name}」の保存時 ACP cwd ${savedWorker.acpCwd} は見つかりません。そこにだけあった未コミット変更は復元できず、保存 Store に commit SHA がないため欠落 commit の有無も照合できません。`);
+                }
+            }
+        }
+    }
     if (workerWorktree) {
         sessionLogger.emit({
             type: 'harness.worktree',
@@ -627,6 +706,34 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
             eventQueue.enqueue({ type: 'worker.completed', result });
             scheduleSessionResumeStoreFlush();
         },
+        onWorkerSessionRecovered: async (notification) => {
+            workerSessions.set(notification.name, {
+                acpSessionId: notification.acpSessionId,
+                acpCwd: notification.acpCwd,
+                ...(workerAcpFingerprints.get(notification.name)
+                    ? { acpSpawn: workerAcpFingerprints.get(notification.name) }
+                    : {}),
+            });
+            try {
+                await flushSessionResumeStore();
+            }
+            catch (error) {
+                reportResumeStoreFlushFailure(error);
+            }
+            const detail = notification.reason === 'session_load_failed'
+                ? '保存済み ACP session を読み込めなかったため'
+                : '保存済み ACP thread の履歴を読めなかったため';
+            sessionLogger.emit({
+                type: 'harness.warning',
+                message: `worker.session.recovered name=${notification.name} kind=${notification.kind}: ${detail}新しい session で再開します。`,
+            });
+            eventQueue.enqueue({
+                type: 'worker.session.recovered',
+                name: notification.name,
+                kind: notification.kind,
+                reason: notification.reason,
+            });
+        },
         onWorkerFailed: (failure) => {
             sessionLogger.emit({ type: 'worker.failed', failure });
             eventQueue.enqueue({ type: 'worker.failed', failure });
@@ -820,22 +927,8 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
                 repoRoot: options.repoRoot,
                 conductorAgentId: conductorAgent.agentId,
                 issueUrl: options.issueUrl,
-                location: activeStoreLocation,
-            }), statusLine, undefined, [
-                ...(activeStoreLocation === 'canonical-slug'
-                    ? [
-                        sessionStateStorePath({
-                            repoRoot: options.repoRoot,
-                            conductorAgentId: conductorAgent.agentId,
-                            location: 'user-path-hash',
-                        }),
-                    ]
-                    : []),
-                legacySessionStateStorePath({
-                    repoRoot: options.repoRoot,
-                    conductorAgentId: conductorAgent.agentId,
-                }),
-            ]));
+                location: 'canonical-slug',
+            }), statusLine, undefined));
             sessionStateWriteQueue = write.catch(() => { });
             return write;
         },
@@ -885,16 +978,19 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
             : {}),
         ...(conductorBackend === 'pi'
             ? {
+                issueUrl: options.issueUrl,
                 pi: resolveConductorPiResourcePaths({
                     repoRoot: options.repoRoot,
                     config: ensembleConfig,
                 }),
-                sessionDir: resolveEnsemblePaths({
-                    repoRoot: options.repoRoot,
-                }).piSessionsDir,
-                legacySessionDir: resolveEnsemblePaths({
-                    repoRoot: options.repoRoot,
-                }).legacyPiSessionsDirForCwd(conductorCwd),
+                ...(activeLocatedResumeStore
+                    ? {
+                        resumeCwds: [
+                            activeLocatedResumeStore.resumeStore.conductorCwd,
+                            activeLocatedResumeStore.resumeStore.repoRoot,
+                        ].filter((cwd) => Boolean(cwd)),
+                    }
+                    : {}),
             }
             : {}),
         ...(Object.keys(mcpServers).length > 0 ? { mcpServers } : {}),
@@ -925,19 +1021,42 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
         throw error;
     }
     startupCleanup.add(async () => {
-        if (options.resumeAgentId && conductorAgent.closeForResume) {
-            await conductorAgent.closeForResume();
-        }
-        else {
-            await conductorAgent.close();
-        }
+        await closeConductorAgentOnce(conductorAgent, {
+            forResume: Boolean(options.resumeAgentId),
+        });
     });
     // Factories may not be abortable while pending. Register the returned agent
     // before checking shutdown so a late success is still closed by the guard.
     shutdownSignal.throwIfAborted();
+    if (options.resumeAgentId) {
+        const currentSessionStatePath = sessionStateStorePath({
+            repoRoot: options.repoRoot,
+            conductorAgentId: conductorAgent.agentId,
+            issueUrl: options.issueUrl,
+            location: 'canonical-slug',
+        });
+        try {
+            const currentState = await loadSessionStateStore(currentSessionStatePath);
+            if (!currentState &&
+                activeLocatedResumeStore &&
+                resolvePath(activeLocatedResumeStore.resumeStore.repoRoot) !==
+                    resolvePath(options.repoRoot)) {
+                reportResumeNotice('保存時 clone に残る legacy session-state YAML は通常読み取り対象ではありません。以前の statusLine と履歴を復元する必要がある場合は、migration tool で canonical slug へ移してください。');
+            }
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            sessionLogger.emit({
+                type: 'harness.warning',
+                message: `Issue 保存先の session state を読み込めませんでした。 error=${detail}`,
+            });
+            reportResumeNotice(`Issue 保存先の session-state YAML を読み込めませんでした。原因: ${detail}`);
+        }
+    }
     const conductorHandle = { conductor: conductorAgent };
-    activeResumeStorePath ??= sessionResumeStorePath({
+    activeResumeStorePath ??= canonicalSessionResumeStorePath({
         repoRoot: options.repoRoot,
+        issueUrl: options.issueUrl,
         conductorAgentId: conductorAgent.agentId,
     });
     // Keep auth/transport reconnects on the same backend factory as the session.
@@ -945,26 +1064,49 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
         conductorAgentFactory,
         conductorOptions,
         retrySuppressionSignal: shutdownIntentController.signal,
-        onAuthReconnectAttempt: ({ agentId }) => {
+        onAuthReconnectAttempt: ({ agentId, source, }) => {
             sessionLogger.emit({
                 type: 'conductor.auth.reconnect',
                 agentId,
+                status: 'attempt',
+                ...(source ? { source } : {}),
             });
         },
-        onTransportReconnectAttempt: ({ agentId }) => {
+        onAuthReconnectComplete: ({ agentId, success, source, closeFailed, }) => {
+            sessionLogger.emit({
+                type: 'conductor.auth.reconnect',
+                agentId,
+                status: success ? 'succeeded' : 'failed',
+                ...(source ? { source } : {}),
+            });
+            if (closeFailed) {
+                sessionLogger.emit({
+                    type: 'harness.warning',
+                    message: '旧 conductor の終了処理に失敗したため、リソース解放は確認できません。再接続後の状態を確認してください。',
+                });
+            }
+        },
+        onTransportReconnectAttempt: ({ agentId, source, }) => {
             sessionLogger.emit({
                 type: 'conductor.transport.reconnect',
                 agentId,
                 status: 'attempt',
+                ...(source ? { source } : {}),
             });
         },
-        onTransportReconnectComplete: ({ agentId, success, error, }) => {
+        onTransportReconnectComplete: ({ agentId, success, source, closeFailed, }) => {
             sessionLogger.emit({
                 type: 'conductor.transport.reconnect',
                 agentId,
                 status: success ? 'succeeded' : 'failed',
-                ...(error ? { error } : {}),
+                ...(source ? { source } : {}),
             });
+            if (closeFailed) {
+                sessionLogger.emit({
+                    type: 'harness.warning',
+                    message: '旧 conductor の終了処理に失敗したため、リソース解放は確認できません。再接続後の状態を確認してください。',
+                });
+            }
         },
     };
     let sessionResumeStoreWriteQueue = Promise.resolve();
@@ -992,14 +1134,23 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
             (harnessPhase === 'running' || harnessPhase === 'idle'
                 ? 'unknown'
                 : undefined);
+        const cursorBootstrapComplete = cursorBootstrapState
+            ? cursorBootstrapCompleteForStore(cursorBootstrapState)
+            : undefined;
         return {
             version: SESSION_RESUME_STORE_VERSION,
             conductorAgentId: conductorHandle.conductor.agentId,
             conductorBackend,
+            ...(createdHarnessCliVersion !== undefined
+                ? { createdHarnessCliVersion }
+                : {}),
             conductorCwd,
             ...(cursorBootstrapRunId
                 ? { cursorBootstrapRunId }
                 : {}),
+            ...(cursorBootstrapComplete !== undefined
+                ? { cursorBootstrapComplete }
+                : {}),
             lazyWorkers: activeLazyWorkers,
             ...(harnessSocketPath ? { harnessSocketPath } : {}),
             issueUrl: options.issueUrl,
@@ -1033,7 +1184,7 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
             repoRoot: options.repoRoot,
             conductorAgentId: conductorHandle.conductor.agentId,
             issueUrl: options.issueUrl,
-            location: activeStoreLocation,
+            location: 'canonical-slug',
         }), snapshot);
     };
     const persistSessionResumeStore = async (snapshot, lifecycle) => {
@@ -1121,6 +1272,7 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
     const toolCallHistoryPath = toolCallSnapshotHistoryPath({
         repoRoot: options.repoRoot,
         conductorAgentId: conductorHandle.conductor.agentId,
+        issueUrl: options.issueUrl,
     });
     let toolCallHistoryFlushTimer;
     let toolCallHistoryFlushQueue = Promise.resolve();
@@ -1293,9 +1445,38 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
     let stopReason = 'completed';
     const continueOnConductorError = options.continueOnConductorError ?? false;
     const waitForOperatorExit = options.waitForOperatorExit ?? false;
+    const operatorCanInspectRecovery = options.operatorCanInspectRecovery === true;
     let operatorRequestedExit = false;
     let operatorRequestedClose = false;
     let disposeOperatorInput;
+    const resolveCursorBootstrapUnknown = (assumption) => {
+        if (!operatorCanInspectRecovery ||
+            !cursorBootstrapState ||
+            cursorBootstrapState.status !== 'unknown') {
+            return false;
+        }
+        cursorBootstrapState.status = 'saving';
+        cursorBootstrapState.pendingAssumption = assumption;
+        void flushSessionResumeStore()
+            .then(() => {
+            cursorBootstrapState.status =
+                assumption === 'assume-complete' ? 'complete' : 'incomplete';
+            delete cursorBootstrapState.pendingAssumption;
+            sessionLogger.emit({
+                type: 'harness.warning',
+                message: assumption === 'assume-complete'
+                    ? 'operator が Cursor bootstrap を complete と仮定する判断を SessionResumeStore に保存しました。compiled prompt は追加送信しません。'
+                    : 'operator が Cursor bootstrap を incomplete と仮定する判断を SessionResumeStore に保存しました。次の新しい event に compiled prompt を添えて送ります。',
+            });
+        })
+            .catch((error) => {
+            cursorBootstrapState.status = 'unknown';
+            delete cursorBootstrapState.pendingAssumption;
+            reportResumeStoreFlushFailure(error);
+        })
+            .finally(() => dispatchLifecycle.wake());
+        return true;
+    };
     const onOperatorMessageQueued = (delivery) => {
         scheduleSessionResumeStoreFlush();
         if (delivery !== 'interrupt')
@@ -1347,23 +1528,33 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
         onOperatorMessageQueued(delivery);
         return true;
     };
+    const requestOperatorShutdown = (mode) => {
+        if (teardownStarted || operatorRequestedExit || operatorRequestedClose) {
+            return false;
+        }
+        if (mode === 'exit') {
+            sessionLogger.emit({ type: 'session.operator_exit' });
+            workerSession.runtime.cancelAllActivePrompts();
+            operatorRequestedExit = true;
+        }
+        else {
+            sessionLogger.emit({ type: 'session.operator_close' });
+            workerSession.runtime.cancelAllActivePrompts();
+            operatorRequestedClose = true;
+        }
+        shutdownIntentController.abort();
+        abortAfterOpenQuestionDrain(operatorTerminationController);
+        return true;
+    };
     if (options.bindOperatorInput) {
         const bindingDispose = options.bindOperatorInput({
             submit: (message, submitOptions) => {
                 if (isOperatorExitCommand(message)) {
-                    sessionLogger.emit({ type: 'session.operator_exit' });
-                    workerSession.runtime.cancelAllActivePrompts();
-                    operatorRequestedExit = true;
-                    shutdownIntentController.abort();
-                    abortAfterOpenQuestionDrain(operatorTerminationController);
+                    requestOperatorShutdown('exit');
                     return false;
                 }
                 if (isOperatorCloseCommand(message)) {
-                    sessionLogger.emit({ type: 'session.operator_close' });
-                    workerSession.runtime.cancelAllActivePrompts();
-                    operatorRequestedClose = true;
-                    shutdownIntentController.abort();
-                    abortAfterOpenQuestionDrain(operatorTerminationController);
+                    requestOperatorShutdown('close');
                     return false;
                 }
                 if (isOperatorReconnectCommand(message)) {
@@ -1395,6 +1586,21 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
                         }]
                     : []),
             }),
+            listRecoverySnapshots: () => recoveryInbox.list(),
+            ...(operatorCanInspectRecovery
+                ? {
+                    getRecoverySnapshot: (recoveryId) => recoveryInbox.get(recoveryId),
+                }
+                : {}),
+            clearRecoverySnapshot: (recoveryId) => recoveryInbox.remove(recoveryId),
+            continueAfterRecovery: () => dispatchLifecycle.confirmRecovery(),
+            recoveryAttentionAttemptId: () => dispatchLifecycle.pendingAttemptId,
+            ...(cursorBootstrapState && operatorCanInspectRecovery
+                ? {
+                    getCursorBootstrapStatus: () => cursorBootstrapState.status,
+                    resolveCursorBootstrapUnknown,
+                }
+                : {}),
         });
         if (typeof bindingDispose === 'function') {
             disposeOperatorInput = bindingDispose;
@@ -1445,29 +1651,9 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
                     repoRoot: options.repoRoot,
                     conductorAgentId: conductorAgent.agentId,
                     issueUrl: options.issueUrl,
-                    location: activeStoreLocation,
+                    location: 'canonical-slug',
                 });
-                const fallbackStatePaths = [
-                    ...(activeStoreLocation === 'canonical-slug'
-                        ? [
-                            sessionStateStorePath({
-                                repoRoot: options.repoRoot,
-                                conductorAgentId: conductorAgent.agentId,
-                                location: 'user-path-hash',
-                            }),
-                        ]
-                        : []),
-                    legacySessionStateStorePath({
-                        repoRoot: options.repoRoot,
-                        conductorAgentId: conductorAgent.agentId,
-                    }),
-                ];
-                let sessionState = await loadSessionStateStore(currentStatePath);
-                for (const fallbackPath of fallbackStatePaths) {
-                    if (sessionState)
-                        break;
-                    sessionState = await loadSessionStateStore(fallbackPath);
-                }
+                const sessionState = await loadSessionStateStore(currentStatePath);
                 return {
                     ...openQuestions.snapshot(),
                     ...(sessionState ? { sessionState } : {}),
@@ -1479,6 +1665,7 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
                 }
                 return sendOperatorMessage({ message: text, delivery });
             },
+            requestOperatorShutdown: ({ mode }) => requestOperatorShutdown(mode),
             answerOpenQuestion: async ({ questionId, answer }) => {
                 if (teardownStarted) {
                     throw new OpenQuestionControlOperationError(-32000, 'The session is shutting down.');
@@ -1589,6 +1776,10 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
             conductorHandle,
             sendReconnect,
             eventQueue,
+            recoveryInbox,
+            recoveryBackend: conductorBackend,
+            dispatchLifecycle,
+            operatorCanInspectRecovery,
             dispatchHoldState,
             onDispatchHoldChanged,
             resetOutboundDispatchesThisSend: () => {
@@ -1635,6 +1826,7 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
             // permission.pending) must be dispatched without waiting for a new
             // session briefing.
             skipInitialSend: Boolean(options.resumeAgentId),
+            ...(cursorBootstrapState ? { cursorBootstrapState } : {}),
             onSendStarted: (info) => {
                 reportHarnessActivity('conductor', true);
                 sessionLogger.emit({
@@ -1652,6 +1844,45 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
                 });
             },
             onSendComplete: recordSendComplete,
+            onRecoveryAttention: ({ attemptId, sourceKey, status, failureClass, confirmationRequired, pendingOperatorMessageCount, snapshot, agentAvailable, }) => {
+                const recoveryAction = operatorCanInspectRecovery
+                    ? snapshot
+                        ? `入力を確認するには /recovery list の後に /recovery show ${snapshot.recoveryId} を実行してください。`
+                        : 'この send に operator-authored input は含まれていません。'
+                    : 'この実行環境では recovery 本文を確認できません。同一 process 内でも取得できず、process 終了時に破棄されます。';
+                const queueNotice = pendingOperatorMessageCount > 0
+                    ? operatorCanInspectRecovery
+                        ? `未送信の operator message が ${pendingOperatorMessageCount} 件、既存 queue に残っています。`
+                        : `未送信の operator message ${pendingOperatorMessageCount} 件は既存 queue に残っていますが、非 TTY one-shot 終了時に破棄されます。必要なら状態を確認して再実行してください。`
+                    : undefined;
+                const confirmationNotice = confirmationRequired
+                    ? operatorCanInspectRecovery
+                        ? '状態を確認してから必要な続きを新しい指示で送り、後続 dispatch を再開するには /recovery continue を実行してください。'
+                        : '失敗した入力は自動再送せず、後続 dispatch も停止しています。非 TTY では本文を確認できないため、状態を確かめてから安全な再開方法を判断してください。'
+                    : '明示的な interrupt 入力が queue に残っているため、その入力を次に処理します。/recovery continue は不要です。';
+                sessionLogger.emit({
+                    type: 'harness.warning',
+                    message: [
+                        `conductor send が未完了です (source=${escapeTerminalControlCharacters(sourceKey)}, attempt=${attemptId}, status=${escapeTerminalControlCharacters(status)}, failure=${failureClass}).`,
+                        recoveryAction,
+                        queueNotice,
+                        agentAvailable
+                            ? undefined
+                            : 'agent は unavailable です。接続を直した後に /reconnect を実行してください。',
+                        confirmationNotice,
+                    ]
+                        .filter((part) => part !== undefined)
+                        .join(' '),
+                });
+            },
+            onRecoveryCapacityBlocked: () => {
+                sessionLogger.emit({
+                    type: 'harness.warning',
+                    message: operatorCanInspectRecovery
+                        ? 'recovery inbox の容量が上限に達しました。入力は queue に残して dispatch を待っています。/recovery clear <id> で空きを作るか、TTL 経過後に続行します。'
+                        : 'recovery inbox の容量が上限に達しました。入力を保持したまま dispatch を待っています。この実行環境では本文を確認できません。',
+                });
+            },
             onDispatchBatchSettled: ({ events, result, error }) => {
                 for (const event of events) {
                     if (event.type !== 'operator.message')
@@ -1692,6 +1923,16 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
                 cursorBootstrapRunId = info.runId;
                 scheduleSessionResumeStoreFlush();
             }
+            const issueDispatchCompleted = info.status === 'finished' ||
+                info.status === 'completed' ||
+                info.status === 'running';
+            if (conductorBackend === 'cursor' &&
+                cursorBootstrapState?.status === 'incomplete' &&
+                issueDispatchCompleted &&
+                (info.dispatchSource === 'initial' || info.historyInbound !== undefined)) {
+                cursorBootstrapState.status = 'complete';
+                scheduleSessionResumeStoreFlush();
+            }
             const responseText = info.result?.trim();
             if (info.status === 'finished' && responseText) {
                 const at = Date.now();
@@ -1703,7 +1944,7 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
                 if (info.dispatchSource !== 'initial') {
                     conductorMessages.push({
                         text: responseText,
-                        inbound: info.inbound,
+                        inbound: info.historyInbound ?? info.inbound,
                         at,
                         sendCount: info.sendCount,
                         ...(info.dispatchSource
@@ -1798,6 +2039,9 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
         }
     }
     finally {
+        disposeOperatorInput?.();
+        disposeOperatorInput = undefined;
+        recoveryInbox.dispose();
         const lifecycle = operatorRequestedClose
             ? 'closed'
             : operatorRequestedExit
@@ -1857,7 +2101,6 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
                 }
                 teardownPhases.openQuestionControl = Date.now() - phaseStart;
             }
-            disposeOperatorInput?.();
             if (dispatchHoldReminderMonitor) {
                 emitTeardownPhase('dispatchHoldReminderMonitor');
                 dispatchHoldReminderMonitor.stop();
@@ -1873,11 +2116,11 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
             // after this point are rejected by the teardown guard above.
             workerSession.runtime.cancelAllActivePrompts();
             if (operatorRequestedClose) {
-                // A worker's ACP session exists before its first prompt completes, but
-                // workerSessions is normally updated by onWorkerCompleted. Snapshot
-                // attached sessions now so force shutdown cannot discard the only
-                // completion event that would have persisted a resumable session ID.
-                for (const attached of workerSession.runtime.listAttached()) {
+                // A worker's ACP session exists before its first prompt completes, so
+                // snapshot resumable attached sessions before force shutdown. Recovery
+                // bootstrap replacements are excluded until initialized; their prior
+                // workerSessions entry remains available for the next resume.
+                for (const attached of workerSession.runtime.listAttachedForResume()) {
                     workerSessions.set(attached.name, {
                         acpSessionId: attached.session.sessionId,
                         acpCwd: attached.session.acpCwd,
@@ -1936,12 +2179,9 @@ async function runConductorSessionWithStartupGuard(options, startupCleanup) {
             const runConductorClose = async () => {
                 emitTeardownPhase('conductor');
                 const phaseStart = Date.now();
-                if (operatorRequestedClose && conductorHandle.conductor.closeForResume) {
-                    await conductorHandle.conductor.closeForResume();
-                }
-                else {
-                    await conductorHandle.conductor.close();
-                }
+                await closeConductorAgentOnce(conductorHandle.conductor, {
+                    forResume: operatorRequestedClose,
+                });
                 teardownPhases.conductor = Date.now() - phaseStart;
             };
             if (forceShutdown) {
@@ -2078,15 +2318,46 @@ function attachLegacySessionCallbacks(logger, options) {
         }
     });
 }
-function finalizeSessionWorkerSpecs(workers, defaultAcp) {
+function finalizeSessionWorkerSpecs(workers, repoRoot, issueNumber, defaultAcp, piAgentDir) {
+    const resolvedPiAgentDir = piAgentDir ??
+        resolveConductorPiResourcePaths({
+            repoRoot,
+            config: defaultAcp?.config,
+            env: defaultAcp?.env,
+        }).agentDir;
     for (const worker of workers) {
         const resolved = resolveWorkerAcpSpawn({
             defaultOptions: defaultAcp,
             modelTag: worker.modelTag,
         });
-        const finalized = finalizeResolvedAcpSpawn(resolved);
+        const sessionSpawn = resolved.piRuntime === 'builtin'
+            ? configurePiWorkerRuntime(resolved, {
+                repoRoot,
+                issueNumber,
+                workerName: worker.name,
+                ...(resolvedPiAgentDir
+                    ? { agentDir: resolvedPiAgentDir }
+                    : {}),
+            })
+            : resolved;
+        const finalized = finalizeResolvedAcpSpawn(sessionSpawn);
         worker.spawn = resolvedAcpSpawnToOptions(finalized, worker.spawn);
         worker.acpFingerprint = acpSpawnFingerprint(finalized);
     }
 }
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
 //# sourceMappingURL=conductor-session.js.map