@xfey/tutti 0.1.95 → 0.1.97

package/dist/control-plane/index.js

@@ -1,7 +1,7 @@
-import { readActiveTaskCompileContext, readWorklistProjection, } from "../collaboration-state/index.js";
+import { readActiveClarificationProjection, readActiveTaskCompileContext, markScratchpadRefreshSucceeded, readPendingTaskCompileSubmission, readTaskProjectionByActivityRef, readScratchpadSourceState, readWorklistProjection, } from "../collaboration-state/index.js";
 import { ProcedureEngine } from "../procedure-engine/index.js";
 import { RunEngine } from "../run-engine/index.js";
-import { WorkspaceOpsError, readReferenceSummaryTargets, } from "../workspace-ops/index.js";
+import { WorkspaceOpsError, 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 { refreshProjectBriefProjection, } from "./project-brief-refresh.js";
@@ -11,14 +11,16 @@ 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 { startControlPlaneTaskCompile } from "./task-compile-start.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 { runSendClarificationRoundMessage, runSubmitClarificationRound, } from "./clarification-commands.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;
@@ -33,12 +35,16 @@ export class Phase5ControlPlane {
     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;
@@ -59,6 +65,11 @@ export class Phase5ControlPlane {
             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({
@@ -97,7 +108,7 @@ export class Phase5ControlPlane {
         });
     }
     runStartupRecovery(options = {}) {
-        return runControlPlaneStartupRecovery({
+        const recovered = runControlPlaneStartupRecovery({
             store: this.store,
             events: this.events,
             options,
@@ -106,12 +117,20 @@ export class Phase5ControlPlane {
             setLastRecoveryConclusion: (conclusion) => {
                 this.lastRecoveryConclusion = conclusion;
             },
-            replaySealedRound: (sealed, roundId) => sealed.thread.owner.kind === "task_compile"
-                ? this.startTaskCompileContinuation(sealed.thread.owner, roundId)
-                : this.startTaskBoundFollowUpCheck(sealed.thread.owner, sealed.thread.id, roundId),
+            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,
@@ -128,6 +147,7 @@ export class Phase5ControlPlane {
         if (!shouldUseMessageAsScratchpadSource(message)) {
             return;
         }
+        this.cancelPendingWorklistCompletionContextSync();
         this.scratchpadAutoRefreshScheduler.notifySourceChanged();
     }
     refreshProjectBrief(options) {
@@ -148,8 +168,10 @@ export class Phase5ControlPlane {
         }
         this.closing = true;
         this.scratchpadAutoRefreshScheduler.dispose();
+        this.cancelPendingWorklistCompletionContextSync();
         this.pendingAllReferenceSummaries = false;
         this.pendingReferenceSummaryPaths.clear();
+        this.intentDispatcher.dispose();
     }
     dispose() {
         this.beginShutdown();
@@ -171,6 +193,7 @@ export class Phase5ControlPlane {
         }
     }
     startTaskCompile(payload) {
+        this.cancelPendingWorklistCompletionContextSync();
         const activeRun = this.readActiveRun();
         if (activeRun !== null) {
             return {
@@ -211,6 +234,9 @@ export class Phase5ControlPlane {
         });
     }
     startContextSyncAnalysis(trigger = { kind: "manual" }) {
+        if (trigger.kind === "manual") {
+            this.cancelPendingWorklistCompletionContextSync();
+        }
         return startContextSyncAnalysisProcedure({
             engine: this.engine,
             store: this.store,
@@ -305,8 +331,7 @@ export class Phase5ControlPlane {
             payload,
             commandId,
             now: this.now,
-            startTaskCompileContinuation: (owner, submittedRoundId) => this.startTaskCompileContinuation(owner, submittedRoundId),
-            startTaskBoundFollowUpCheck: (owner, threadId, submittedRoundId) => this.startTaskBoundFollowUpCheck(owner, threadId, submittedRoundId),
+            wakeIntentDispatcher: () => this.intentDispatcher.wake(),
         });
     }
     async waitForIdle() {
@@ -348,6 +373,7 @@ export class Phase5ControlPlane {
         });
     }
     startRunForTask(input) {
+        this.pendingRunInputs.set(input.activity_ref, input);
         const result = startControlPlaneRunForTask({
             runEngine: this.runEngine,
             store: this.store,
@@ -366,8 +392,10 @@ export class Phase5ControlPlane {
             publishRunResultRecorded: (recorded) => this.publishRunResultRecorded(recorded),
         });
         if (result.kind === "accepted") {
+            this.cancelPendingWorklistCompletionContextSync();
             this.runLifecycle?.started();
         }
+        this.intentDispatcher.wake();
         return result;
     }
     readActiveRun() {
@@ -450,9 +478,14 @@ export class Phase5ControlPlane {
         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) {
                 emitTaskCompletedResultMessage({
@@ -497,7 +530,7 @@ export class Phase5ControlPlane {
         if (this.tryRunTaskArrivalScheduler()) {
             return;
         }
-        this.maybeStartContextSyncAfterWorklistCompletion();
+        this.scheduleContextSyncAfterWorklistCompletion();
     }
     worklistCompletionContextSyncTrigger() {
         const worklist = readWorklistProjection(this.store.db);
@@ -511,17 +544,47 @@ export class Phase5ControlPlane {
             module_count: worklist.modules.length,
         };
     }
-    maybeStartContextSyncAfterWorklistCompletion() {
-        if (this.closing) {
+    scheduleContextSyncAfterWorklistCompletion() {
+        if (this.closing ||
+            !this.store.db.open ||
+            this.pendingWorklistCompletionContextSyncTimer !== null) {
+            return;
+        }
+        const sourceState = readScratchpadSourceState(this.store.db);
+        if (this.worklistCompletionContextSyncTrigger() === undefined ||
+            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 trigger = this.worklistCompletionContextSyncTrigger();
-        if (trigger === undefined || this.readSchedulerBlocker() !== null) {
+        const sourceState = readScratchpadSourceState(this.store.db);
+        if (trigger === undefined ||
+            sourceState.dirty_since !== undefined ||
+            sourceState.in_flight !== undefined ||
+            this.readSchedulerBlocker() !== null) {
             return;
         }
         void this.startContextSyncAnalysis(trigger);
     }
-    startTaskCompileContinuation(owner, roundId) {
+    cancelPendingWorklistCompletionContextSync() {
+        if (this.pendingWorklistCompletionContextSyncTimer === null) {
+            return;
+        }
+        clearTimeout(this.pendingWorklistCompletionContextSyncTimer);
+        this.pendingWorklistCompletionContextSyncTimer = null;
+    }
+    startTaskCompileContinuation(owner, roundId, onTerminal) {
         let tasksAdded = false;
         return startControlPlaneTaskCompileContinuation({
             engine: this.engine,
@@ -545,9 +608,10 @@ export class Phase5ControlPlane {
             onTasksAdded: () => {
                 tasksAdded = true;
             },
+            ...(onTerminal === undefined ? {} : { onTerminal }),
         });
     }
-    startTaskBoundFollowUpCheck(owner, threadId, roundId) {
+    startTaskBoundFollowUpCheck(owner, threadId, roundId, onTerminal) {
         return startControlPlaneTaskBoundFollowUpCheck({
             engine: this.engine,
             store: this.store,
@@ -567,9 +631,236 @@ export class Phase5ControlPlane {
                 }
             },
             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,
@@ -595,7 +886,13 @@ export class Phase5ControlPlane {
                 }
             }
             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();
+                }
             }
         }
     }

package/dist/control-plane/intent-dispatcher.d.ts

@@ -0,0 +1,52 @@
+import type { HostProjectStore } from "../store/index.js";
+import { type ControlPlaneIntent, type ControlPlaneIntentTerminalState } from "./dispatch-intents.js";
+export type IntentRuntimeTerminal = {
+    state: ControlPlaneIntentTerminalState;
+    errorCode?: string;
+};
+export type IntentRuntimeStartResult = {
+    kind: "accepted";
+} | {
+    kind: "busy";
+} | {
+    kind: "not_ready";
+    errorCode: string;
+    availableAt?: string;
+} | {
+    kind: "obsolete";
+    errorCode: string;
+};
+export type ControlPlaneIntentRuntimeHandler = (intent: ControlPlaneIntent, runtime: {
+    terminal: (result?: IntentRuntimeTerminal) => void;
+}) => IntentRuntimeStartResult;
+export declare class ControlPlaneIntentDispatcher {
+    private readonly store;
+    private readonly now;
+    private readonly handler;
+    private readonly reconciliationIntervalMs;
+    private readonly claimLeaseMs;
+    private readonly busyRetryMs;
+    private readonly notReadyRetryMs;
+    private readonly activeClaims;
+    private timer;
+    private wakeScheduled;
+    private draining;
+    private closing;
+    constructor(options: {
+        store: HostProjectStore;
+        handler: ControlPlaneIntentRuntimeHandler;
+        now?: () => Date;
+        reconciliationIntervalMs?: number;
+        claimLeaseMs?: number;
+        busyRetryMs?: number;
+        notReadyRetryMs?: number;
+    });
+    start(): void;
+    wake(): void;
+    dispose(): void;
+    private drain;
+    private renewActiveClaims;
+    private reconcileExpiredClaims;
+    private after;
+}
+//# sourceMappingURL=intent-dispatcher.d.ts.map