@xfey/tenso 0.1.130

package/dist/control-plane/index.js

@@ -0,0 +1,941 @@
+import { readActiveClarificationProjection, readActiveTaskCompileContext, markScratchpadRefreshSucceeded, readPendingTaskCompileSubmission, readTaskDetailProjection, readTaskProjectionByActivityRef, readScratchpadSourceState, } from "../collaboration-state/index.js";
+import { ProcedureEngine } from "../procedure-engine/index.js";
+import { RunEngine } from "../run-engine/index.js";
+import { WorkspaceOpsError, isReferenceFilePath, readReferenceSummaryTargets, } from "../workspace-ops/index.js";
+import { publishProcedureTransition as publishProcedureTransitionEvent, publishRunResultRecorded as publishRunResultRecordedEvent, publishRunTransition as publishRunTransitionEvent, publishTaskRunStarted as publishTaskRunStartedEvent, } from "./event-publishers.js";
+import { startContextSyncAnalysisProcedure } from "./context-sync.js";
+import { pendingContextSyncCompletion } from "./context-sync-completion.js";
+import { refreshProjectBriefProjection, } from "./project-brief-refresh.js";
+import { startReferenceSummaryRefreshProcedure } from "./reference-summary-refresh.js";
+import { runControlPlaneStartupRecovery } from "./startup-recovery.js";
+import { readControlPlaneExecutionStatus } from "./execution-status.js";
+import { ScratchpadAutoRefreshScheduler } from "./scratchpad-auto-refresh.js";
+import { startControlPlaneScratchpadRefresh } from "./scratchpad-refresh-start.js";
+import { shouldUseMessageAsScratchpadSource } from "./scratchpad-source-messages.js";
+import { resumeControlPlaneTaskCompileChain, resumePendingTaskCompileSubmission, startControlPlaneTaskCompile, } from "./task-compile-start.js";
+import { startControlPlaneTaskCompileContinuation } from "./task-compile-continuation.js";
+import { startControlPlaneTaskBoundFollowUpCheck } from "./follow-up-start.js";
+import { runControlPlaneSchedulerForTaskArrival, runControlPlaneSchedulerNow, } from "./run-scheduler.js";
+import { startControlPlaneRunForTask } from "./run-start.js";
+import { retryControlPlaneTask } from "./run-retry.js";
+import { enqueueClarificationSuccessorIntent, runSendClarificationRoundMessage, runSubmitClarificationRound, } from "./clarification-commands.js";
+import { ControlPlaneIntentDispatcher, } from "./intent-dispatcher.js";
+import { emitTaskCompletedResultMessage, emitTaskFailedResultMessage, } from "./worklist-terminal-feedback.js";
+const WORKLIST_COMPLETION_CONTEXT_SYNC_GRACE_MS = 30_000;
+export class Phase5ControlPlane {
+    engine;
+    runEngine;
+    store;
+    events;
+    resolveWorkflowRunner;
+    resolveRunPipeline;
+    readMainlineStatus;
+    readActiveApproval;
+    hasPendingChatRequests;
+    logger;
+    projectContext;
+    runLifecycle;
+    now;
+    scratchpadAutoRefreshScheduler;
+    intentDispatcher;
+    pendingWorklistCompletionContextSyncTimer = null;
+    pendingReferenceSummaryPaths = new Set();
+    referenceSummaryWaiters = new Map();
+    pendingAllReferenceSummaries = false;
+    referenceSummaryStartScheduled = false;
+    closing = false;
+    asyncOwners = new Set();
+    pendingRunInputs = new Map();
+    runIntentTerminals = new Map();
+    lastRecoveryConclusion = null;
+    constructor(options) {
+        this.store = options.store;
+        this.events = options.events;
+        this.resolveWorkflowRunner = options.resolveWorkflowRunner;
+        this.resolveRunPipeline = options.resolveRunPipeline;
+        this.readMainlineStatus = options.readMainlineStatus;
+        this.readActiveApproval = options.readActiveApproval;
+        this.hasPendingChatRequests = options.hasPendingChatRequests ?? (() => false);
+        this.logger = options.logger;
+        this.projectContext = options.projectContext;
+        this.runLifecycle = options.runLifecycle;
+        this.now = options.now ?? (() => new Date());
+        this.engine = new ProcedureEngine({ now: this.now });
+        this.runEngine = new RunEngine({ now: this.now });
+        this.scratchpadAutoRefreshScheduler = new ScratchpadAutoRefreshScheduler({
+            store: this.store,
+            now: this.now,
+            readScratchpadRefreshBlocker: () => this.readScratchpadRefreshBlocker(),
+            startScratchpadRefresh: () => this.startScratchpadRefresh({ lane: "scratchpad_background" }),
+        });
+        this.intentDispatcher = new ControlPlaneIntentDispatcher({
+            store: this.store,
+            now: this.now,
+            handler: (intent, runtime) => this.dispatchDurableIntent(intent, runtime),
+        });
+    }
+    getExecutionStatus() {
+        return readControlPlaneExecutionStatus({
+            procedureEngine: this.engine,
+            runEngine: this.runEngine,
+            store: this.store,
+            lastRecoveryConclusion: this.lastRecoveryConclusion,
+            ...(this.readActiveApproval === undefined
+                ? {}
+                : { readActiveApproval: this.readActiveApproval }),
+            now: this.now,
+        });
+    }
+    runSchedulerNow(payload = {}) {
+        return runControlPlaneSchedulerNow({
+            store: this.store,
+            payload,
+            resolveRunPipeline: this.resolveRunPipeline,
+            readMainlineStatus: this.readMainlineStatus,
+            readSchedulerBlocker: () => this.readSchedulerBlocker(),
+            startRunForTask: (runInput) => this.startRunForTask(runInput),
+            now: this.now,
+        });
+    }
+    retryTask(taskId, payload) {
+        return retryControlPlaneTask({
+            store: this.store,
+            taskId,
+            payload,
+            resolveRunPipeline: this.resolveRunPipeline,
+            readActiveActivity: () => this.readSchedulerBlocker(),
+            startRunForTask: (runInput) => {
+                void this.startRunForTask(runInput);
+            },
+            now: this.now,
+        });
+    }
+    runStartupRecovery(options = {}) {
+        const recovered = runControlPlaneStartupRecovery({
+            store: this.store,
+            events: this.events,
+            options,
+            now: this.now,
+            getExecutionStatus: () => this.getExecutionStatus(),
+            setLastRecoveryConclusion: (conclusion) => {
+                this.lastRecoveryConclusion = conclusion;
+            },
+            enqueueSealedRound: (sealed, roundId) => {
+                const ensured = enqueueClarificationSuccessorIntent(this.store.db, {
+                    owner: sealed.thread.owner,
+                    roundId,
+                    now: this.now,
+                }).intent;
+                return (ensured.state === "pending" || ensured.state === "claimed" || ensured.state === "running");
+            },
+        });
+        this.intentDispatcher.start();
+        return recovered;
+    }
+    startScratchpadRefresh(options = {}) {
+        this.cancelPendingWorklistCompletionContextSync();
+        return startControlPlaneScratchpadRefresh({
+            engine: this.engine,
+            store: this.store,
+            events: this.events,
+            resolveWorkflowRunner: this.resolveWorkflowRunner,
+            projectContext: this.projectContext,
+            ...(options.lane === undefined ? {} : { lane: options.lane }),
+            logger: this.logger,
+            now: this.now,
+            publishProcedureTransition: (state) => this.publishProcedureTransition(state),
+        });
+    }
+    notifyScratchpadSourceChanged(message) {
+        if (!shouldUseMessageAsScratchpadSource(message)) {
+            return;
+        }
+        this.cancelPendingWorklistCompletionContextSync();
+        this.scratchpadAutoRefreshScheduler.notifySourceChanged();
+    }
+    refreshProjectBrief(options) {
+        return this.trackAsyncOwner(refreshProjectBriefProjection({
+            store: this.store,
+            projectContext: this.projectContext,
+            reason: options.reason,
+            resolveWorkflowRunner: this.resolveWorkflowRunner,
+            ...(options.workflowRef === undefined ? {} : { workflowRef: options.workflowRef }),
+            ...(options.activityRef === undefined ? {} : { activityRef: options.activityRef }),
+            logger: this.logger,
+            now: this.now,
+        }));
+    }
+    beginShutdown() {
+        if (this.closing) {
+            return;
+        }
+        this.closing = true;
+        this.scratchpadAutoRefreshScheduler.dispose();
+        this.cancelPendingWorklistCompletionContextSync();
+        this.pendingAllReferenceSummaries = false;
+        this.pendingReferenceSummaryPaths.clear();
+        this.intentDispatcher.dispose();
+    }
+    dispose() {
+        this.beginShutdown();
+        return this.waitForIdle();
+    }
+    async waitForRepoInspectionIdle(onBlocked) {
+        for (;;) {
+            const waits = [];
+            const run = this.readActiveRun();
+            const procedure = this.readActiveForegroundProcedure();
+            if (run !== null) {
+                onBlocked?.(run);
+                waits.push(this.runEngine.waitForIdle());
+            }
+            if (procedure !== null) {
+                onBlocked?.(procedure);
+                waits.push(this.engine.waitForLaneIdle("foreground"));
+            }
+            if (waits.length === 0) {
+                return;
+            }
+            await Promise.all(waits);
+        }
+    }
+    startTaskCompile(payload) {
+        this.cancelPendingWorklistCompletionContextSync();
+        const activeRun = this.readActiveRun();
+        if (activeRun !== null) {
+            return {
+                disposition: {
+                    kind: "already_running",
+                    activity_ref: activeRun.activity_ref,
+                },
+            };
+        }
+        let tasksAdded = false;
+        return startControlPlaneTaskCompile({
+            engine: this.engine,
+            store: this.store,
+            events: this.events,
+            payload,
+            resolveWorkflowRunner: this.resolveWorkflowRunner,
+            projectContext: this.projectContext,
+            logger: this.logger,
+            now: this.now,
+            publishProcedureTransition: (state) => {
+                this.publishProcedureTransition(state);
+                if (!this.closing &&
+                    tasksAdded &&
+                    state.activity.status === "finished" &&
+                    state.activity.workflow_kind === "task_compile") {
+                    this.tryRunTaskArrivalScheduler();
+                }
+            },
+            registerReferenceSummaryWaiter: (activityRef, waiter) => {
+                const existing = this.referenceSummaryWaiters.get(activityRef) ?? [];
+                existing.push(waiter);
+                this.referenceSummaryWaiters.set(activityRef, existing);
+            },
+            onTasksAdded: () => {
+                tasksAdded = true;
+            },
+            shouldContinue: () => !this.closing,
+        });
+    }
+    startContextSyncAnalysis() {
+        this.cancelPendingWorklistCompletionContextSync();
+        return this.startContextSync({ kind: "manual" });
+    }
+    startContextSync(trigger, completionBatchKey) {
+        return startContextSyncAnalysisProcedure({
+            engine: this.engine,
+            store: this.store,
+            events: this.events,
+            trigger,
+            ...(completionBatchKey === undefined ? {} : { completionBatchKey }),
+            resolveWorkflowRunner: this.resolveWorkflowRunner,
+            readActiveActivity: () => this.readSchedulerBlocker(),
+            projectContext: this.projectContext,
+            logger: this.logger,
+            now: this.now,
+            publishProcedureTransition: (state) => this.publishProcedureTransition(state),
+        });
+    }
+    startReferenceSummaryRefresh(payload = {}) {
+        if (payload.paths === undefined) {
+            this.pendingAllReferenceSummaries = false;
+            this.pendingReferenceSummaryPaths.clear();
+            if (this.projectContext === undefined) {
+                this.pendingAllReferenceSummaries = true;
+            }
+            else {
+                try {
+                    for (const target of readReferenceSummaryTargets({
+                        workspaceRoot: this.projectContext.workspaceRoot,
+                        now: this.now,
+                    })) {
+                        this.pendingReferenceSummaryPaths.add(target.path);
+                    }
+                }
+                catch (error) {
+                    if (!(error instanceof WorkspaceOpsError && error.code === "not_found")) {
+                        throw error;
+                    }
+                }
+            }
+        }
+        else {
+            for (const path of payload.paths) {
+                this.pendingReferenceSummaryPaths.add(path);
+            }
+        }
+        return this.tryStartPendingReferenceSummaryRefresh();
+    }
+    tryStartPendingReferenceSummaryRefresh() {
+        const refreshAll = this.pendingAllReferenceSummaries;
+        const paths = refreshAll ? undefined : [...this.pendingReferenceSummaryPaths];
+        const result = startReferenceSummaryRefreshProcedure({
+            engine: this.engine,
+            store: this.store,
+            events: this.events,
+            ...(paths === undefined ? {} : { paths }),
+            resolveWorkflowRunner: this.resolveWorkflowRunner,
+            readActiveActivity: () => this.readSchedulerBlocker(),
+            projectContext: this.projectContext,
+            logger: this.logger,
+            now: this.now,
+            onTargetsPersisted: (targets) => {
+                for (const target of targets) {
+                    this.pendingReferenceSummaryPaths.delete(target.path);
+                }
+            },
+            publishProcedureTransition: (state) => this.publishProcedureTransition(state),
+        });
+        if (result.disposition.kind !== "already_running") {
+            if (refreshAll) {
+                this.pendingAllReferenceSummaries = false;
+                this.pendingReferenceSummaryPaths.clear();
+            }
+            else {
+                for (const path of paths ?? []) {
+                    this.pendingReferenceSummaryPaths.delete(path);
+                }
+            }
+        }
+        return result;
+    }
+    sendClarificationRoundMessage(roundId, payload, author) {
+        return runSendClarificationRoundMessage({
+            store: this.store,
+            events: this.events,
+            roundId,
+            payload,
+            author,
+            now: this.now,
+        });
+    }
+    submitClarificationRound(roundId, payload, commandId) {
+        return runSubmitClarificationRound({
+            store: this.store,
+            events: this.events,
+            roundId,
+            payload,
+            commandId,
+            now: this.now,
+            wakeIntentDispatcher: () => this.intentDispatcher.wake(),
+        });
+    }
+    async waitForIdle() {
+        while (true) {
+            await this.engine.waitForIdle();
+            await this.runEngine.waitForIdle();
+            await Promise.allSettled([...this.asyncOwners]);
+            await Promise.resolve();
+            if (this.readAnyActiveActivity() === null &&
+                this.asyncOwners.size === 0 &&
+                (this.closing || !this.hasPendingReferenceSummaryRefresh())) {
+                return;
+            }
+            if (!this.closing) {
+                this.schedulePendingReferenceSummaryRefresh();
+            }
+        }
+    }
+    trackAsyncOwner(owner) {
+        this.asyncOwners.add(owner);
+        void owner.then(() => this.asyncOwners.delete(owner), () => this.asyncOwners.delete(owner));
+        return owner;
+    }
+    hasPendingReferenceSummaryRefresh() {
+        return this.pendingAllReferenceSummaries || this.pendingReferenceSummaryPaths.size !== 0;
+    }
+    schedulePendingReferenceSummaryRefresh() {
+        if (this.closing ||
+            !this.hasPendingReferenceSummaryRefresh() ||
+            this.referenceSummaryStartScheduled) {
+            return;
+        }
+        this.referenceSummaryStartScheduled = true;
+        queueMicrotask(() => {
+            this.referenceSummaryStartScheduled = false;
+            if (!this.closing && this.hasPendingReferenceSummaryRefresh()) {
+                void this.tryStartPendingReferenceSummaryRefresh();
+            }
+        });
+    }
+    startRunForTask(input) {
+        this.pendingRunInputs.set(input.activity_ref, input);
+        const result = startControlPlaneRunForTask({
+            runEngine: this.runEngine,
+            store: this.store,
+            run: input,
+            projectContext: this.projectContext,
+            resolveWorkflowRunner: this.resolveWorkflowRunner,
+            logger: this.logger,
+            now: this.now,
+            publishRunTransition: (state) => {
+                this.publishRunTransition(state);
+                if (state.transition_kind === "terminal") {
+                    this.runLifecycle?.settled();
+                }
+            },
+            publishTaskRunStarted: (task, activityRef) => this.publishTaskRunStarted(task, activityRef),
+            publishRunResultRecorded: (recorded) => this.publishRunResultRecorded(recorded),
+        });
+        if (result.kind === "accepted") {
+            this.cancelPendingWorklistCompletionContextSync();
+            this.runLifecycle?.started();
+        }
+        this.intentDispatcher.wake();
+        return result;
+    }
+    readActiveRun() {
+        const runStatus = this.runEngine.getExecutionStatus();
+        if (runStatus.status !== "idle" && runStatus.active_activity !== undefined) {
+            return {
+                activity_ref: runStatus.active_activity.activity_ref,
+                activity_kind: runStatus.active_activity.activity_kind,
+            };
+        }
+        return null;
+    }
+    readActiveProcedures() {
+        return this.engine.getActiveProcedures().map((activity) => ({
+            activity_ref: activity.activity_ref,
+            activity_kind: "procedure",
+            lane: activity.lane ?? "foreground",
+            ...(activity.workflow_kind === undefined ? {} : { workflow_kind: activity.workflow_kind }),
+            ...(activity.workflow_ref === undefined
+                ? {}
+                : { workflow_ref: activity.workflow_ref }),
+        }));
+    }
+    readActiveForegroundProcedure() {
+        return (this.readActiveProcedures().find((activity) => {
+            return activity.lane === "foreground";
+        }) ?? null);
+    }
+    readActiveScratchpadRefreshProcedure() {
+        return (this.readActiveProcedures().find((activity) => {
+            return activity.workflow_kind === "scratchpad_refresh";
+        }) ?? null);
+    }
+    readAnyActiveActivity() {
+        const activeRun = this.readActiveRun();
+        if (activeRun !== null) {
+            return activeRun;
+        }
+        return this.readActiveProcedures()[0] ?? null;
+    }
+    readSchedulerBlocker() {
+        const activeRun = this.readActiveRun();
+        if (activeRun !== null) {
+            return activeRun;
+        }
+        return this.readActiveForegroundProcedure();
+    }
+    readScratchpadRefreshBlocker() {
+        const activeScratchpadRefresh = this.readActiveScratchpadRefreshProcedure();
+        if (activeScratchpadRefresh !== null) {
+            return activeScratchpadRefresh;
+        }
+        const foreground = this.readActiveForegroundProcedure();
+        if (foreground === null) {
+            return null;
+        }
+        const activeContext = readActiveTaskCompileContext(this.store.db);
+        if (activeContext !== null &&
+            (foreground.workflow_kind === "project_context_bootstrap" ||
+                (foreground.workflow_kind === "task_compile" &&
+                    foreground.workflow_ref === activeContext.workflow_ref))) {
+            return null;
+        }
+        return foreground;
+    }
+    publishTaskRunStarted(task, activityRef) {
+        publishTaskRunStartedEvent(this.events, task, activityRef);
+    }
+    publishRunResultRecorded(recorded) {
+        publishRunResultRecordedEvent(this.events, recorded);
+    }
+    publishRunTransition(state) {
+        publishRunTransitionEvent({
+            events: this.events,
+            state,
+            now: this.now,
+            getExecutionStatus: () => this.getExecutionStatus(),
+            onTerminal: (terminalState) => this.handleRunTerminalTransition(terminalState),
+        });
+        this.scratchpadAutoRefreshScheduler.notifyActivityChanged();
+        if (state.transition_kind === "terminal") {
+            this.schedulePendingReferenceSummaryRefresh();
+            this.intentDispatcher.wake();
+        }
+    }
+    handleRunTerminalTransition(state) {
+        const activityRef = state.activity.activity_ref;
+        this.runIntentTerminals.get(activityRef)?.();
+        this.runIntentTerminals.delete(activityRef);
+        this.pendingRunInputs.delete(activityRef);
+        if (state.activity.status === "finished") {
+            if (state.activity.task_id !== undefined) {
+                const taskId = state.activity.task_id;
+                const detail = readTaskDetailProjection(this.store.db, taskId);
+                const result = detail?.detail.result;
+                if (result?.result_kind === "finished" &&
+                    result.outcome === "completed" &&
+                    result.promotion?.status === "promoted") {
+                    for (const path of result.changed_paths ?? []) {
+                        if (isReferenceFilePath(path)) {
+                            this.pendingReferenceSummaryPaths.add(path);
+                        }
+                    }
+                }
+                emitTaskCompletedResultMessage({
+                    store: this.store,
+                    events: this.events,
+                    taskId,
+                    activityRef: state.activity.activity_ref,
+                    ...(this.projectContext === undefined
+                        ? {}
+                        : { workspaceRoot: this.projectContext.workspaceRoot }),
+                    now: this.now,
+                });
+            }
+            this.maybeScheduleAfterRunCompletion();
+            return;
+        }
+        if (state.activity.status === "failed" && state.activity.task_id !== undefined) {
+            emitTaskFailedResultMessage({
+                store: this.store,
+                events: this.events,
+                taskId: state.activity.task_id,
+                activityRef: state.activity.activity_ref,
+                now: this.now,
+            });
+        }
+    }
+    tryRunTaskArrivalScheduler() {
+        if (this.closing) {
+            return false;
+        }
+        const result = runControlPlaneSchedulerForTaskArrival({
+            store: this.store,
+            resolveRunPipeline: this.resolveRunPipeline,
+            readMainlineStatus: this.readMainlineStatus,
+            readSchedulerBlocker: () => this.readSchedulerBlocker(),
+            startRunForTask: (runInput) => this.startRunForTask(runInput),
+            now: this.now,
+        });
+        return result.disposition.kind === "scheduled";
+    }
+    maybeScheduleAfterRunCompletion() {
+        if (this.tryRunTaskArrivalScheduler()) {
+            return;
+        }
+        this.scheduleContextSyncAfterWorklistCompletion();
+    }
+    notifyChatRequestsChanged() {
+        if (this.closing || !this.store.db.open)
+            return;
+        if (this.hasPendingChatRequests())
+            this.cancelPendingWorklistCompletionContextSync();
+        else
+            this.scheduleContextSyncAfterWorklistCompletion();
+    }
+    scheduleContextSyncAfterWorklistCompletion() {
+        if (this.closing ||
+            !this.store.db.open ||
+            this.pendingWorklistCompletionContextSyncTimer !== null) {
+            return;
+        }
+        const sourceState = readScratchpadSourceState(this.store.db);
+        if (pendingContextSyncCompletion(this.store.db) === undefined ||
+            this.hasPendingChatRequests() ||
+            sourceState.dirty_since !== undefined ||
+            sourceState.in_flight !== undefined ||
+            this.readSchedulerBlocker() !== null) {
+            return;
+        }
+        this.pendingWorklistCompletionContextSyncTimer = setTimeout(() => {
+            this.attemptContextSyncAfterWorklistCompletion();
+        }, WORKLIST_COMPLETION_CONTEXT_SYNC_GRACE_MS);
+        this.pendingWorklistCompletionContextSyncTimer.unref?.();
+    }
+    attemptContextSyncAfterWorklistCompletion() {
+        this.pendingWorklistCompletionContextSyncTimer = null;
+        if (this.closing || !this.store.db.open) {
+            return;
+        }
+        const completion = pendingContextSyncCompletion(this.store.db);
+        const sourceState = readScratchpadSourceState(this.store.db);
+        if (completion === undefined ||
+            this.hasPendingChatRequests() ||
+            sourceState.dirty_since !== undefined ||
+            sourceState.in_flight !== undefined ||
+            this.readSchedulerBlocker() !== null) {
+            return;
+        }
+        void this.startContextSync(completion.trigger, completion.key);
+    }
+    cancelPendingWorklistCompletionContextSync() {
+        if (this.pendingWorklistCompletionContextSyncTimer === null) {
+            return;
+        }
+        clearTimeout(this.pendingWorklistCompletionContextSyncTimer);
+        this.pendingWorklistCompletionContextSyncTimer = null;
+    }
+    startTaskCompileContinuation(owner, roundId, onTerminal) {
+        let tasksAdded = false;
+        return startControlPlaneTaskCompileContinuation({
+            engine: this.engine,
+            store: this.store,
+            events: this.events,
+            owner,
+            roundId,
+            resolveWorkflowRunner: this.resolveWorkflowRunner,
+            projectContext: this.projectContext,
+            logger: this.logger,
+            now: this.now,
+            publishProcedureTransition: (state) => {
+                this.publishProcedureTransition(state);
+                if (!this.closing &&
+                    tasksAdded &&
+                    state.activity.status === "finished" &&
+                    state.activity.workflow_kind === "task_compile") {
+                    this.tryRunTaskArrivalScheduler();
+                }
+            },
+            onTasksAdded: () => {
+                tasksAdded = true;
+            },
+            ...(onTerminal === undefined ? {} : { onTerminal }),
+        });
+    }
+    startTaskBoundFollowUpCheck(owner, threadId, roundId, onTerminal) {
+        return startControlPlaneTaskBoundFollowUpCheck({
+            engine: this.engine,
+            store: this.store,
+            events: this.events,
+            owner,
+            threadId,
+            roundId,
+            resolveWorkflowRunner: this.resolveWorkflowRunner,
+            resolveRunPipeline: this.resolveRunPipeline,
+            readMainlineStatus: this.readMainlineStatus,
+            logger: this.logger,
+            now: this.now,
+            publishProcedureTransition: (state) => this.publishProcedureTransition(state),
+            startRunForTask: (runInput) => {
+                if (!this.closing) {
+                    void this.startRunForTask(runInput);
+                }
+            },
+            shouldContinue: () => !this.closing,
+            ...(onTerminal === undefined ? {} : { onTerminal }),
+        });
+    }
+    dispatchDurableIntent(intent, runtime) {
+        switch (intent.kind) {
+            case "run_dispatch":
+                return this.dispatchRunIntent(intent, runtime.terminal);
+            case "scratchpad_refresh":
+                return this.dispatchScratchpadIntent(intent, runtime.terminal);
+            case "reference_summary_refresh":
+                return this.dispatchReferenceSummaryIntent(runtime.terminal);
+            case "task_compile_start":
+                return this.dispatchTaskCompileStartIntent(intent, runtime.terminal);
+            case "task_compile_continuation":
+            case "task_bound_follow_up":
+                return this.dispatchClarificationSuccessorIntent(intent, runtime.terminal);
+        }
+    }
+    dispatchRunIntent(intent, terminal) {
+        const activityRef = intent.owner_ref;
+        const task = readTaskProjectionByActivityRef(this.store.db, activityRef);
+        if (task === null || task.status !== "running") {
+            return { kind: "obsolete", errorCode: "run_already_terminal" };
+        }
+        const activeRun = this.readActiveRun();
+        if (activeRun !== null) {
+            if (activeRun.activity_ref !== activityRef) {
+                return { kind: "busy" };
+            }
+            this.runIntentTerminals.set(activityRef, terminal);
+            return { kind: "accepted" };
+        }
+        const runInput = this.pendingRunInputs.get(activityRef);
+        if (runInput === undefined) {
+            return { kind: "not_ready", errorCode: "run_dispatch_context_unavailable" };
+        }
+        this.runIntentTerminals.set(activityRef, terminal);
+        const start = this.startRunForTask(runInput);
+        if (start.kind === "accepted") {
+            return { kind: "accepted" };
+        }
+        this.runIntentTerminals.delete(activityRef);
+        return { kind: "busy" };
+    }
+    dispatchScratchpadIntent(intent, terminal) {
+        const sourceState = readScratchpadSourceState(this.store.db);
+        if (sourceState.in_flight !== undefined) {
+            return { kind: "busy" };
+        }
+        if (sourceState.dirty_since === undefined) {
+            return { kind: "obsolete", errorCode: "scratchpad_source_clean" };
+        }
+        if (sourceState.backoff_until !== undefined &&
+            new Date(sourceState.backoff_until).getTime() > this.now().getTime()) {
+            return {
+                kind: "not_ready",
+                errorCode: "scratchpad_backoff_active",
+                availableAt: sourceState.backoff_until,
+            };
+        }
+        const result = startControlPlaneScratchpadRefresh({
+            engine: this.engine,
+            store: this.store,
+            events: this.events,
+            resolveWorkflowRunner: this.resolveWorkflowRunner,
+            projectContext: this.projectContext,
+            lane: intent.lane === "scratchpad_background" ? "scratchpad_background" : "foreground",
+            logger: this.logger,
+            now: this.now,
+            publishProcedureTransition: (state) => this.publishProcedureTransition(state),
+            recordRecoveryIntent: false,
+            recoveryIntentId: intent.intent_id,
+            onTerminal: terminal,
+        });
+        if (result.disposition.kind === "accepted") {
+            return { kind: "accepted" };
+        }
+        if (result.disposition.kind === "already_running") {
+            return { kind: "busy" };
+        }
+        if (result.disposition.kind === "no_source_messages") {
+            markScratchpadRefreshSucceeded(this.store.db, { now: this.now });
+            return { kind: "obsolete", errorCode: "scratchpad_source_empty" };
+        }
+        if (result.disposition.kind === "provider_not_configured") {
+            return { kind: "not_ready", errorCode: "provider_not_configured" };
+        }
+        return { kind: "not_ready", errorCode: "provider_unavailable" };
+    }
+    dispatchReferenceSummaryIntent(terminal) {
+        const result = startReferenceSummaryRefreshProcedure({
+            engine: this.engine,
+            store: this.store,
+            events: this.events,
+            resolveWorkflowRunner: this.resolveWorkflowRunner,
+            readActiveActivity: () => this.readSchedulerBlocker(),
+            projectContext: this.projectContext,
+            logger: this.logger,
+            now: this.now,
+            publishProcedureTransition: (state) => this.publishProcedureTransition(state),
+            recordRecoveryIntent: false,
+            onTerminal: terminal,
+        });
+        if (result.disposition.kind === "accepted") {
+            return { kind: "accepted" };
+        }
+        if (result.disposition.kind === "already_running") {
+            return { kind: "busy" };
+        }
+        if (result.disposition.kind === "no_targets") {
+            return { kind: "obsolete", errorCode: "reference_targets_terminal" };
+        }
+        if (result.disposition.kind === "provider_not_configured") {
+            return { kind: "not_ready", errorCode: "provider_not_configured" };
+        }
+        return { kind: "not_ready", errorCode: "provider_unavailable" };
+    }
+    dispatchTaskCompileStartIntent(intent, terminal) {
+        const activeContext = readActiveTaskCompileContext(this.store.db);
+        const activeClarification = readActiveClarificationProjection(this.store.db);
+        if (activeContext === null) {
+            const submission = readPendingTaskCompileSubmission(this.store.db, intent.owner_ref);
+            if (submission === null) {
+                return { kind: "obsolete", errorCode: "task_compile_context_absent" };
+            }
+            if (activeClarification.state === "active") {
+                return { kind: "not_ready", errorCode: "clarification_active" };
+            }
+            let tasksAdded = false;
+            return resumePendingTaskCompileSubmission({
+                engine: this.engine,
+                store: this.store,
+                events: this.events,
+                taskCompileWorkflowRef: submission.workflow_ref,
+                recoveryIntentId: intent.intent_id,
+                resolveWorkflowRunner: this.resolveWorkflowRunner,
+                projectContext: this.projectContext,
+                logger: this.logger,
+                now: this.now,
+                publishProcedureTransition: (state) => {
+                    this.publishProcedureTransition(state);
+                    if (!this.closing &&
+                        tasksAdded &&
+                        state.activity.status === "finished" &&
+                        state.activity.workflow_kind === "task_compile") {
+                        this.tryRunTaskArrivalScheduler();
+                    }
+                },
+                registerReferenceSummaryWaiter: (activityRef, waiter) => {
+                    const existing = this.referenceSummaryWaiters.get(activityRef) ?? [];
+                    existing.push(waiter);
+                    this.referenceSummaryWaiters.set(activityRef, existing);
+                },
+                onTasksAdded: () => {
+                    tasksAdded = true;
+                },
+                shouldContinue: () => !this.closing,
+                onChainTerminal: terminal,
+            });
+        }
+        if (activeContext.workflow_ref !== intent.owner_ref) {
+            return { kind: "obsolete", errorCode: "task_compile_context_absent" };
+        }
+        if (activeClarification.state === "active") {
+            if (activeClarification.thread.owner.kind === "task_compile" &&
+                activeClarification.thread.owner.workflow_ref === activeContext.workflow_ref) {
+                return { kind: "obsolete", errorCode: "task_compile_waiting_for_human" };
+            }
+            return { kind: "not_ready", errorCode: "clarification_active" };
+        }
+        const foreground = this.readActiveForegroundProcedure();
+        if (foreground?.workflow_kind === "reference_summary_refresh" &&
+            this.referenceSummaryWaiters.has(foreground.activity_ref)) {
+            return { kind: "busy" };
+        }
+        let tasksAdded = false;
+        return resumeControlPlaneTaskCompileChain({
+            engine: this.engine,
+            store: this.store,
+            events: this.events,
+            taskCompileWorkflowRef: activeContext.workflow_ref,
+            resolveWorkflowRunner: this.resolveWorkflowRunner,
+            projectContext: this.projectContext,
+            logger: this.logger,
+            now: this.now,
+            publishProcedureTransition: (state) => {
+                this.publishProcedureTransition(state);
+                if (!this.closing &&
+                    tasksAdded &&
+                    state.activity.status === "finished" &&
+                    state.activity.workflow_kind === "task_compile") {
+                    this.tryRunTaskArrivalScheduler();
+                }
+            },
+            registerReferenceSummaryWaiter: (activityRef, waiter) => {
+                const existing = this.referenceSummaryWaiters.get(activityRef) ?? [];
+                existing.push(waiter);
+                this.referenceSummaryWaiters.set(activityRef, existing);
+            },
+            onTasksAdded: () => {
+                tasksAdded = true;
+            },
+            shouldContinue: () => !this.closing,
+            onChainTerminal: terminal,
+        });
+    }
+    dispatchClarificationSuccessorIntent(intent, terminal) {
+        const active = readActiveClarificationProjection(this.store.db);
+        if (active.state === "none" ||
+            active.thread.status !== "active" ||
+            active.round.id !== intent.owner_ref ||
+            active.round.status !== "sealed" ||
+            active.round.successor_status !== "not_materialized") {
+            return { kind: "obsolete", errorCode: "clarification_successor_not_required" };
+        }
+        if (intent.kind === "task_compile_continuation") {
+            if (active.thread.owner.kind !== "task_compile") {
+                return { kind: "obsolete", errorCode: "clarification_owner_kind_changed" };
+            }
+            return this.startTaskCompileContinuation(active.thread.owner, active.round.id, terminal);
+        }
+        if (active.thread.owner.kind !== "task") {
+            return { kind: "obsolete", errorCode: "clarification_owner_kind_changed" };
+        }
+        return this.startTaskBoundFollowUpCheck(active.thread.owner, active.thread.id, active.round.id, terminal);
+    }
+    publishProcedureTransition(state) {
+        if (state.transition_kind === "started" && state.activity.lane === "foreground") {
+            this.cancelPendingWorklistCompletionContextSync();
+        }
+        this.logProcedureTransition(state);
+        publishProcedureTransitionEvent({
+            events: this.events,
+            store: this.store,
+            state,
+            now: this.now,
+            getExecutionStatus: () => this.getExecutionStatus(),
+        });
+        this.scratchpadAutoRefreshScheduler.notifyActivityChanged();
+        if (state.transition_kind === "terminal") {
+            const activityRef = state.activity.activity_ref;
+            const waiters = this.referenceSummaryWaiters.get(activityRef) ?? [];
+            this.referenceSummaryWaiters.delete(activityRef);
+            for (const waiter of waiters) {
+                try {
+                    waiter(state);
+                }
+                catch (error) {
+                    this.logger?.info({
+                        activity_ref: activityRef,
+                        error_name: error instanceof Error ? error.name : "UnknownError",
+                    }, "Reference summary continuation failed");
+                }
+            }
+            if (!this.closing) {
+                this.intentDispatcher.wake();
+                this.schedulePendingReferenceSummaryRefresh();
+                if (state.activity.status === "finished" &&
+                    (state.activity.workflow_kind === "scratchpad_refresh" ||
+                        state.activity.workflow_kind === "reference_summary_refresh")) {
+                    this.scheduleContextSyncAfterWorklistCompletion();
+                }
+            }
+        }
+    }
+    logProcedureTransition(state) {
+        const activity = state.activity;
+        const fields = {
+            activity_ref: activity.activity_ref,
+            activity_status: activity.status,
+            ...(activity.workflow_ref === undefined ? {} : { workflow_ref: activity.workflow_ref }),
+            ...(activity.workflow_kind === undefined ? {} : { workflow_kind: activity.workflow_kind }),
+            ...(activity.started_at === undefined ? {} : { started_at: activity.started_at }),
+            ...(activity.ended_at === undefined ? {} : { ended_at: activity.ended_at }),
+        };
+        if (activity.started_at !== undefined && activity.ended_at !== undefined) {
+            fields.duration_ms = Math.max(0, new Date(activity.ended_at).getTime() - new Date(activity.started_at).getTime());
+        }
+        const message = activity.status === "running"
+            ? "Procedure started"
+            : activity.status === "finished"
+                ? "Procedure completed"
+                : activity.status === "needs_human"
+                    ? "Procedure needs human input"
+                    : "Procedure failed";
+        this.logger?.info(fields, message);
+    }
+}
+//# sourceMappingURL=index.js.map