@agents-ensemble/core 0.12.0 → 0.14.0

package/dist/conductor/conductor-session.js

@@ -4,25 +4,28 @@ import { createAnswerOpenQuestionTool } from '../escalation/answer-open-question
 import { createAskHumanTool } from '../escalation/ask-human-tool.js';
 import { createOpenQuestionListTools } from '../escalation/open-question-list-tools.js';
 import { openQuestionToEscalationRecord } from '../escalation/open-question-to-escalation.js';
-import { OpenQuestionRegistry } from '../escalation/open-question.js';
+import { OpenQuestionRegistry, } from '../escalation/open-question.js';
 import { deny } from '../permission/permission-broker.js';
 import { PermissionPipeline } from '../permission/permission-pipeline.js';
 import { createPermissionDeadlockMonitor, } from '../permission/permission-deadlock-monitor.js';
 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 { finalizeResolvedAcpSpawn, validateWorkerAcpPrerequisites, } from '../acp/validate-acp-preset-prerequisites.js';
 import { profileWorkersToSessionSpecs, sessionStateFromProfile, resolveAgentPromptModule, } from '../profile/types.js';
 import { WorkerSession } from '../runtime/worker-session.js';
+import { ToolCallSnapshotRegistry, } from '../runtime/tool-call-snapshot-registry.js';
 import { createPromptWorkerTool } from '../dispatch/prompt-worker-tool.js';
 import { createWorkerStatusTools } from '../dispatch/worker-status-tool.js';
+import { createGetToolCallTool } from '../dispatch/get-tool-call-tool.js';
 import { createSessionUsageTools } from '../dispatch/session-usage-tool.js';
+import { createReportSessionStateTool } from '../dispatch/report-session-state-tool.js';
 import { createSetDispatchHoldTool } from '../dispatch/set-dispatch-hold-tool.js';
 import { parseIssueUrl } from '../issue/issue-ref.js';
 import { resolveWorkerWorkspace, removeWorkerWorktree, } from '../worktree/worktree.js';
 import { WorkerOutboundQueue } from '../runtime/worker-outbound-queue.js';
 import { ConductorToolRegistry } from './conductor-tool.js';
-import { createCursorSdkConductorAgentFactory } from './cursor-sdk-conductor-agent.js';
-import { createPiConductorAgentFactory } from './pi-conductor-agent.js';
+import { createConductorAgentFactory } from './conductor-agent-factory.js';
 import { formatConductorAuthRecoveryHint, isConductorSendAuthError, } from './conductor-auth.js';
 import { resolvePiConductorProvider } from './conductor-pi-auth.js';
 import { SessionLogger } from './session/session-logger.js';
@@ -34,6 +37,10 @@ import { isOperatorExitCommand } from './operator-exit.js';
 import { isOperatorCloseCommand } from './operator-close.js';
 import { isOperatorReconnectCommand } from './operator-reconnect.js';
 import { assertSessionSidecarMatches, requireSessionSidecarForResume, saveSessionSidecar, SESSION_SIDECAR_VERSION, sessionSidecarPath, } from '../session/session-sidecar.js';
+import { saveSessionStatusLine, sessionStateStorePath, } from '../session/session-state-store.js';
+import { loadToolCallSnapshotHistory, pruneExpiredToolCallSnapshotHistoryFiles, saveToolCallSnapshotHistory, toolCallSnapshotHistoryPath, } from '../session/tool-call-snapshot-history.js';
+import { loadOpenQuestionsStore, openQuestionsStorePath, saveOpenQuestionsStore, } from '../session/open-questions-store.js';
+import { 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';
@@ -49,6 +56,12 @@ 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';
+const OPEN_QUESTION_CONTROL_DRAIN_TIMEOUT_MS = 5_000;
+const RECORDED_ANSWER_UNKNOWN_DISPATCH = {
+    outcome: 'unknown',
+    answerStatus: 'recorded',
+    dispatchStatus: 'unknown',
+};
 export async function runConductorSession(options) {
     const userInstructions = await loadUserInstructions({
         userEnsembleRoot: options.mcpConfigOptions?.userEnsembleRoot,
@@ -65,9 +78,20 @@ export async function runConductorSession(options) {
             repoRoot: options.repoRoot,
         });
     attachLegacySessionCallbacks(sessionLogger, options);
+    const expiredHistory = await pruneExpiredToolCallSnapshotHistoryFiles(options.repoRoot);
+    if (expiredHistory.failedCount > 0) {
+        sessionLogger.emit({
+            type: 'harness.warning',
+            message: 'Some expired tool-call snapshot history files could not be removed.',
+        });
+    }
     const escalations = [];
     const openQuestions = new OpenQuestionRegistry();
+    let harnessSocketPath;
+    let openQuestionControlServer;
     const eventQueue = new SessionEventQueue();
+    const openQuestionDispatchReceipts = new WeakMap();
+    const pendingOpenQuestionDispatchReceipts = new Set();
     const dispatchHoldState = createDispatchHoldState();
     const onDispatchHoldChanged = (change) => {
         sessionLogger.emit({
@@ -85,16 +109,19 @@ export async function runConductorSession(options) {
     const workerSessions = new Map();
     let githubMonitorCursor;
     let githubMonitor;
+    const pendingGitHubRecoveries = [];
     const conductorCwd = options.conductorCwd ?? process.cwd();
     const mcpServers = await resolveMcpServers(options.repoRoot, options.mcpConfigOptions);
     const mcpConfigDigest = computeMcpConfigDigest(mcpServers);
     const mcpConfigConfigured = Object.keys(mcpServers).length > 0;
+    let resumeToolCallSnapshots = [];
+    let toolCallHistoryNeedsRewrite = false;
     if (options.resumeAgentId) {
-        const sidecar = await requireSessionSidecarForResume({
+        const loadedSidecar = await requireSessionSidecarForResume({
             repoRoot: options.repoRoot,
             conductorAgentId: options.resumeAgentId,
         });
-        assertSessionSidecarMatches(sidecar, {
+        assertSessionSidecarMatches(loadedSidecar, {
             conductorAgentId: options.resumeAgentId,
             issueUrl: options.issueUrl,
             repoRoot: options.repoRoot,
@@ -102,10 +129,57 @@ export async function runConductorSession(options) {
             mcpConfigDigest,
             mcpConfigConfigured,
         });
-        openQuestions.restore({
-            sequence: sidecar.sequence,
-            openQuestions: sidecar.openQuestions,
+        // A previously completed lifecycle no longer describes this instance once
+        // resume begins. Persist unknown before restoring or attaching anything so
+        // a crash before the first regular sidecar flush cannot leave stale
+        // `closed` / `exited` data behind.
+        const sidecar = {
+            ...loadedSidecar,
+            lifecycle: 'unknown',
+            harnessSocketPath: undefined,
+            updatedAt: Date.now(),
+        };
+        await saveSessionSidecar(sessionSidecarPath({
+            repoRoot: options.repoRoot,
+            conductorAgentId: options.resumeAgentId,
+        }), sidecar);
+        const history = await loadToolCallSnapshotHistory({
+            repoRoot: options.repoRoot,
+            conductorAgentId: options.resumeAgentId,
         });
+        resumeToolCallSnapshots = history.entries;
+        toolCallHistoryNeedsRewrite = history.needsRewrite;
+        if (history.warning) {
+            sessionLogger.emit({
+                type: 'harness.warning',
+                message: `${history.warning}; the session will continue without affected history`,
+            });
+        }
+        const openQuestionsPath = openQuestionsStorePath({
+            repoRoot: options.repoRoot,
+            conductorAgentId: options.resumeAgentId,
+        });
+        const openQuestionsSnapshot = await loadOpenQuestionsStore(openQuestionsPath);
+        if (openQuestionsSnapshot) {
+            openQuestions.restore(openQuestionsSnapshot);
+        }
+        else {
+            const legacySnapshot = {
+                sequence: sidecar.sequence,
+                openQuestions: sidecar.openQuestions,
+            };
+            openQuestions.restore(legacySnapshot);
+            try {
+                await saveOpenQuestionsStore(openQuestionsPath, legacySnapshot);
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : String(error);
+                sessionLogger.emit({
+                    type: 'harness.warning',
+                    message: `旧 sidecar から復元した open question を YAML にバックフィルできませんでした。今回のセッションは継続します。 error=${detail}`,
+                });
+            }
+        }
         activeProfile = sidecar.profile;
         // Sidecars written before this setting always started every worker eagerly.
         activeLazyWorkers = sidecar.lazyWorkers ?? false;
@@ -147,12 +221,62 @@ export async function runConductorSession(options) {
         ? new AbortController()
         : undefined;
     const shutdownSignal = options.shutdownSignal ?? shutdownController.signal;
+    const shutdownIntentController = new AbortController();
     const operatorTerminationController = new AbortController();
+    const drainedShutdownController = new AbortController();
     const driverShutdownSignal = AbortSignal.any([
-        shutdownSignal,
+        drainedShutdownController.signal,
         operatorTerminationController.signal,
     ]);
+    const abortAfterOpenQuestionDrain = (controller) => {
+        const activeControlServer = openQuestionControlServer;
+        if (!activeControlServer) {
+            controller.abort();
+            return;
+        }
+        const reportDrainFailure = (error) => {
+            const detail = error instanceof Error ? error.message : String(error);
+            sessionLogger.emit({
+                type: 'harness.warning',
+                message: `Open Question control drain failed: ${detail}`,
+            });
+        };
+        const quiescing = activeControlServer.quiesce();
+        if (!activeControlServer.hasInFlightRequests()) {
+            void quiescing.catch(reportDrainFailure);
+            controller.abort();
+            return;
+        }
+        let drainTimeout;
+        const drainDeadline = new Promise((resolve) => {
+            drainTimeout = setTimeout(() => resolve('timeout'), OPEN_QUESTION_CONTROL_DRAIN_TIMEOUT_MS);
+        });
+        const drainResult = quiescing.then(() => 'drained', (error) => {
+            reportDrainFailure(error);
+            return 'failed';
+        });
+        void Promise.race([drainResult, drainDeadline]).then((result) => {
+            if (drainTimeout)
+                clearTimeout(drainTimeout);
+            if (result === 'timeout') {
+                sessionLogger.emit({
+                    type: 'harness.warning',
+                    message: `Open Question control drain exceeded ${OPEN_QUESTION_CONTROL_DRAIN_TIMEOUT_MS}ms; aborting conductor dispatch. Accepted answers may have unknown notification outcomes.`,
+                });
+            }
+            controller.abort();
+        });
+    };
+    const onShutdownSignal = () => {
+        shutdownIntentController.abort();
+        abortAfterOpenQuestionDrain(drainedShutdownController);
+    };
+    shutdownSignal.addEventListener('abort', onShutdownSignal, { once: true });
+    if (shutdownSignal.aborted)
+        onShutdownSignal();
     let unregisterProcessSignalHandlers = () => { };
+    const removeShutdownDrainListener = () => shutdownSignal.removeEventListener('abort', onShutdownSignal);
+    unregisterProcessSignalHandlers = removeShutdownDrainListener;
     if (ownsShutdownController &&
         options.registerProcessSignalHandlers !== false) {
         const onSignal = () => shutdownController.abort();
@@ -161,11 +285,16 @@ export async function runConductorSession(options) {
         unregisterProcessSignalHandlers = () => {
             process.off('SIGINT', onSignal);
             process.off('SIGTERM', onSignal);
+            removeShutdownDrainListener();
         };
     }
     const permissionPipeline = options.permissionPipeline ??
         new PermissionPipeline({ policy: options.permissionPolicy });
     let scheduleSidecarFlush = () => { };
+    let flushSidecar = async () => { };
+    let scheduleToolCallHistoryFlush = () => { };
+    let flushToolCallHistory = async () => { };
+    let toolCallHistoryDirty = toolCallHistoryNeedsRewrite;
     const sessionState = sessionStateFromProfile(activeProfile);
     const issue = parseIssueUrl(options.issueUrl);
     const spawnBase = {
@@ -216,7 +345,11 @@ export async function runConductorSession(options) {
     }
     const sessionUsageTracker = new SessionUsageTracker({
         contextLimitTokens: options.contextLimitTokens,
+        trackCompactions: conductorBackend === 'pi' && options.conductorAgentFactory == null,
     });
+    const toolCallSnapshots = new ToolCallSnapshotRegistry();
+    let toolCallHistoryLimitWarningEmitted = false;
+    let toolCallHistoryOversizeWarningEmitted = false;
     const workerSession = new WorkerSession({
         issueUrl: options.issueUrl,
         repoRoot: options.repoRoot,
@@ -249,6 +382,13 @@ export async function runConductorSession(options) {
                 const operatorSummary = formatPermissionSummaryForOperator(pending, {
                     workerLabel,
                 });
+                const toolCallId = getPermissionToolCallId(pending.request);
+                const toolCallSnapshot = toolCallId && pending.request.sessionId
+                    ? toolCallSnapshots.get(toolCallId, {
+                        workerId,
+                        sessionId: pending.request.sessionId,
+                    })
+                    : undefined;
                 sessionLogger.emit({
                     type: 'permission.pending',
                     permission: pending,
@@ -257,6 +397,8 @@ export async function runConductorSession(options) {
                 eventQueue.enqueue({
                     type: 'permission.pending',
                     permission: pending,
+                    worker: workerLabel,
+                    brief: buildPermissionBrief(pending.request, toolCallSnapshot),
                     operatorSummary,
                 });
             }
@@ -331,6 +473,36 @@ export async function runConductorSession(options) {
             }
         },
         onAcpUpdate: (event) => {
+            if (event.toolCallUpdate) {
+                const result = toolCallSnapshots.applyWithResult({
+                    workerId: event.workerId,
+                    workerName: event.name,
+                    sessionId: event.sessionId ?? '',
+                }, event.toolCallUpdate);
+                if (result.status === 'applied') {
+                    toolCallHistoryDirty = true;
+                    scheduleToolCallHistoryFlush();
+                    if (result.evictedCount > 0 &&
+                        !toolCallHistoryLimitWarningEmitted) {
+                        toolCallHistoryLimitWarningEmitted = true;
+                        sessionLogger.emit({
+                            type: 'harness.warning',
+                            message: 'Tool-call snapshot history reached its retention limit; oldest snapshots were removed.',
+                        });
+                    }
+                }
+                else if (result.reason === 'too-large') {
+                    toolCallHistoryDirty = true;
+                    scheduleToolCallHistoryFlush();
+                    if (!toolCallHistoryOversizeWarningEmitted) {
+                        toolCallHistoryOversizeWarningEmitted = true;
+                        sessionLogger.emit({
+                            type: 'harness.warning',
+                            message: 'A tool-call snapshot exceeds the history size limit and was not retained.',
+                        });
+                    }
+                }
+            }
             sessionLogger.emit({
                 type: 'harness.worker.acp.update',
                 name: event.name,
@@ -369,6 +541,22 @@ export async function runConductorSession(options) {
         });
     }
     workerSession.startWorkers();
+    if (resumeToolCallSnapshots.length > 0) {
+        const workerIdsByName = new Map();
+        workers.forEach((worker, index) => {
+            const workerId = workerSession.startedWorkerIds[index];
+            if (workerId)
+                workerIdsByName.set(worker.name, workerId);
+        });
+        const restoreResult = toolCallSnapshots.restore(resumeToolCallSnapshots, workerIdsByName);
+        if (restoreResult.skippedCount > 0) {
+            toolCallHistoryDirty = true;
+            sessionLogger.emit({
+                type: 'harness.warning',
+                message: `${restoreResult.skippedCount} tool-call snapshot entr${restoreResult.skippedCount === 1 ? 'y was' : 'ies were'} skipped because its worker is no longer available or its data is invalid.`,
+            });
+        }
+    }
     const recordAnsweredQuestion = (answered) => {
         const record = openQuestionToEscalationRecord(answered);
         if (record) {
@@ -380,15 +568,6 @@ export async function runConductorSession(options) {
     };
     const askHumanTools = createAskHumanTool({
         registry: openQuestions,
-        getPermissionSummary: (permissionId) => {
-            const pending = permissionPipeline.pending.get(permissionId);
-            if (!pending) {
-                return undefined;
-            }
-            const workerLabel = workerSession.runtime.resolveWorkerLabel(pending.workerId) ??
-                pending.workerId;
-            return formatPermissionSummaryForOperator(pending, { workerLabel });
-        },
         onEnqueued: (question) => {
             sessionLogger.emit({ type: 'open.question.enqueued', question });
             options.onOpenQuestionEnqueued?.(question);
@@ -406,6 +585,9 @@ export async function runConductorSession(options) {
         pipeline: permissionPipeline,
         inbox: workerSession.inbox,
     });
+    const getToolCallTools = createGetToolCallTool({
+        snapshots: toolCallSnapshots,
+    });
     let outboundDispatchesThisSend = 0;
     const outboundWorkersThisSend = new Set();
     const workerOutboundQueue = new WorkerOutboundQueue((worker, instruction, options) => {
@@ -431,9 +613,12 @@ export async function runConductorSession(options) {
             githubMonitorCursor ??= emptyGitHubMonitorCursor();
             return githubMonitorCursor;
         },
-        onRegistered: (registration) => {
+        onRegistered: async (registration) => {
             githubMonitor?.registerPullRequest?.(registration);
-            scheduleSidecarFlush();
+            // Do not report success to the conductor until the explicit watch is
+            // durable. This closes the crash window between the tool result and a
+            // later best-effort flush.
+            await flushSidecar();
         },
     });
     const unregisterGitHubWatchTools = createUnregisterGitHubWatchTool({
@@ -442,9 +627,9 @@ export async function runConductorSession(options) {
             githubMonitorCursor ??= emptyGitHubMonitorCursor();
             return githubMonitorCursor;
         },
-        onUnregistered: (prNumber) => {
+        onUnregistered: async (prNumber) => {
             githubMonitor?.unregisterPullRequest?.(prNumber);
-            scheduleSidecarFlush();
+            await flushSidecar();
         },
     });
     let conductorAgent;
@@ -456,6 +641,20 @@ export async function runConductorSession(options) {
             return usage.cost;
         },
     });
+    let sessionStateWriteQueue = Promise.resolve();
+    const reportSessionStateTool = createReportSessionStateTool({
+        onReport: (statusLine) => {
+            if (teardownStarted) {
+                throw new Error('report_session_state is unavailable during teardown');
+            }
+            const write = sessionStateWriteQueue.then(() => saveSessionStatusLine(sessionStateStorePath({
+                repoRoot: options.repoRoot,
+                conductorAgentId: conductorAgent.agentId,
+            }), statusLine));
+            sessionStateWriteQueue = write.catch(() => { });
+            return write;
+        },
+    });
     const dispatchHoldTools = createSetDispatchHoldTool({
         state: dispatchHoldState,
         onChanged: onDispatchHoldChanged,
@@ -479,11 +678,13 @@ export async function runConductorSession(options) {
         .registerAll(answerOpenQuestionTools)
         .registerAll(openQuestionListTools)
         .registerAll(resolvePermissionTools)
+        .registerAll(getToolCallTools)
         .registerAll(promptWorkerTools)
         .registerAll(workerStatusTools)
         .registerAll(registerGitHubWatchTools)
         .registerAll(unregisterGitHubWatchTools)
         .registerAll(sessionUsageTools)
+        .registerAll(reportSessionStateTool)
         .registerAll(dispatchHoldTools);
     const conductorOptions = {
         cwd: conductorCwd,
@@ -504,6 +705,11 @@ export async function runConductorSession(options) {
             : {}),
         ...(Object.keys(mcpServers).length > 0 ? { mcpServers } : {}),
         customTools: conductorToolRegistry.toRecord(),
+        ...(conductorBackend === 'pi' && options.conductorAgentFactory == null
+            ? {
+                onContextCompaction: () => sessionUsageTracker.recordContextCompaction(),
+            }
+            : {}),
     };
     const conductorProvider = conductorBackend === 'pi'
         ? (await resolvePiConductorProvider({
@@ -520,6 +726,7 @@ export async function runConductorSession(options) {
     const sendReconnect = {
         conductorAgentFactory,
         conductorOptions,
+        retrySuppressionSignal: shutdownIntentController.signal,
         onAuthReconnectAttempt: ({ agentId }) => {
             sessionLogger.emit({
                 type: 'conductor.auth.reconnect',
@@ -543,47 +750,128 @@ export async function runConductorSession(options) {
         },
     };
     let sidecarFlushQueue = Promise.resolve();
-    let flushSidecar = async () => { };
-    flushSidecar = () => {
-        const nextFlush = sidecarFlushQueue.then(async () => {
-            const workers = {};
-            for (const [name, worker] of workerSessions) {
-                workers[name] = {
-                    acpSessionId: worker.acpSessionId,
-                    ...(worker.acpCwd ? { acpCwd: worker.acpCwd } : {}),
-                    ...(worker.acpSpawn ? { acpSpawn: worker.acpSpawn } : {}),
-                };
-            }
-            const snapshot = openQuestions.snapshot();
-            const sidecar = {
-                version: SESSION_SIDECAR_VERSION,
-                conductorAgentId: conductorHandle.conductor.agentId,
-                conductorBackend,
-                lazyWorkers: activeLazyWorkers,
-                issueUrl: options.issueUrl,
-                repoRoot: options.repoRoot,
-                profile: structuredClone(activeProfile),
-                ...(options.profilePath ? { profilePath: options.profilePath } : {}),
-                openQuestions: snapshot.openQuestions,
-                sequence: snapshot.sequence,
-                workers,
-                mcpConfigDigest,
-                ...(githubMonitorCursor ? { githubMonitor: githubMonitorCursor } : {}),
-                updatedAt: Date.now(),
+    let terminalLifecycle;
+    const enqueueSidecarWrite = (write) => {
+        const nextWrite = sidecarFlushQueue.then(write);
+        sidecarFlushQueue = nextWrite.catch(() => { });
+        return nextWrite;
+    };
+    const createSessionSidecar = (snapshot, lifecycle) => {
+        const workers = {};
+        for (const [name, worker] of workerSessions) {
+            workers[name] = {
+                acpSessionId: worker.acpSessionId,
+                ...(worker.acpCwd ? { acpCwd: worker.acpCwd } : {}),
+                ...(worker.acpSpawn ? { acpSpawn: worker.acpSpawn } : {}),
             };
-            await saveSessionSidecar(sessionSidecarPath({
-                repoRoot: options.repoRoot,
-                conductorAgentId: conductorHandle.conductor.agentId,
-            }), sidecar);
+        }
+        return {
+            version: SESSION_SIDECAR_VERSION,
+            conductorAgentId: conductorHandle.conductor.agentId,
+            conductorBackend,
+            lazyWorkers: activeLazyWorkers,
+            ...(harnessSocketPath ? { harnessSocketPath } : {}),
+            issueUrl: options.issueUrl,
+            repoRoot: options.repoRoot,
+            profile: structuredClone(activeProfile),
+            ...(options.profilePath ? { profilePath: options.profilePath } : {}),
+            openQuestions: snapshot.openQuestions,
+            sequence: snapshot.sequence,
+            workers,
+            mcpConfigDigest,
+            ...((terminalLifecycle ?? lifecycle)
+                ? { lifecycle: terminalLifecycle ?? lifecycle }
+                : {}),
+            ...(githubMonitorCursor ? { githubMonitor: githubMonitorCursor } : {}),
+            updatedAt: Date.now(),
+        };
+    };
+    const persistOpenQuestionsSnapshot = async (snapshot) => {
+        await saveOpenQuestionsStore(openQuestionsStorePath({
+            repoRoot: options.repoRoot,
+            conductorAgentId: conductorHandle.conductor.agentId,
+        }), snapshot);
+    };
+    const persistSessionSidecar = async (snapshot, lifecycle) => {
+        await saveSessionSidecar(sessionSidecarPath({
+            repoRoot: options.repoRoot,
+            conductorAgentId: conductorHandle.conductor.agentId,
+        }), createSessionSidecar(snapshot, lifecycle));
+    };
+    flushSidecar = (lifecycle) => enqueueSidecarWrite(async () => {
+        const snapshot = openQuestions.snapshot();
+        await persistOpenQuestionsSnapshot(snapshot);
+        await persistSessionSidecar(snapshot, lifecycle);
+    });
+    const reportSidecarFlushFailure = (error) => {
+        const detail = error instanceof Error ? error.message : String(error);
+        sessionLogger.emit({
+            type: 'harness.warning',
+            message: `Open Question YAML / session sidecar を保存できませんでした。最新状態から再開できず、直前に保存された状態からの再開になる場合があります。 error=${detail}`,
+        });
+    };
+    const reportSessionSidecarWriteFailure = (error) => {
+        const detail = error instanceof Error ? error.message : String(error);
+        sessionLogger.emit({
+            type: 'harness.warning',
+            message: `Session sidecar の更新に失敗しました。Open Question YAML の保存は完了しており、sidecar は後続 flush で同期します。 error=${detail}`,
         });
-        sidecarFlushQueue = nextFlush.catch(() => { });
-        return nextFlush;
     };
     scheduleSidecarFlush = () => {
-        void flushSidecar().catch(() => {
-            // best-effort persistence
+        void flushSidecar().catch(reportSidecarFlushFailure);
+    };
+    const toolCallHistoryPath = toolCallSnapshotHistoryPath({
+        repoRoot: options.repoRoot,
+        conductorAgentId: conductorHandle.conductor.agentId,
+    });
+    let toolCallHistoryFlushTimer;
+    let toolCallHistoryFlushQueue = Promise.resolve();
+    let toolCallHistoryFlushWarningEmitted = false;
+    const emitToolCallHistoryFlushWarning = () => {
+        if (toolCallHistoryFlushWarningEmitted)
+            return;
+        toolCallHistoryFlushWarningEmitted = true;
+        sessionLogger.emit({
+            type: 'harness.warning',
+            message: 'Tool-call snapshot history could not be saved; the latest history may be unavailable after resume.',
         });
     };
+    flushToolCallHistory = () => {
+        if (toolCallHistoryFlushTimer) {
+            clearTimeout(toolCallHistoryFlushTimer);
+            toolCallHistoryFlushTimer = undefined;
+        }
+        if (!toolCallHistoryDirty)
+            return toolCallHistoryFlushQueue;
+        toolCallHistoryDirty = false;
+        const nextFlush = toolCallHistoryFlushQueue.then(() => saveToolCallSnapshotHistory(toolCallHistoryPath, toolCallSnapshots.snapshot()));
+        toolCallHistoryFlushQueue = nextFlush.catch(() => { });
+        return nextFlush;
+    };
+    scheduleToolCallHistoryFlush = () => {
+        toolCallHistoryDirty = true;
+        if (toolCallHistoryFlushTimer)
+            return;
+        toolCallHistoryFlushTimer = setTimeout(() => {
+            toolCallHistoryFlushTimer = undefined;
+            void flushToolCallHistory().catch(() => {
+                toolCallHistoryDirty = true;
+                emitToolCallHistoryFlushWarning();
+            });
+        }, 100);
+        toolCallHistoryFlushTimer.unref?.();
+    };
+    const flushToolCallHistoryBestEffort = async () => {
+        try {
+            await flushToolCallHistory();
+        }
+        catch {
+            toolCallHistoryDirty = true;
+            emitToolCallHistoryFlushWarning();
+        }
+    };
+    if (toolCallHistoryDirty)
+        scheduleToolCallHistoryFlush();
     let sendCount = 0;
     let autonomousTurns = 0;
     const monitorDefaults = ensembleConfig.github.monitor;
@@ -610,6 +898,14 @@ export async function runConductorSession(options) {
                     type: 'harness.github.update',
                     itemCount: payload.items.length,
                 });
+                for (const suppressedErrorCount of pendingGitHubRecoveries.splice(0)) {
+                    eventQueue.enqueue({
+                        type: 'harness.connectivity.recovered',
+                        source: 'github_monitor',
+                        suppressedErrorCount,
+                        dispatchMode: 'inform',
+                    });
+                }
                 eventQueue.enqueue({
                     type: 'github.update',
                     items: payload.items,
@@ -635,11 +931,21 @@ export async function runConductorSession(options) {
                     message,
                 });
             },
-            onPollRecovered: (suppressedErrorCount) => {
+            onPollRecovered: (suppressedErrorCount, hasUpdates) => {
                 sessionLogger.emit({
                     type: 'harness.github.monitor_recovered',
                     suppressedErrorCount,
                 });
+                if (hasUpdates) {
+                    pendingGitHubRecoveries.push(suppressedErrorCount);
+                }
+                else {
+                    eventQueue.enqueue({
+                        type: 'harness.connectivity.recovered',
+                        source: 'github_monitor',
+                        suppressedErrorCount,
+                    });
+                }
             },
         });
         githubMonitor.start();
@@ -687,14 +993,16 @@ export async function runConductorSession(options) {
                     sessionLogger.emit({ type: 'session.operator_exit' });
                     workerSession.runtime.cancelAllActivePrompts();
                     operatorRequestedExit = true;
-                    operatorTerminationController.abort();
+                    shutdownIntentController.abort();
+                    abortAfterOpenQuestionDrain(operatorTerminationController);
                     return false;
                 }
                 if (isOperatorCloseCommand(message)) {
                     sessionLogger.emit({ type: 'session.operator_close' });
                     workerSession.runtime.cancelAllActivePrompts();
                     operatorRequestedClose = true;
-                    operatorTerminationController.abort();
+                    shutdownIntentController.abort();
+                    abortAfterOpenQuestionDrain(operatorTerminationController);
                     return false;
                 }
                 if (isOperatorReconnectCommand(message)) {
@@ -728,6 +1036,114 @@ export async function runConductorSession(options) {
         }
     }
     try {
+        openQuestionControlServer = await startOpenQuestionControlServer({
+            listOpenQuestions: () => openQuestions.listOpen(),
+            answerOpenQuestion: async ({ questionId, answer }) => {
+                if (teardownStarted) {
+                    throw new OpenQuestionControlOperationError(-32000, 'The session is shutting down.');
+                }
+                const current = openQuestions.get(questionId);
+                if (!current || current.status !== 'open') {
+                    throw new OpenQuestionControlOperationError(-32004, 'Open Question is not available.');
+                }
+                let accepted = false;
+                let sidecarWriteError;
+                let dispatchReceipt;
+                let answered;
+                const escalatedRecords = [];
+                await enqueueSidecarWrite(async () => {
+                    const stagedOpenQuestions = new OpenQuestionRegistry();
+                    stagedOpenQuestions.restore(openQuestions.snapshot());
+                    const stagedAccepted = submitOperatorInput({
+                        message: answer,
+                        targetOpenQuestionId: questionId,
+                        conductorTurn: sendCount + 1,
+                        openQuestions: stagedOpenQuestions,
+                        escalations: [],
+                        eventQueue: new SessionEventQueue(),
+                        sessionLogger: { emit: () => { } },
+                    });
+                    const stagedAnswer = stagedOpenQuestions.get(questionId);
+                    if (!stagedAccepted ||
+                        !stagedAnswer ||
+                        stagedAnswer.status !== 'answered') {
+                        return;
+                    }
+                    // The Open Questions YAML is the durable commit point. Do not expose
+                    // the answer in the live Registry or event queue until this succeeds.
+                    await persistOpenQuestionsSnapshot(stagedOpenQuestions.snapshot());
+                    // Another answer path may have won while the atomic YAML write was
+                    // in flight. Restore the current Registry snapshot before rejecting.
+                    if (openQuestions.get(questionId)?.status !== 'open') {
+                        await persistOpenQuestionsSnapshot(openQuestions.snapshot());
+                        return;
+                    }
+                    accepted = submitOperatorInput({
+                        message: answer,
+                        targetOpenQuestionId: questionId,
+                        answeredAt: stagedAnswer.answeredAt,
+                        conductorTurn: sendCount + 1,
+                        openQuestions,
+                        escalations,
+                        eventQueue,
+                        sessionLogger,
+                        onEscalated: (record) => escalatedRecords.push(record),
+                        onOperatorMessageQueued: (event) => {
+                            let receipt;
+                            dispatchReceipt = new Promise((resolve, reject) => {
+                                receipt = {
+                                    resolve: () => resolve(),
+                                    reject: (error) => reject(error),
+                                };
+                                openQuestionDispatchReceipts.set(event, receipt);
+                                pendingOpenQuestionDispatchReceipts.add(receipt);
+                            });
+                            void dispatchReceipt.catch(() => { });
+                        },
+                    });
+                    answered = openQuestions.get(questionId);
+                    if (!accepted || !answered || answered.status !== 'answered') {
+                        await persistOpenQuestionsSnapshot(openQuestions.snapshot());
+                        accepted = false;
+                        return;
+                    }
+                    try {
+                        await persistSessionSidecar(openQuestions.snapshot());
+                    }
+                    catch (error) {
+                        // YAML is authoritative and is already durable. Keep the accepted
+                        // answer/notification, report the mirror failure, then repair it.
+                        sidecarWriteError = error;
+                    }
+                });
+                if (!accepted || !answered || answered.status !== 'answered') {
+                    throw new OpenQuestionControlOperationError(-32004, 'Open Question could not be answered.');
+                }
+                for (const record of escalatedRecords) {
+                    try {
+                        options.onEscalated?.(record);
+                    }
+                    catch (error) {
+                        const detail = error instanceof Error ? error.message : String(error);
+                        sessionLogger.emit({
+                            type: 'harness.warning',
+                            message: `Open Question observer callback failed: ${detail}`,
+                        });
+                    }
+                }
+                if (sidecarWriteError !== undefined) {
+                    reportSessionSidecarWriteFailure(sidecarWriteError);
+                    scheduleSidecarFlush();
+                }
+                if (!dispatchReceipt) {
+                    throw new OpenQuestionControlOperationError(-32603, 'The answer was recorded, but its conductor notification was not queued. The outcome is unknown; do not resubmit the answer and inspect the session state.', RECORDED_ANSWER_UNKNOWN_DISPATCH);
+                }
+                await dispatchReceipt;
+                return answered;
+            },
+        });
+        harnessSocketPath = openQuestionControlServer.socketPath;
+        await flushSidecar().catch(reportSidecarFlushFailure);
         const driverResult = await runConductorSessionDriver({
             issueUrl: options.issueUrl,
             initialPrompt: conductorBackend === 'pi'
@@ -788,6 +1204,23 @@ export async function runConductorSession(options) {
                 });
             },
             onSendComplete: recordSendComplete,
+            onDispatchBatchSettled: ({ events, result, error }) => {
+                for (const event of events) {
+                    if (event.type !== 'operator.message')
+                        continue;
+                    const receipt = openQuestionDispatchReceipts.get(event);
+                    if (!receipt)
+                        continue;
+                    openQuestionDispatchReceipts.delete(event);
+                    pendingOpenQuestionDispatchReceipts.delete(receipt);
+                    if (error || result?.status !== 'finished') {
+                        receipt.reject(new OpenQuestionControlOperationError(-32005, 'The answer was recorded and persisted, but conductor notification could not be confirmed. The outcome is unknown; do not resubmit the answer and inspect the session state.', RECORDED_ANSWER_UNKNOWN_DISPATCH));
+                    }
+                    else {
+                        receipt.resolve();
+                    }
+                }
+            },
             onOpenQuestionEnqueued: (question) => {
                 sessionLogger.emit({ type: 'open.question.enqueued', question });
                 options.onOpenQuestionEnqueued?.(question);
@@ -869,14 +1302,28 @@ export async function runConductorSession(options) {
                 agentId: conductorHandle.conductor.agentId,
                 escalations,
                 openQuestions: openQuestions.list(),
-                sessionUsage: sessionUsage.totals.rounds > 0 || sessionUsage.cost != null
+                sessionUsage: sessionUsage.totals.rounds > 0 ||
+                    sessionUsage.cost != null ||
+                    sessionUsage.compactionCount != null
                     ? sessionUsage
                     : undefined,
             });
         }
     }
     finally {
+        const lifecycle = operatorRequestedClose
+            ? 'closed'
+            : operatorRequestedExit
+                ? 'exited'
+                : shutdownSignal.aborted
+                    ? 'interrupted'
+                    : 'unknown';
+        terminalLifecycle = lifecycle;
         teardownStarted = true;
+        for (const receipt of pendingOpenQuestionDispatchReceipts) {
+            receipt.reject(new OpenQuestionControlOperationError(-32005, 'The answer was recorded and persisted, but the conductor session stopped before notification completed. The outcome is unknown; do not resubmit the answer and inspect the session state.', RECORDED_ANSWER_UNKNOWN_DISPATCH));
+        }
+        pendingOpenQuestionDispatchReceipts.clear();
         const forceShutdown = operatorRequestedExit ||
             operatorRequestedClose ||
             shutdownSignal.aborted;
@@ -902,6 +1349,24 @@ export async function runConductorSession(options) {
             sessionLogger.emit({ type: 'harness.teardown.phase', phase });
         };
         try {
+            const activeControlServer = openQuestionControlServer;
+            openQuestionControlServer = undefined;
+            harnessSocketPath = undefined;
+            if (activeControlServer) {
+                emitTeardownPhase('openQuestionControl');
+                const phaseStart = Date.now();
+                try {
+                    await activeControlServer.close();
+                }
+                catch (error) {
+                    const detail = error instanceof Error ? error.message : String(error);
+                    sessionLogger.emit({
+                        type: 'harness.warning',
+                        message: `Open Question control socket cleanup failed: ${detail}`,
+                    });
+                }
+                teardownPhases.openQuestionControl = Date.now() - phaseStart;
+            }
             disposeOperatorInput?.();
             if (permissionDeadlockMonitor) {
                 emitTeardownPhase('permissionDeadlockMonitor');
@@ -955,14 +1420,9 @@ export async function runConductorSession(options) {
                 teardownPhases.flushSidecar = Date.now() - phaseStart;
             }
             catch (error) {
-                if (operatorRequestedClose) {
-                    const detail = error instanceof Error ? error.message : String(error);
-                    sessionLogger.emit({
-                        type: 'harness.warning',
-                        message: `/close 時に sidecar を保存できませんでした。最新状態から再開できず、直前に保存された状態からの再開になる場合があります。 error=${detail}`,
-                    });
-                }
+                reportSidecarFlushFailure(error);
             }
+            await flushToolCallHistoryBestEffort();
             const runGithubMonitorStop = async () => {
                 if (!githubMonitor || githubMonitorStopped) {
                     return;
@@ -1006,6 +1466,9 @@ export async function runConductorSession(options) {
                 await runWorkerStop();
                 await runConductorClose();
             }
+            // ACP updates can arrive while cancellation and bridge shutdown settle.
+            // Flush once more after all workers stop to capture their final snapshot.
+            await flushToolCallHistoryBestEffort();
             sessionLogger.emit({
                 type: 'harness.teardown',
                 force: forceShutdown,
@@ -1021,17 +1484,19 @@ export async function runConductorSession(options) {
             }
         }
         finally {
+            try {
+                emitTeardownPhase('flushSidecar');
+                await sessionStateWriteQueue;
+                await flushSidecar(lifecycle);
+            }
+            catch (error) {
+                reportSidecarFlushFailure(error);
+            }
             process.off('SIGINT', onTeardownSignal);
             process.off('SIGTERM', onTeardownSignal);
         }
     }
 }
-export function createConductorAgentFactory(backend) {
-    if (backend === 'cursor') {
-        return createCursorSdkConductorAgentFactory();
-    }
-    return createPiConductorAgentFactory();
-}
 function createPiKickoffPrompt(issueUrl) {
     return (`Start the conductor workflow for ${issueUrl}. ` +
         'Review the Issue context in your system instructions and dispatch the first required worker with prompt_worker.');