@agents-ensemble/core 0.11.0 → 0.13.0

package/dist/conductor/conductor-session.js

@@ -9,20 +9,23 @@ 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';
@@ -31,8 +34,12 @@ import { bufferDispatchHoldEvents, createDispatchHoldState, pruneStalePermission
 import { operatorInputMaxTurns, resolveMaxTurns, } from './session-policy.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 { assertSessionSidecarMatches, requireSessionSidecarForResume, saveSessionSidecar, SESSION_SIDECAR_VERSION, sessionSidecarPath, } from '../session/session-sidecar.js';
+import { loadToolCallSnapshotHistory, pruneExpiredToolCallSnapshotHistoryFiles, saveToolCallSnapshotHistory, toolCallSnapshotHistoryPath, } from '../session/tool-call-snapshot-history.js';
+import { loadOpenQuestionsStore, openQuestionsStorePath, saveOpenQuestionsStore, } from '../session/open-questions-store.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 { submitOperatorInput } from './submit-operator-input.js';
@@ -63,6 +70,13 @@ 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();
     const eventQueue = new SessionEventQueue();
@@ -83,10 +97,13 @@ 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({
             repoRoot: options.repoRoot,
@@ -100,10 +117,43 @@ export async function runConductorSession(options) {
             mcpConfigDigest,
             mcpConfigConfigured,
         });
-        openQuestions.restore({
-            sequence: sidecar.sequence,
-            openQuestions: sidecar.openQuestions,
+        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;
@@ -145,10 +195,10 @@ export async function runConductorSession(options) {
         ? new AbortController()
         : undefined;
     const shutdownSignal = options.shutdownSignal ?? shutdownController.signal;
-    const operatorExitController = new AbortController();
+    const operatorTerminationController = new AbortController();
     const driverShutdownSignal = AbortSignal.any([
         shutdownSignal,
-        operatorExitController.signal,
+        operatorTerminationController.signal,
     ]);
     let unregisterProcessSignalHandlers = () => { };
     if (ownsShutdownController &&
@@ -164,6 +214,9 @@ export async function runConductorSession(options) {
     const permissionPipeline = options.permissionPipeline ??
         new PermissionPipeline({ policy: options.permissionPolicy });
     let scheduleSidecarFlush = () => { };
+    let scheduleToolCallHistoryFlush = () => { };
+    let flushToolCallHistory = async () => { };
+    let toolCallHistoryDirty = toolCallHistoryNeedsRewrite;
     const sessionState = sessionStateFromProfile(activeProfile);
     const issue = parseIssueUrl(options.issueUrl);
     const spawnBase = {
@@ -214,7 +267,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,
@@ -244,12 +301,28 @@ export async function runConductorSession(options) {
             const pending = permissionPipeline.pending.get(requestId);
             if (pending) {
                 const workerLabel = workerSession.runtime.resolveWorkerLabel(workerId) ?? workerId;
+                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,
                     workerLabel,
                 });
-                eventQueue.enqueue({ type: 'permission.pending', permission: pending });
+                eventQueue.enqueue({
+                    type: 'permission.pending',
+                    permission: pending,
+                    worker: workerLabel,
+                    brief: buildPermissionBrief(pending.request, toolCallSnapshot),
+                    operatorSummary,
+                });
             }
             return null;
         },
@@ -322,6 +395,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,
@@ -360,6 +463,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) {
@@ -388,6 +507,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) => {
@@ -438,6 +560,7 @@ export async function runConductorSession(options) {
             return usage.cost;
         },
     });
+    const reportSessionStateTool = createReportSessionStateTool();
     const dispatchHoldTools = createSetDispatchHoldTool({
         state: dispatchHoldState,
         onChanged: onDispatchHoldChanged,
@@ -461,11 +584,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,
@@ -486,6 +611,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({
@@ -553,6 +683,10 @@ export async function runConductorSession(options) {
                 ...(githubMonitorCursor ? { githubMonitor: githubMonitorCursor } : {}),
                 updatedAt: Date.now(),
             };
+            await saveOpenQuestionsStore(openQuestionsStorePath({
+                repoRoot: options.repoRoot,
+                conductorAgentId: conductorHandle.conductor.agentId,
+            }), snapshot);
             await saveSessionSidecar(sessionSidecarPath({
                 repoRoot: options.repoRoot,
                 conductorAgentId: conductorHandle.conductor.agentId,
@@ -561,11 +695,68 @@ export async function runConductorSession(options) {
         sidecarFlushQueue = nextFlush.catch(() => { });
         return nextFlush;
     };
+    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}`,
+        });
+    };
     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;
@@ -592,6 +783,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,
@@ -617,6 +816,22 @@ export async function runConductorSession(options) {
                     message,
                 });
             },
+            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();
     }
@@ -654,6 +869,7 @@ export async function runConductorSession(options) {
     const continueOnConductorError = options.continueOnConductorError ?? false;
     const waitForOperatorExit = options.waitForOperatorExit ?? false;
     let operatorRequestedExit = false;
+    let operatorRequestedClose = false;
     let disposeOperatorInput;
     if (options.bindOperatorInput) {
         const bindingDispose = options.bindOperatorInput({
@@ -662,7 +878,14 @@ export async function runConductorSession(options) {
                     sessionLogger.emit({ type: 'session.operator_exit' });
                     workerSession.runtime.cancelAllActivePrompts();
                     operatorRequestedExit = true;
-                    operatorExitController.abort();
+                    operatorTerminationController.abort();
+                    return false;
+                }
+                if (isOperatorCloseCommand(message)) {
+                    sessionLogger.emit({ type: 'session.operator_close' });
+                    workerSession.runtime.cancelAllActivePrompts();
+                    operatorRequestedClose = true;
+                    operatorTerminationController.abort();
                     return false;
                 }
                 if (isOperatorReconnectCommand(message)) {
@@ -764,13 +987,20 @@ export async function runConductorSession(options) {
         stopReason = driverResult.stopReason;
         sendCount = driverResult.sendCount;
         autonomousTurns = driverResult.autonomousTurns;
-        if (operatorRequestedExit && stopReason === 'interrupted') {
+        if ((operatorRequestedExit || operatorRequestedClose) &&
+            stopReason === 'interrupted') {
             stopReason = 'completed';
         }
         return await buildResult();
         function recordSendComplete(info) {
             sendCount = info.sendCount;
             autonomousTurns = info.autonomousTurns;
+            const githubUpdateIds = info.githubUpdateIds ?? [];
+            if (info.status === 'finished' &&
+                !operatorRequestedClose &&
+                githubUpdateIds.length > 0) {
+                githubMonitor?.acknowledgeUpdates?.(githubUpdateIds);
+            }
             sessionUsageTracker.recordConductorRound({
                 runId: info.runId,
                 status: info.status,
@@ -817,7 +1047,9 @@ export async function runConductorSession(options) {
         }
         async function buildResult() {
             sessionLogger.finish(stopReason);
-            const skipUsageCostFetch = operatorRequestedExit || shutdownSignal.aborted;
+            const skipUsageCostFetch = operatorRequestedExit ||
+                operatorRequestedClose ||
+                shutdownSignal.aborted;
             const sessionUsage = await enrichSessionUsageWithCost(sessionUsageTracker.getSessionSummary(), skipUsageCostFetch
                 ? undefined
                 : async () => {
@@ -828,7 +1060,9 @@ 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,
             });
@@ -836,7 +1070,9 @@ export async function runConductorSession(options) {
     }
     finally {
         teardownStarted = true;
-        const forceShutdown = operatorRequestedExit || shutdownSignal.aborted;
+        const forceShutdown = operatorRequestedExit ||
+            operatorRequestedClose ||
+            shutdownSignal.aborted;
         const teardownStartedAt = Date.now();
         const teardownPhases = {};
         unregisterProcessSignalHandlers();
@@ -864,12 +1100,27 @@ export async function runConductorSession(options) {
                 emitTeardownPhase('permissionDeadlockMonitor');
                 permissionDeadlockMonitor.stop();
             }
-            if (githubMonitor) {
+            if (githubMonitor && !operatorRequestedClose) {
                 githubMonitor.flush();
             }
             // Stop active prompts before closing ACP bridges. Requests that arrive
             // 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()) {
+                    workerSessions.set(attached.name, {
+                        acpSessionId: attached.session.sessionId,
+                        acpCwd: attached.session.acpCwd,
+                        ...(workerAcpFingerprints.get(attached.name)
+                            ? { acpSpawn: workerAcpFingerprints.get(attached.name) }
+                            : {}),
+                    });
+                }
+            }
             const rejectedPendingPermissions = rejectAllPendingPermissions(permissionPipeline, workerSession.inbox);
             if (rejectedPendingPermissions.length > 0) {
                 sessionLogger.emit({
@@ -881,17 +1132,27 @@ export async function runConductorSession(options) {
                     })),
                 });
             }
+            let githubMonitorStopped = false;
+            if (githubMonitor && operatorRequestedClose) {
+                emitTeardownPhase('githubMonitor');
+                const phaseStart = Date.now();
+                await githubMonitor.stop();
+                githubMonitorCursor = githubMonitor.getCursor();
+                teardownPhases.githubMonitor = Date.now() - phaseStart;
+                githubMonitorStopped = true;
+            }
             try {
                 emitTeardownPhase('flushSidecar');
                 const phaseStart = Date.now();
                 await flushSidecar();
                 teardownPhases.flushSidecar = Date.now() - phaseStart;
             }
-            catch {
-                // best-effort persistence
+            catch (error) {
+                reportSidecarFlushFailure(error);
             }
+            await flushToolCallHistoryBestEffort();
             const runGithubMonitorStop = async () => {
-                if (!githubMonitor) {
+                if (!githubMonitor || githubMonitorStopped) {
                     return;
                 }
                 emitTeardownPhase('githubMonitor');
@@ -909,7 +1170,12 @@ export async function runConductorSession(options) {
             const runConductorClose = async () => {
                 emitTeardownPhase('conductor');
                 const phaseStart = Date.now();
-                await conductorHandle.conductor.close();
+                if (operatorRequestedClose && conductorHandle.conductor.closeForResume) {
+                    await conductorHandle.conductor.closeForResume();
+                }
+                else {
+                    await conductorHandle.conductor.close();
+                }
                 teardownPhases.conductor = Date.now() - phaseStart;
             };
             if (forceShutdown) {
@@ -928,6 +1194,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,
@@ -948,12 +1217,6 @@ export async function runConductorSession(options) {
         }
     }
 }
-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.');