@agents-ensemble/core 0.14.0 → 0.15.0

package/dist/conductor/conductor-session.js

@@ -31,20 +31,22 @@ import { resolvePiConductorProvider } from './conductor-pi-auth.js';
 import { SessionLogger } from './session/session-logger.js';
 import { SessionEventQueue } from './session/session-event-queue.js';
 import { bufferDispatchHoldEvents, createDispatchHoldState, pruneStalePermissionEvents, } from './session/dispatch-hold.js';
+import { createDispatchHoldReminderMonitor, formatDispatchHoldReminderMessage, } from './session/dispatch-hold-reminder-monitor.js';
 import { operatorInputMaxTurns, resolveMaxTurns, } from './session-policy.js';
 import { runConductorSessionDriver } from './conductor-session-driver.js';
 import { 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 { parseOperatorMessageDelivery } from './operator-command.js';
+import { assertSessionResumeStoreMatches, requireSessionResumeStoreForResume, saveSessionResumeStore, SESSION_RESUME_STORE_VERSION, sessionResumeStorePath, } from '../session/session-resume-store.js';
+import { saveSessionStatusLine, sessionStateStorePath, loadSessionStateStore, } from '../session/session-state-store.js';
 import { loadToolCallSnapshotHistory, pruneExpiredToolCallSnapshotHistoryFiles, saveToolCallSnapshotHistory, toolCallSnapshotHistoryPath, } from '../session/tool-call-snapshot-history.js';
 import { loadOpenQuestionsStore, openQuestionsStorePath, saveOpenQuestionsStore, } from '../session/open-questions-store.js';
-import { OpenQuestionControlOperationError, startOpenQuestionControlServer, } from '../session/open-question-control.js';
+import { CONDUCTOR_MESSAGE_HISTORY_MAX_ENTRIES, OpenQuestionControlOperationError, startOpenQuestionControlServer, } from '../session/open-question-control.js';
 import { formatPermissionSummaryForOperator } from '../permission/format-permission-summary-for-operator.js';
 import { enrichSessionUsageWithCost } from '../usage/enrich-session-usage-cost.js';
 import { SessionUsageTracker } from '../usage/session-usage-tracker.js';
-import { submitOperatorInput } from './submit-operator-input.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 { GitHubMonitorError } from '../github/github-monitor-error.js';
@@ -88,11 +90,17 @@ export async function runConductorSession(options) {
     const escalations = [];
     const openQuestions = new OpenQuestionRegistry();
     let harnessSocketPath;
+    let harnessPhase;
+    let harnessModifiedAt;
+    let reportHarnessActivity = () => { };
     let openQuestionControlServer;
+    let lastConductorMessage = null;
+    const conductorMessages = [];
     const eventQueue = new SessionEventQueue();
     const openQuestionDispatchReceipts = new WeakMap();
     const pendingOpenQuestionDispatchReceipts = new Set();
     const dispatchHoldState = createDispatchHoldState();
+    let dispatchHoldReminderMonitor;
     const onDispatchHoldChanged = (change) => {
         sessionLogger.emit({
             type: 'conductor.dispatch_hold',
@@ -103,6 +111,7 @@ export async function runConductorSession(options) {
                 ? { flushedEventCount: change.flushedEventCount }
                 : {}),
         });
+        dispatchHoldReminderMonitor?.onHoldChanged(change.hold);
     };
     let activeProfile = options.profile;
     let activeLazyWorkers = ensembleConfig.session.lazyWorkers;
@@ -117,11 +126,11 @@ export async function runConductorSession(options) {
     let resumeToolCallSnapshots = [];
     let toolCallHistoryNeedsRewrite = false;
     if (options.resumeAgentId) {
-        const loadedSidecar = await requireSessionSidecarForResume({
+        const loadedResumeStore = await requireSessionResumeStoreForResume({
             repoRoot: options.repoRoot,
             conductorAgentId: options.resumeAgentId,
         });
-        assertSessionSidecarMatches(loadedSidecar, {
+        assertSessionResumeStoreMatches(loadedResumeStore, {
             conductorAgentId: options.resumeAgentId,
             issueUrl: options.issueUrl,
             repoRoot: options.repoRoot,
@@ -131,18 +140,22 @@ export async function runConductorSession(options) {
         });
         // 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
+        // a crash before the first regular SessionResumeStore flush cannot leave stale
         // `closed` / `exited` data behind.
-        const sidecar = {
-            ...loadedSidecar,
+        const resumeStore = {
+            ...loadedResumeStore,
             lifecycle: 'unknown',
+            harnessPhase: 'running',
+            modifiedAt: Date.now(),
             harnessSocketPath: undefined,
             updatedAt: Date.now(),
         };
-        await saveSessionSidecar(sessionSidecarPath({
+        harnessPhase = 'running';
+        harnessModifiedAt = resumeStore.modifiedAt;
+        await saveSessionResumeStore(sessionResumeStorePath({
             repoRoot: options.repoRoot,
             conductorAgentId: options.resumeAgentId,
-        }), sidecar);
+        }), resumeStore);
         const history = await loadToolCallSnapshotHistory({
             repoRoot: options.repoRoot,
             conductorAgentId: options.resumeAgentId,
@@ -165,8 +178,8 @@ export async function runConductorSession(options) {
         }
         else {
             const legacySnapshot = {
-                sequence: sidecar.sequence,
-                openQuestions: sidecar.openQuestions,
+                sequence: resumeStore.sequence,
+                openQuestions: resumeStore.openQuestions,
             };
             openQuestions.restore(legacySnapshot);
             try {
@@ -176,15 +189,15 @@ export async function runConductorSession(options) {
                 const detail = error instanceof Error ? error.message : String(error);
                 sessionLogger.emit({
                     type: 'harness.warning',
-                    message: `旧 sidecar から復元した open question を YAML にバックフィルできませんでした。今回のセッションは継続します。 error=${detail}`,
+                    message: `旧形式の SessionResumeStore から復元した open question を YAML にバックフィルできませんでした。今回のセッションは継続します。 error=${detail}`,
                 });
             }
         }
-        activeProfile = sidecar.profile;
-        // Sidecars written before this setting always started every worker eagerly.
-        activeLazyWorkers = sidecar.lazyWorkers ?? false;
-        githubMonitorCursor = sidecar.githubMonitor;
-        for (const [name, worker] of Object.entries(sidecar.workers)) {
+        activeProfile = resumeStore.profile;
+        // ResumeStores written before this setting always started every worker eagerly.
+        activeLazyWorkers = resumeStore.lazyWorkers ?? false;
+        githubMonitorCursor = resumeStore.githubMonitor;
+        for (const [name, worker] of Object.entries(resumeStore.workers)) {
             workerSessions.set(name, {
                 acpSessionId: worker.acpSessionId,
                 ...(worker.acpCwd ? { acpCwd: worker.acpCwd } : {}),
@@ -290,8 +303,8 @@ export async function runConductorSession(options) {
     }
     const permissionPipeline = options.permissionPipeline ??
         new PermissionPipeline({ policy: options.permissionPolicy });
-    let scheduleSidecarFlush = () => { };
-    let flushSidecar = async () => { };
+    let scheduleSessionResumeStoreFlush = () => { };
+    let flushSessionResumeStore = async () => { };
     let scheduleToolCallHistoryFlush = () => { };
     let flushToolCallHistory = async () => { };
     let toolCallHistoryDirty = toolCallHistoryNeedsRewrite;
@@ -357,6 +370,7 @@ export async function runConductorSession(options) {
         workers,
         lazyWorkers: activeLazyWorkers,
         sessionState,
+        ...(userInstructions ? { userInstructions } : {}),
         restoredWorkerSessions: Object.fromEntries(workerSessions),
         permissionPipeline,
         ...(options.connectAcp ? { connectAcp: options.connectAcp } : {}),
@@ -433,7 +447,7 @@ export async function runConductorSession(options) {
                     : {}),
             });
             eventQueue.enqueue({ type: 'worker.completed', result });
-            scheduleSidecarFlush();
+            scheduleSessionResumeStoreFlush();
         },
         onWorkerFailed: (failure) => {
             sessionLogger.emit({ type: 'worker.failed', failure });
@@ -442,6 +456,7 @@ export async function runConductorSession(options) {
         onPromptTelemetry: (event) => {
             switch (event.phase) {
                 case 'started':
+                    reportHarnessActivity('worker', true);
                     sessionLogger.emit({
                         type: 'harness.worker.prompt.started',
                         name: event.name,
@@ -451,6 +466,7 @@ export async function runConductorSession(options) {
                     });
                     break;
                 case 'completed':
+                    reportHarnessActivity('worker', false);
                     sessionLogger.emit({
                         type: 'harness.worker.prompt.completed',
                         name: event.name,
@@ -461,6 +477,7 @@ export async function runConductorSession(options) {
                     });
                     break;
                 case 'failed':
+                    reportHarnessActivity('worker', false);
                     sessionLogger.emit({
                         type: 'harness.worker.prompt.failed',
                         name: event.name,
@@ -564,14 +581,14 @@ export async function runConductorSession(options) {
             sessionLogger.emit({ type: 'escalation.recorded', record });
             options.onEscalated?.(record);
         }
-        scheduleSidecarFlush();
+        scheduleSessionResumeStoreFlush();
     };
     const askHumanTools = createAskHumanTool({
         registry: openQuestions,
         onEnqueued: (question) => {
             sessionLogger.emit({ type: 'open.question.enqueued', question });
             options.onOpenQuestionEnqueued?.(question);
-            scheduleSidecarFlush();
+            scheduleSessionResumeStoreFlush();
         },
     });
     const answerOpenQuestionTools = createAnswerOpenQuestionTool({
@@ -618,7 +635,7 @@ export async function runConductorSession(options) {
             // 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();
+            await flushSessionResumeStore();
         },
     });
     const unregisterGitHubWatchTools = createUnregisterGitHubWatchTool({
@@ -629,7 +646,7 @@ export async function runConductorSession(options) {
         },
         onUnregistered: async (prNumber) => {
             githubMonitor?.unregisterPullRequest?.(prNumber);
-            await flushSidecar();
+            await flushSessionResumeStore();
         },
     });
     let conductorAgent;
@@ -749,14 +766,15 @@ export async function runConductorSession(options) {
             });
         },
     };
-    let sidecarFlushQueue = Promise.resolve();
+    let sessionResumeStoreWriteQueue = Promise.resolve();
     let terminalLifecycle;
-    const enqueueSidecarWrite = (write) => {
-        const nextWrite = sidecarFlushQueue.then(write);
-        sidecarFlushQueue = nextWrite.catch(() => { });
+    let terminalResumeStoreFinalFlushQueued = false;
+    const enqueueSessionResumeStoreWrite = (write) => {
+        const nextWrite = sessionResumeStoreWriteQueue.then(write);
+        sessionResumeStoreWriteQueue = nextWrite.catch(() => { });
         return nextWrite;
     };
-    const createSessionSidecar = (snapshot, lifecycle) => {
+    const createSessionResumeStore = (snapshot, lifecycle) => {
         const workers = {};
         for (const [name, worker] of workerSessions) {
             workers[name] = {
@@ -765,8 +783,13 @@ export async function runConductorSession(options) {
                 ...(worker.acpSpawn ? { acpSpawn: worker.acpSpawn } : {}),
             };
         }
+        const persistedLifecycle = terminalLifecycle ??
+            lifecycle ??
+            (harnessPhase === 'running' || harnessPhase === 'idle'
+                ? 'unknown'
+                : undefined);
         return {
-            version: SESSION_SIDECAR_VERSION,
+            version: SESSION_RESUME_STORE_VERSION,
             conductorAgentId: conductorHandle.conductor.agentId,
             conductorBackend,
             lazyWorkers: activeLazyWorkers,
@@ -775,13 +798,15 @@ export async function runConductorSession(options) {
             repoRoot: options.repoRoot,
             profile: structuredClone(activeProfile),
             ...(options.profilePath ? { profilePath: options.profilePath } : {}),
+            ...(harnessPhase ? { harnessPhase } : {}),
+            ...(harnessModifiedAt !== undefined
+                ? { modifiedAt: harnessModifiedAt }
+                : {}),
             openQuestions: snapshot.openQuestions,
             sequence: snapshot.sequence,
             workers,
             mcpConfigDigest,
-            ...((terminalLifecycle ?? lifecycle)
-                ? { lifecycle: terminalLifecycle ?? lifecycle }
-                : {}),
+            ...(persistedLifecycle ? { lifecycle: persistedLifecycle } : {}),
             ...(githubMonitorCursor ? { githubMonitor: githubMonitorCursor } : {}),
             updatedAt: Date.now(),
         };
@@ -792,33 +817,90 @@ export async function runConductorSession(options) {
             conductorAgentId: conductorHandle.conductor.agentId,
         }), snapshot);
     };
-    const persistSessionSidecar = async (snapshot, lifecycle) => {
-        await saveSessionSidecar(sessionSidecarPath({
+    const persistSessionResumeStore = async (snapshot, lifecycle) => {
+        await saveSessionResumeStore(sessionResumeStorePath({
             repoRoot: options.repoRoot,
             conductorAgentId: conductorHandle.conductor.agentId,
-        }), createSessionSidecar(snapshot, lifecycle));
+        }), createSessionResumeStore(snapshot, lifecycle));
     };
-    flushSidecar = (lifecycle) => enqueueSidecarWrite(async () => {
-        const snapshot = openQuestions.snapshot();
-        await persistOpenQuestionsSnapshot(snapshot);
-        await persistSessionSidecar(snapshot, lifecycle);
-    });
-    const reportSidecarFlushFailure = (error) => {
+    flushSessionResumeStore = (lifecycle) => {
+        if (terminalResumeStoreFinalFlushQueued && lifecycle === undefined) {
+            return sessionResumeStoreWriteQueue;
+        }
+        if (lifecycle !== undefined && lifecycle !== 'unknown') {
+            terminalResumeStoreFinalFlushQueued = true;
+        }
+        return enqueueSessionResumeStoreWrite(async () => {
+            if (lifecycle !== undefined) {
+                terminalLifecycle = lifecycle;
+                harnessPhase =
+                    lifecycle === 'closed'
+                        ? 'close'
+                        : lifecycle === 'exited'
+                            ? 'exit'
+                            : lifecycle === 'interrupted'
+                                ? 'abort'
+                                : undefined;
+                harnessModifiedAt = harnessPhase ? Date.now() : undefined;
+            }
+            const snapshot = openQuestions.snapshot();
+            await persistOpenQuestionsSnapshot(snapshot);
+            await persistSessionResumeStore(snapshot, lifecycle);
+        });
+    };
+    const reportResumeStoreFlushFailure = (error) => {
         const detail = error instanceof Error ? error.message : String(error);
         sessionLogger.emit({
             type: 'harness.warning',
-            message: `Open Question YAML / session sidecar を保存できませんでした。最新状態から再開できず、直前に保存された状態からの再開になる場合があります。 error=${detail}`,
+            message: `Open Question YAML / SessionResumeStore を保存できませんでした。最新状態から再開できず、直前に保存された状態からの再開になる場合があります。 error=${detail}`,
         });
     };
-    const reportSessionSidecarWriteFailure = (error) => {
+    const reportSessionResumeStoreWriteFailure = (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}`,
+            message: `SessionResumeStore の更新に失敗しました。Open Question YAML の保存は完了しており、保存状態は後続 flush で同期します。 error=${detail}`,
         });
     };
-    scheduleSidecarFlush = () => {
-        void flushSidecar().catch(reportSidecarFlushFailure);
+    scheduleSessionResumeStoreFlush = () => {
+        void flushSessionResumeStore().catch(reportResumeStoreFlushFailure);
+    };
+    let conductorSendCount = 0;
+    let workerPromptCount = 0;
+    let idlePhaseTimer;
+    const persistHarnessPhase = (phase) => {
+        if (teardownStarted || harnessPhase === phase)
+            return;
+        if (idlePhaseTimer) {
+            clearTimeout(idlePhaseTimer);
+            idlePhaseTimer = undefined;
+        }
+        harnessPhase = phase;
+        harnessModifiedAt = Date.now();
+        void flushSessionResumeStore().catch(reportResumeStoreFlushFailure);
+    };
+    reportHarnessActivity = (kind, active) => {
+        if (teardownStarted)
+            return;
+        if (kind === 'conductor') {
+            conductorSendCount = Math.max(0, conductorSendCount + (active ? 1 : -1));
+        }
+        else {
+            workerPromptCount = Math.max(0, workerPromptCount + (active ? 1 : -1));
+        }
+        if (conductorSendCount + workerPromptCount > 0) {
+            persistHarnessPhase('running');
+            return;
+        }
+        if (idlePhaseTimer || harnessPhase === 'idle')
+            return;
+        idlePhaseTimer = setTimeout(() => {
+            idlePhaseTimer = undefined;
+            if (conductorSendCount + workerPromptCount === 0) {
+                persistHarnessPhase('idle');
+            }
+        }, 250);
+        idlePhaseTimer.unref?.();
     };
     const toolCallHistoryPath = toolCallSnapshotHistoryPath({
         repoRoot: options.repoRoot,
@@ -891,7 +973,7 @@ export async function runConductorSession(options) {
             shutdownSignal,
             onCursorChange: (cursor) => {
                 githubMonitorCursor = cursor;
-                scheduleSidecarFlush();
+                scheduleSessionResumeStoreFlush();
             },
             onUpdate: (payload) => {
                 sessionLogger.emit({
@@ -950,6 +1032,21 @@ export async function runConductorSession(options) {
         });
         githubMonitor.start();
     }
+    dispatchHoldReminderMonitor = createDispatchHoldReminderMonitor({
+        getSnapshot: () => ({
+            hold: dispatchHoldState.dispatchHold,
+            heldEventCount: dispatchHoldState.heldEvents.length,
+        }),
+        onReminder: ({ heldEventCount }) => {
+            sessionLogger.emit({
+                type: 'harness.warning',
+                message: formatDispatchHoldReminderMessage(heldEventCount, options.dispatchHoldReminderMs),
+            });
+        },
+        reminderIntervalMs: options.dispatchHoldReminderMs,
+        shutdownSignal,
+    });
+    dispatchHoldReminderMonitor.start();
     let permissionDeadlockMonitor;
     if (!options.disablePermissionDeadlockMonitor) {
         permissionDeadlockMonitor = createPermissionDeadlockMonitor({
@@ -986,6 +1083,57 @@ export async function runConductorSession(options) {
     let operatorRequestedExit = false;
     let operatorRequestedClose = false;
     let disposeOperatorInput;
+    const onOperatorMessageQueued = (delivery) => {
+        scheduleSessionResumeStoreFlush();
+        if (delivery !== 'interrupt')
+            return;
+        const cancel = conductorHandle.conductor.cancel;
+        if (!cancel) {
+            sessionLogger.emit({
+                type: 'harness.warning',
+                message: 'Operator interrupt cancellation is unavailable; the message will use normal next dispatch.',
+            });
+            return;
+        }
+        void cancel.call(conductorHandle.conductor).catch((error) => {
+            const detail = error instanceof Error ? error.message : String(error);
+            sessionLogger.emit({
+                type: 'harness.warning',
+                message: `Operator interrupt cancellation failed; the message will use normal next dispatch: ${detail}`,
+            });
+        });
+    };
+    const submitOperatorMessage = (input) => {
+        const delivery = input.delivery ?? 'next';
+        const received = submitOperatorInput({
+            ...input,
+            delivery,
+            conductorTurn: sendCount + 1,
+            openQuestions,
+            escalations,
+            eventQueue,
+            sessionLogger,
+            onEscalated: input.onEscalated ?? ((record) => options.onEscalated?.(record)),
+        });
+        if (!received)
+            return false;
+        onOperatorMessageQueued(delivery);
+        return true;
+    };
+    const sendOperatorMessage = (input) => {
+        const delivery = input.delivery ?? 'next';
+        const received = enqueueOperatorMessageEvent({
+            ...input,
+            delivery,
+            conductorTurn: sendCount + 1,
+            eventQueue,
+            sessionLogger,
+        });
+        if (!received)
+            return false;
+        onOperatorMessageQueued(delivery);
+        return true;
+    };
     if (options.bindOperatorInput) {
         const bindingDispose = options.bindOperatorInput({
             submit: (message, submitOptions) => {
@@ -1009,20 +1157,16 @@ export async function runConductorSession(options) {
                     eventQueue.enqueue({ type: 'operator.reconnect' });
                     return true;
                 }
-                const received = submitOperatorInput({
-                    message,
+                const parsed = submitOptions?.targetOpenQuestionId !== undefined
+                    ? { message, delivery: 'next' }
+                    : submitOptions?.delivery === undefined
+                        ? parseOperatorMessageDelivery(message)
+                        : { message, delivery: submitOptions.delivery };
+                return submitOperatorMessage({
+                    message: parsed.message,
+                    delivery: parsed.delivery,
                     targetOpenQuestionId: submitOptions?.targetOpenQuestionId,
-                    conductorTurn: sendCount + 1,
-                    openQuestions,
-                    escalations,
-                    eventQueue,
-                    sessionLogger,
-                    onEscalated: (record) => options.onEscalated?.(record),
                 });
-                if (received) {
-                    scheduleSidecarFlush();
-                }
-                return received;
             },
             getContext: () => ({
                 conductorTurn: sendCount + 1,
@@ -1038,6 +1182,25 @@ export async function runConductorSession(options) {
     try {
         openQuestionControlServer = await startOpenQuestionControlServer({
             listOpenQuestions: () => openQuestions.listOpen(),
+            getLastConductorMessage: () => lastConductorMessage,
+            listConductorMessages: () => conductorMessages,
+            observeSession: async () => {
+                await sessionStateWriteQueue;
+                const sessionState = await loadSessionStateStore(sessionStateStorePath({
+                    repoRoot: options.repoRoot,
+                    conductorAgentId: conductorAgent.agentId,
+                }));
+                return {
+                    ...openQuestions.snapshot(),
+                    ...(sessionState ? { sessionState } : {}),
+                };
+            },
+            sendOperatorMessage: ({ text, delivery }) => {
+                if (teardownStarted) {
+                    throw new OpenQuestionControlOperationError(-32000, 'The session is shutting down.');
+                }
+                return sendOperatorMessage({ message: text, delivery });
+            },
             answerOpenQuestion: async ({ questionId, answer }) => {
                 if (teardownStarted) {
                     throw new OpenQuestionControlOperationError(-32000, 'The session is shutting down.');
@@ -1047,11 +1210,11 @@ export async function runConductorSession(options) {
                     throw new OpenQuestionControlOperationError(-32004, 'Open Question is not available.');
                 }
                 let accepted = false;
-                let sidecarWriteError;
+                let resumeStoreWriteError;
                 let dispatchReceipt;
                 let answered;
                 const escalatedRecords = [];
-                await enqueueSidecarWrite(async () => {
+                await enqueueSessionResumeStoreWrite(async () => {
                     const stagedOpenQuestions = new OpenQuestionRegistry();
                     stagedOpenQuestions.restore(openQuestions.snapshot());
                     const stagedAccepted = submitOperatorInput({
@@ -1078,15 +1241,11 @@ export async function runConductorSession(options) {
                         await persistOpenQuestionsSnapshot(openQuestions.snapshot());
                         return;
                     }
-                    accepted = submitOperatorInput({
+                    accepted = submitOperatorMessage({
                         message: answer,
+                        delivery: 'next',
                         targetOpenQuestionId: questionId,
                         answeredAt: stagedAnswer.answeredAt,
-                        conductorTurn: sendCount + 1,
-                        openQuestions,
-                        escalations,
-                        eventQueue,
-                        sessionLogger,
                         onEscalated: (record) => escalatedRecords.push(record),
                         onOperatorMessageQueued: (event) => {
                             let receipt;
@@ -1108,12 +1267,12 @@ export async function runConductorSession(options) {
                         return;
                     }
                     try {
-                        await persistSessionSidecar(openQuestions.snapshot());
+                        await persistSessionResumeStore(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;
+                        resumeStoreWriteError = error;
                     }
                 });
                 if (!accepted || !answered || answered.status !== 'answered') {
@@ -1131,9 +1290,9 @@ export async function runConductorSession(options) {
                         });
                     }
                 }
-                if (sidecarWriteError !== undefined) {
-                    reportSessionSidecarWriteFailure(sidecarWriteError);
-                    scheduleSidecarFlush();
+                if (resumeStoreWriteError !== undefined) {
+                    reportSessionResumeStoreWriteFailure(resumeStoreWriteError);
+                    scheduleSessionResumeStoreFlush();
                 }
                 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);
@@ -1143,7 +1302,7 @@ export async function runConductorSession(options) {
             },
         });
         harnessSocketPath = openQuestionControlServer.socketPath;
-        await flushSidecar().catch(reportSidecarFlushFailure);
+        await flushSessionResumeStore().catch(reportResumeStoreFlushFailure);
         const driverResult = await runConductorSessionDriver({
             issueUrl: options.issueUrl,
             initialPrompt: conductorBackend === 'pi'
@@ -1189,6 +1348,7 @@ export async function runConductorSession(options) {
             // session briefing.
             skipInitialSend: Boolean(options.resumeAgentId),
             onSendStarted: (info) => {
+                reportHarnessActivity('conductor', true);
                 sessionLogger.emit({
                     type: 'conductor.send.started',
                     sendCount: info.sendCount,
@@ -1237,6 +1397,29 @@ export async function runConductorSession(options) {
         function recordSendComplete(info) {
             sendCount = info.sendCount;
             autonomousTurns = info.autonomousTurns;
+            const responseText = info.result?.trim();
+            if (info.status === 'finished' && responseText) {
+                const at = Date.now();
+                lastConductorMessage = {
+                    text: responseText,
+                    at,
+                    sendCount: info.sendCount,
+                };
+                if (info.dispatchSource !== 'initial') {
+                    conductorMessages.push({
+                        text: responseText,
+                        inbound: info.inbound,
+                        at,
+                        sendCount: info.sendCount,
+                        ...(info.dispatchSource
+                            ? { dispatchSource: info.dispatchSource }
+                            : {}),
+                    });
+                    if (conductorMessages.length > CONDUCTOR_MESSAGE_HISTORY_MAX_ENTRIES) {
+                        conductorMessages.shift();
+                    }
+                }
+            }
             const githubUpdateIds = info.githubUpdateIds ?? [];
             if (info.status === 'finished' &&
                 !operatorRequestedClose &&
@@ -1266,6 +1449,7 @@ export async function runConductorSession(options) {
                 workerDispatches: info.workerDispatches,
                 workerFailures: info.workerFailures,
             });
+            reportHarnessActivity('conductor', false);
             outboundWorkersThisSend.clear();
             if (isConductorSendAuthError({
                 runId: info.runId,
@@ -1285,7 +1469,7 @@ export async function runConductorSession(options) {
                         : { backend: 'cursor' }),
                 });
             }
-            scheduleSidecarFlush();
+            scheduleSessionResumeStoreFlush();
         }
         async function buildResult() {
             sessionLogger.finish(stopReason);
@@ -1318,8 +1502,11 @@ export async function runConductorSession(options) {
                 : shutdownSignal.aborted
                     ? 'interrupted'
                     : 'unknown';
-        terminalLifecycle = lifecycle;
         teardownStarted = true;
+        if (idlePhaseTimer) {
+            clearTimeout(idlePhaseTimer);
+            idlePhaseTimer = undefined;
+        }
         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));
         }
@@ -1368,6 +1555,10 @@ export async function runConductorSession(options) {
                 teardownPhases.openQuestionControl = Date.now() - phaseStart;
             }
             disposeOperatorInput?.();
+            if (dispatchHoldReminderMonitor) {
+                emitTeardownPhase('dispatchHoldReminderMonitor');
+                dispatchHoldReminderMonitor.stop();
+            }
             if (permissionDeadlockMonitor) {
                 emitTeardownPhase('permissionDeadlockMonitor');
                 permissionDeadlockMonitor.stop();
@@ -1414,13 +1605,13 @@ export async function runConductorSession(options) {
                 githubMonitorStopped = true;
             }
             try {
-                emitTeardownPhase('flushSidecar');
+                emitTeardownPhase('flushSessionResumeStore');
                 const phaseStart = Date.now();
-                await flushSidecar();
-                teardownPhases.flushSidecar = Date.now() - phaseStart;
+                await flushSessionResumeStore();
+                teardownPhases.flushSessionResumeStore = Date.now() - phaseStart;
             }
             catch (error) {
-                reportSidecarFlushFailure(error);
+                reportResumeStoreFlushFailure(error);
             }
             await flushToolCallHistoryBestEffort();
             const runGithubMonitorStop = async () => {
@@ -1485,12 +1676,12 @@ export async function runConductorSession(options) {
         }
         finally {
             try {
-                emitTeardownPhase('flushSidecar');
+                emitTeardownPhase('flushSessionResumeStore');
                 await sessionStateWriteQueue;
-                await flushSidecar(lifecycle);
+                await flushSessionResumeStore(lifecycle);
             }
             catch (error) {
-                reportSidecarFlushFailure(error);
+                reportResumeStoreFlushFailure(error);
             }
             process.off('SIGINT', onTeardownSignal);
             process.off('SIGTERM', onTeardownSignal);