@agents-ensemble/core 0.17.2 → 0.19.0

package/dist/conductor/conductor-session.js

@@ -1,4 +1,4 @@
-import { computeEnsembleConfigDigest } from '../config/ensemble-config-digest.js';
+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';
 import { createAnswerOpenQuestionTool } from '../escalation/answer-open-question-tool.js';
@@ -25,8 +25,10 @@ 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 { isConductorAgentFactoryCleanupIncomplete } from './conductor-agent-factory-cleanup.js';
 import { ConductorToolRegistry } from './conductor-tool.js';
 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 { SessionLogger } from './session/session-logger.js';
@@ -40,6 +42,7 @@ 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 { buildSessionModelsSummary, } from '../session/build-session-models-summary.js';
 import { saveSessionStatusLine, sessionStateStorePath, loadSessionStateStore, legacySessionStateStorePath, } 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';
@@ -50,6 +53,7 @@ import { SessionUsageTracker } from '../usage/session-usage-tracker.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';
+import { CONDUCTOR_MODEL_ID_ENV, DEFAULT_CONDUCTOR_MODEL_ID, resolveConductorModelId, } from './resolve-conductor-model-id.js';
 import { GitHubMonitorError } from '../github/github-monitor-error.js';
 import { formatGitHubErrorMessage, GITHUB_AUTH_HINT, } from '../github/github-auth.js';
 import { fetchIssueContext } from '../github/issue-context.js';
@@ -66,12 +70,86 @@ const RECORDED_ANSWER_UNKNOWN_DISPATCH = {
     answerStatus: 'recorded',
     dispatchStatus: 'unknown',
 };
+/** Acquired resources are released here until the session teardown takes ownership. */
+class StartupCleanupGuard {
+    actions = [];
+    handedOff = false;
+    cleanupFailed = false;
+    reportCleanupError = () => { };
+    get hasFailures() {
+        return this.cleanupFailed;
+    }
+    add(action) {
+        if (this.handedOff) {
+            throw new Error('Cannot register startup cleanup after session handoff');
+        }
+        this.actions.push(action);
+    }
+    setErrorReporter(report) {
+        this.reportCleanupError = report;
+    }
+    recordCleanupFailure(error) {
+        this.cleanupFailed = true;
+        try {
+            this.reportCleanupError(error);
+        }
+        catch {
+            // Keep the startup error as the rejection reason if reporting fails.
+        }
+    }
+    handoff() {
+        this.handedOff = true;
+        this.actions.length = 0;
+    }
+    async cleanup() {
+        if (this.handedOff)
+            return;
+        this.handedOff = true;
+        for (const action of this.actions.reverse()) {
+            try {
+                await action();
+            }
+            catch (error) {
+                this.recordCleanupFailure(error);
+            }
+        }
+    }
+}
 export async function runConductorSession(options) {
+    const startupCleanup = new StartupCleanupGuard();
+    try {
+        return await runConductorSessionWithStartupGuard(options, startupCleanup);
+    }
+    catch (error) {
+        await startupCleanup.cleanup();
+        throw error;
+    }
+}
+async function runConductorSessionWithStartupGuard(options, startupCleanup) {
     const userInstructions = await loadUserInstructions({
         userEnsembleRoot: options.mcpConfigOptions?.userEnsembleRoot,
     });
     const ensembleConfig = options.ensembleConfig ?? (await loadEnsembleConfig(options.repoRoot));
-    const ensembleConfigDigest = computeEnsembleConfigDigest(ensembleConfig);
+    let ensembleConfigDigestScheme = 'resume-feasibility';
+    let ensembleConfigDigest = computeResumeFeasibilityConfigDigest(ensembleConfig);
+    let acpModelConfigDigest = computeAcpModelConfigDigest(ensembleConfig);
+    const resolvedConductorModelId = resolveConductorModelId(options.modelId, {
+        config: ensembleConfig,
+    });
+    const hasInvocationModelOverride = Boolean(options.modelId?.trim() ||
+        process.env[CONDUCTOR_MODEL_ID_ENV]?.trim());
+    // Built-in factories understand `default` as their backend default. For a
+    // custom factory, preserve the optional contract when the default comes
+    // from config/code defaults. Keep an invocation-level `default` sentinel so
+    // the factory can honor it over its own lower-priority defaults.
+    const conductorFactoryModelId = options.conductorAgentFactory &&
+        resolvedConductorModelId === DEFAULT_CONDUCTOR_MODEL_ID &&
+        !hasInvocationModelOverride
+        ? undefined
+        : resolvedConductorModelId;
+    const conductorReasoning = resolveConductorReasoning(options.reasoning, {
+        config: ensembleConfig,
+    });
     const conductorBackend = resolveConductorBackendSetting({
         profile: options.profile,
         config: ensembleConfig,
@@ -82,6 +160,13 @@ export async function runConductorSession(options) {
             issueUrl: options.issueUrl,
             repoRoot: options.repoRoot,
         });
+    startupCleanup.setErrorReporter((error) => {
+        const detail = error instanceof Error ? error.message : String(error);
+        sessionLogger.emit({
+            type: 'harness.warning',
+            message: `起動失敗後の後始末に失敗しました: ${detail}`,
+        });
+    });
     attachLegacySessionCallbacks(sessionLogger, options);
     const expiredHistory = await pruneExpiredToolCallSnapshotHistoryFiles(options.repoRoot);
     if (expiredHistory.failedCount > 0) {
@@ -123,6 +208,7 @@ export async function runConductorSession(options) {
     let githubMonitor;
     let activeResumeStorePath;
     let activeStoreLocation = 'user-path-hash';
+    let drainStartupResumeStoreWrites = async () => { };
     const pendingGitHubRecoveries = [];
     const conductorCwd = options.conductorCwd ?? process.cwd();
     let cursorBootstrapRunId;
@@ -139,6 +225,11 @@ export async function runConductorSession(options) {
         const loadedResumeStore = locatedResumeStore.resumeStore;
         activeResumeStorePath = locatedResumeStore.path;
         activeStoreLocation = locatedResumeStore.location;
+        const savedConfigDigestScheme = loadedResumeStore.ensembleConfigDigestScheme;
+        const effectiveConfigDigestScheme = savedConfigDigestScheme ?? 'full';
+        const currentEnsembleConfigDigest = effectiveConfigDigestScheme === 'resume-feasibility'
+            ? computeResumeFeasibilityConfigDigest(ensembleConfig)
+            : computeEnsembleConfigDigest(ensembleConfig);
         assertSessionResumeStoreMatches(loadedResumeStore, {
             conductorAgentId: options.resumeAgentId,
             issueUrl: options.issueUrl,
@@ -146,7 +237,7 @@ export async function runConductorSession(options) {
             conductorBackend,
             mcpConfigDigest,
             mcpConfigConfigured,
-            ensembleConfigDigest,
+            ensembleConfigDigest: currentEnsembleConfigDigest,
         });
         if (loadedResumeStore.ensembleConfigDigest === undefined) {
             sessionLogger.emit({
@@ -154,10 +245,31 @@ export async function runConductorSession(options) {
                 message: 'SessionResumeStore has no ensemble config digest; config consistency cannot be verified for this legacy session.',
             });
         }
+        const hasComparableLegacyFullDigest = effectiveConfigDigestScheme === 'full' &&
+            loadedResumeStore.ensembleConfigDigest !== undefined;
+        if (loadedResumeStore.acpModelConfigDigest === undefined &&
+            !hasComparableLegacyFullDigest) {
+            sessionLogger.emit({
+                type: 'harness.warning',
+                message: 'SessionResumeStore has no ACP model config digest; this diagnostic metadata is unavailable and will not be backfilled. Resume is not blocked by its absence.',
+            });
+        }
+        // Keep the persisted scheme and digest paired across resume and flush.
+        // Legacy stores without a digest remain unverifiable until a new session
+        // is started; a resume must not silently relabel their existing state.
+        ensembleConfigDigestScheme = savedConfigDigestScheme;
+        ensembleConfigDigest = loadedResumeStore.ensembleConfigDigest;
+        // This digest describes the config used when the session was first
+        // recorded. Keep it as diagnostic metadata; model changes do not gate
+        // resume, and a missing legacy value must not be backfilled.
+        acpModelConfigDigest = loadedResumeStore.acpModelConfigDigest;
         // 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 SessionResumeStore flush cannot leave stale
-        // `closed` / `exited` data behind.
+        // a crash during backend resume cannot leave stale `closed` / `exited` data
+        // behind. Startup cleanup restores the previous record only if every
+        // acquired resource is released successfully; otherwise keep this record
+        // marked unknown/running so it does not claim a possibly active session is
+        // closed.
         const resumeStore = {
             ...loadedResumeStore,
             lifecycle: 'unknown',
@@ -169,7 +281,22 @@ export async function runConductorSession(options) {
         cursorBootstrapRunId = loadedResumeStore.cursorBootstrapRunId;
         harnessPhase = 'running';
         harnessModifiedAt = resumeStore.modifiedAt;
+        let resumeStoreActivationCommitted = false;
+        startupCleanup.add(async () => {
+            if (!resumeStoreActivationCommitted)
+                return;
+            await drainStartupResumeStoreWrites();
+            if (startupCleanup.hasFailures) {
+                sessionLogger.emit({
+                    type: 'harness.warning',
+                    message: '起動失敗後の後始末が完了しなかったため、再開記録を unknown/running のまま保ちます。',
+                });
+                return;
+            }
+            await saveSessionResumeStore(locatedResumeStore.path, loadedResumeStore);
+        });
         await saveSessionResumeStore(activeResumeStorePath, resumeStore);
+        resumeStoreActivationCommitted = true;
         const history = await loadToolCallSnapshotHistory({
             repoRoot: options.repoRoot,
             conductorAgentId: options.resumeAgentId,
@@ -334,22 +461,22 @@ export async function runConductorSession(options) {
         shutdownIntentController.abort();
         abortAfterOpenQuestionDrain(drainedShutdownController);
     };
+    let unregisterProcessSignalHandlers = () => { };
+    const removeShutdownDrainListener = () => shutdownSignal.removeEventListener('abort', onShutdownSignal);
+    const onSignal = () => shutdownController.abort();
+    unregisterProcessSignalHandlers = () => {
+        process.off('SIGINT', onSignal);
+        process.off('SIGTERM', onSignal);
+        removeShutdownDrainListener();
+    };
+    startupCleanup.add(() => unregisterProcessSignalHandlers());
     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();
         process.once('SIGINT', onSignal);
         process.once('SIGTERM', onSignal);
-        unregisterProcessSignalHandlers = () => {
-            process.off('SIGINT', onSignal);
-            process.off('SIGTERM', onSignal);
-            removeShutdownDrainListener();
-        };
     }
     const permissionPipeline = options.permissionPipeline ??
         new PermissionPipeline({ policy: options.permissionPolicy });
@@ -598,33 +725,7 @@ export async function runConductorSession(options) {
             });
         },
     });
-    if (workers.length > 0 && !activeLazyWorkers) {
-        sessionLogger.emit({
-            type: 'harness.worker.bootstrap',
-            workers: workers.map((worker) => ({
-                name: worker.name,
-                kind: worker.kind,
-            })),
-            mode: 'init',
-        });
-    }
-    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.`,
-            });
-        }
-    }
+    startupCleanup.add(() => workerSession.stop({ force: true }));
     const recordAnsweredQuestion = (answered) => {
         const record = openQuestionToEscalationRecord(answered);
         if (record) {
@@ -778,7 +879,10 @@ export async function runConductorSession(options) {
             ? { piSkills: activeProfile.conductor?.piSkills !== false }
             : {}),
         apiKey: options.apiKey,
-        modelId: options.modelId,
+        modelId: conductorFactoryModelId,
+        ...(conductorReasoning !== undefined
+            ? { reasoning: conductorReasoning }
+            : {}),
         ...(conductorBackend === 'pi'
             ? {
                 pi: resolveConductorPiResourcePaths({
@@ -808,9 +912,29 @@ export async function runConductorSession(options) {
             pi: conductorOptions.pi,
         })) || undefined
         : undefined;
-    conductorAgent = options.resumeAgentId
-        ? await conductorAgentFactory.resume(options.resumeAgentId, conductorOptions)
-        : await conductorAgentFactory.create(conductorOptions);
+    shutdownSignal.throwIfAborted();
+    try {
+        conductorAgent = options.resumeAgentId
+            ? await conductorAgentFactory.resume(options.resumeAgentId, conductorOptions)
+            : await conductorAgentFactory.create(conductorOptions);
+    }
+    catch (error) {
+        if (isConductorAgentFactoryCleanupIncomplete(error)) {
+            startupCleanup.recordCleanupFailure(error);
+        }
+        throw error;
+    }
+    startupCleanup.add(async () => {
+        if (options.resumeAgentId && conductorAgent.closeForResume) {
+            await conductorAgent.closeForResume();
+        }
+        else {
+            await conductorAgent.close();
+        }
+    });
+    // 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();
     const conductorHandle = { conductor: conductorAgent };
     activeResumeStorePath ??= sessionResumeStorePath({
         repoRoot: options.repoRoot,
@@ -844,6 +968,9 @@ export async function runConductorSession(options) {
         },
     };
     let sessionResumeStoreWriteQueue = Promise.resolve();
+    drainStartupResumeStoreWrites = async () => {
+        await sessionResumeStoreWriteQueue;
+    };
     let terminalLifecycle;
     let terminalResumeStoreFinalFlushQueued = false;
     const enqueueSessionResumeStoreWrite = (write) => {
@@ -887,7 +1014,15 @@ export async function runConductorSession(options) {
             sequence: snapshot.sequence,
             workers,
             mcpConfigDigest,
-            ensembleConfigDigest,
+            ...(ensembleConfigDigestScheme !== undefined
+                ? { ensembleConfigDigestScheme }
+                : {}),
+            ...(ensembleConfigDigest !== undefined
+                ? { ensembleConfigDigest }
+                : {}),
+            ...(acpModelConfigDigest !== undefined
+                ? { acpModelConfigDigest }
+                : {}),
             ...(persistedLifecycle ? { lifecycle: persistedLifecycle } : {}),
             ...(githubMonitorCursor ? { githubMonitor: githubMonitorCursor } : {}),
             updatedAt: Date.now(),
@@ -1033,8 +1168,6 @@ export async function runConductorSession(options) {
             emitToolCallHistoryFlushWarning();
         }
     };
-    if (toolCallHistoryDirty)
-        scheduleToolCallHistoryFlush();
     let sendCount = 0;
     let autonomousTurns = 0;
     const monitorDefaults = ensembleConfig.github.monitor;
@@ -1111,6 +1244,9 @@ export async function runConductorSession(options) {
                 }
             },
         });
+        startupCleanup.add(async () => {
+            await githubMonitor?.stop();
+        });
         githubMonitor.start();
     }
     dispatchHoldReminderMonitor = createDispatchHoldReminderMonitor({
@@ -1127,17 +1263,12 @@ export async function runConductorSession(options) {
         reminderIntervalMs: options.dispatchHoldReminderMs,
         shutdownSignal,
     });
+    startupCleanup.add(() => dispatchHoldReminderMonitor.stop());
     dispatchHoldReminderMonitor.start();
     let permissionDeadlockMonitor;
     if (!options.disablePermissionDeadlockMonitor) {
         permissionDeadlockMonitor = createPermissionDeadlockMonitor({
             pipeline: permissionPipeline,
-            getActivitySnapshot: () => ({
-                attachInFlight: workerSession.runtime.attachInFlightCount,
-                hasProcessingWorker: workerSession.runtime
-                    .listWorkerStatuses()
-                    .some((worker) => worker.state === 'processing'),
-            }),
             onWarning: (message) => {
                 sessionLogger.emit({ type: 'harness.warning', message });
             },
@@ -1156,6 +1287,7 @@ export async function runConductorSession(options) {
             pollIntervalMs: options.permissionDeadlockPollMs,
             shutdownSignal,
         });
+        startupCleanup.add(() => permissionDeadlockMonitor.stop());
         permissionDeadlockMonitor.start();
     }
     let stopReason = 'completed';
@@ -1266,9 +1398,43 @@ export async function runConductorSession(options) {
         });
         if (typeof bindingDispose === 'function') {
             disposeOperatorInput = bindingDispose;
+            startupCleanup.add(() => disposeOperatorInput?.());
         }
     }
     try {
+        if (workers.length > 0 && !activeLazyWorkers) {
+            sessionLogger.emit({
+                type: 'harness.worker.bootstrap',
+                workers: workers.map((worker) => ({
+                    name: worker.name,
+                    kind: worker.kind,
+                })),
+                mode: 'init',
+            });
+        }
+        // Keep startup cleanup active through startup logging and the final
+        // shutdown check. No await follows before workers start.
+        shutdownSignal.throwIfAborted();
+        startupCleanup.handoff();
+        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.`,
+                });
+            }
+        }
+        if (toolCallHistoryDirty)
+            scheduleToolCallHistoryFlush();
         openQuestionControlServer = await startOpenQuestionControlServer({
             listOpenQuestions: () => openQuestions.listOpen(),
             getLastConductorMessage: () => lastConductorMessage,
@@ -1615,6 +1781,14 @@ export async function runConductorSession(options) {
                 agentId: conductorHandle.conductor.agentId,
                 escalations,
                 openQuestions: openQuestions.list(),
+                sessionModels: buildSessionModelsSummary({
+                    backend: conductorBackend,
+                    explicitConductorModelId: resolvedConductorModelId,
+                    explicitConductorReasoning: conductorReasoning,
+                    config: ensembleConfig,
+                    workers,
+                    usageTracker: sessionUsageTracker,
+                }),
                 sessionUsage: sessionUsage.totals.rounds > 0 ||
                     sessionUsage.cost != null ||
                     sessionUsage.compactionCount != null