@xfey/tutti 0.1.96 → 0.1.97

package/dist/control-plane/index.js

@@ -1,4 +1,4 @@
-import { readActiveTaskCompileContext, readScratchpadSourceState, 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";
@@ -11,13 +11,14 @@ 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 {
@@ -34,6 +35,7 @@ export class Phase5ControlPlane {
     runLifecycle;
     now;
     scratchpadAutoRefreshScheduler;
+    intentDispatcher;
     pendingWorklistCompletionContextSyncTimer = null;
     pendingReferenceSummaryPaths = new Set();
     referenceSummaryWaiters = new Map();
@@ -41,6 +43,8 @@ export class Phase5ControlPlane {
     referenceSummaryStartScheduled = false;
     closing = false;
     asyncOwners = new Set();
+    pendingRunInputs = new Map();
+    runIntentTerminals = new Map();
     lastRecoveryConclusion = null;
     constructor(options) {
         this.store = options.store;
@@ -61,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({
@@ -99,7 +108,7 @@ export class Phase5ControlPlane {
         });
     }
     runStartupRecovery(options = {}) {
-        return runControlPlaneStartupRecovery({
+        const recovered = runControlPlaneStartupRecovery({
             store: this.store,
             events: this.events,
             options,
@@ -108,10 +117,17 @@ 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();
@@ -155,6 +171,7 @@ export class Phase5ControlPlane {
         this.cancelPendingWorklistCompletionContextSync();
         this.pendingAllReferenceSummaries = false;
         this.pendingReferenceSummaryPaths.clear();
+        this.intentDispatcher.dispose();
     }
     dispose() {
         this.beginShutdown();
@@ -314,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() {
@@ -357,6 +373,7 @@ export class Phase5ControlPlane {
         });
     }
     startRunForTask(input) {
+        this.pendingRunInputs.set(input.activity_ref, input);
         const result = startControlPlaneRunForTask({
             runEngine: this.runEngine,
             store: this.store,
@@ -378,6 +395,7 @@ export class Phase5ControlPlane {
             this.cancelPendingWorklistCompletionContextSync();
             this.runLifecycle?.started();
         }
+        this.intentDispatcher.wake();
         return result;
     }
     readActiveRun() {
@@ -460,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({
@@ -561,7 +584,7 @@ export class Phase5ControlPlane {
         clearTimeout(this.pendingWorklistCompletionContextSyncTimer);
         this.pendingWorklistCompletionContextSyncTimer = null;
     }
-    startTaskCompileContinuation(owner, roundId) {
+    startTaskCompileContinuation(owner, roundId, onTerminal) {
         let tasksAdded = false;
         return startControlPlaneTaskCompileContinuation({
             engine: this.engine,
@@ -585,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,
@@ -607,8 +631,232 @@ 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();
@@ -638,6 +886,7 @@ export class Phase5ControlPlane {
                 }
             }
             if (!this.closing) {
+                this.intentDispatcher.wake();
                 this.schedulePendingReferenceSummaryRefresh();
                 if (state.activity.status === "finished" &&
                     (state.activity.workflow_kind === "scratchpad_refresh" ||

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

package/dist/control-plane/intent-dispatcher.js

@@ -0,0 +1,184 @@
+import { randomUUID } from "node:crypto";
+import { claimControlPlaneIntent, listExpiredControlPlaneIntentClaims, listPendingControlPlaneIntents, markControlPlaneIntentRunning, releaseControlPlaneIntentClaim, renewControlPlaneIntentLease, requeueExpiredControlPlaneIntentClaim, settleClaimedControlPlaneIntent, } from "./dispatch-intents.js";
+const DEFAULT_RECONCILIATION_INTERVAL_MS = 1_000;
+const DEFAULT_CLAIM_LEASE_MS = 30_000;
+const DEFAULT_BUSY_RETRY_MS = 0;
+const DEFAULT_NOT_READY_RETRY_MS = 2_000;
+export class ControlPlaneIntentDispatcher {
+    store;
+    now;
+    handler;
+    reconciliationIntervalMs;
+    claimLeaseMs;
+    busyRetryMs;
+    notReadyRetryMs;
+    activeClaims = new Map();
+    timer = null;
+    wakeScheduled = false;
+    draining = false;
+    closing = false;
+    constructor(options) {
+        this.store = options.store;
+        this.handler = options.handler;
+        this.now = options.now ?? (() => new Date());
+        this.reconciliationIntervalMs =
+            options.reconciliationIntervalMs ?? DEFAULT_RECONCILIATION_INTERVAL_MS;
+        this.claimLeaseMs = options.claimLeaseMs ?? DEFAULT_CLAIM_LEASE_MS;
+        this.busyRetryMs = options.busyRetryMs ?? DEFAULT_BUSY_RETRY_MS;
+        this.notReadyRetryMs = options.notReadyRetryMs ?? DEFAULT_NOT_READY_RETRY_MS;
+    }
+    start() {
+        if (this.closing || this.timer !== null) {
+            return;
+        }
+        this.reconcileExpiredClaims();
+        this.timer = setInterval(() => {
+            this.renewActiveClaims();
+            this.reconcileExpiredClaims();
+            this.wake();
+        }, this.reconciliationIntervalMs);
+        this.timer.unref?.();
+        this.wake();
+    }
+    wake() {
+        if (this.closing || this.wakeScheduled) {
+            return;
+        }
+        this.wakeScheduled = true;
+        queueMicrotask(() => {
+            this.wakeScheduled = false;
+            this.drain();
+        });
+    }
+    dispose() {
+        if (this.closing) {
+            return;
+        }
+        this.closing = true;
+        if (this.timer !== null) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    drain() {
+        if (this.closing || this.draining || !this.store.db.open) {
+            return;
+        }
+        this.draining = true;
+        try {
+            for (const pending of listPendingControlPlaneIntents(this.store.db, {
+                now: this.now,
+            })) {
+                if (this.closing) {
+                    return;
+                }
+                const claimToken = randomUUID();
+                const leaseExpiresAt = this.after(this.claimLeaseMs);
+                const claimed = claimControlPlaneIntent(this.store.db, {
+                    intentId: pending.intent_id,
+                    claimToken,
+                    leaseExpiresAt,
+                    now: this.now,
+                });
+                if (claimed === null) {
+                    continue;
+                }
+                let terminalDelivered = false;
+                const terminal = (result = { state: "completed" }) => {
+                    if (terminalDelivered || !this.store.db.open) {
+                        return;
+                    }
+                    terminalDelivered = true;
+                    this.activeClaims.delete(claimed.intent_id);
+                    settleClaimedControlPlaneIntent(this.store.db, {
+                        intentId: claimed.intent_id,
+                        claimToken,
+                        state: result.state,
+                        ...(result.errorCode === undefined ? {} : { errorCode: result.errorCode }),
+                        now: this.now,
+                    });
+                    this.wake();
+                };
+                let start;
+                try {
+                    start = this.handler(claimed, { terminal });
+                }
+                catch {
+                    start = { kind: "not_ready", errorCode: "dispatch_start_failed" };
+                }
+                if (start.kind === "accepted") {
+                    const running = markControlPlaneIntentRunning(this.store.db, {
+                        intentId: claimed.intent_id,
+                        claimToken,
+                        leaseExpiresAt,
+                        now: this.now,
+                    });
+                    if (running !== null && !terminalDelivered) {
+                        this.activeClaims.set(claimed.intent_id, { claimToken, leaseExpiresAt });
+                    }
+                    continue;
+                }
+                if (terminalDelivered) {
+                    continue;
+                }
+                if (start.kind === "obsolete") {
+                    terminal({ state: "cancelled", errorCode: start.errorCode });
+                    continue;
+                }
+                releaseControlPlaneIntentClaim(this.store.db, {
+                    intentId: claimed.intent_id,
+                    claimToken,
+                    availableAt: start.kind === "not_ready" && start.availableAt !== undefined
+                        ? start.availableAt
+                        : this.after(start.kind === "busy" ? this.busyRetryMs : this.notReadyRetryMs),
+                    ...(start.kind === "not_ready" ? { errorCode: start.errorCode } : {}),
+                    now: this.now,
+                });
+            }
+        }
+        finally {
+            this.draining = false;
+        }
+    }
+    renewActiveClaims() {
+        if (this.closing || !this.store.db.open) {
+            return;
+        }
+        for (const [intentId, active] of this.activeClaims) {
+            const leaseExpiresAt = this.after(this.claimLeaseMs);
+            if (renewControlPlaneIntentLease(this.store.db, {
+                intentId,
+                claimToken: active.claimToken,
+                leaseExpiresAt,
+                now: this.now,
+            })) {
+                active.leaseExpiresAt = leaseExpiresAt;
+            }
+            else {
+                this.activeClaims.delete(intentId);
+            }
+        }
+    }
+    reconcileExpiredClaims() {
+        if (this.closing || !this.store.db.open) {
+            return;
+        }
+        for (const intent of listExpiredControlPlaneIntentClaims(this.store.db, {
+            now: this.now,
+        })) {
+            if (intent.kind === "run_dispatch" || intent.claim_token === undefined) {
+                continue;
+            }
+            requeueExpiredControlPlaneIntentClaim(this.store.db, {
+                intentId: intent.intent_id,
+                expectedClaimToken: intent.claim_token,
+                errorCode: "stale_runtime_owner",
+                now: this.now,
+            });
+        }
+    }
+    after(milliseconds) {
+        return new Date(this.now().getTime() + milliseconds).toISOString();
+    }
+}
+//# sourceMappingURL=intent-dispatcher.js.map

package/dist/control-plane/reference-summary-refresh.d.ts

@@ -2,10 +2,11 @@ import type { ActivityRef, WorkflowInvocationRef } from "@tutti/shared/ids";
 import type { RefreshReferenceSummariesDisposition, RefreshReferenceSummariesResult } from "@tutti/shared/schemas/api";
 import type { ProcedureEngine, ProcedureEngineState } from "../procedure-engine/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
-import type { HostProjectStore } from "../store/index.js";
+import { type HostProjectStore } from "../store/index.js";
 import { type ReferenceSummaryTarget } from "../workspace-ops/index.js";
 import type { ControlPlaneCommandResult, ControlPlaneLogger, Phase5ControlPlaneOptions } from "./types.js";
 import type { ProcedureWorkflowRunnerResolver } from "./workflows/index.js";
+import type { IntentRuntimeTerminal } from "./intent-dispatcher.js";
 export declare function startReferenceSummaryRefreshProcedure(input: {
     engine: ProcedureEngine;
     store: HostProjectStore;
@@ -24,5 +25,7 @@ export declare function startReferenceSummaryRefreshProcedure(input: {
     }) => void;
     onTargetsPersisted?: (targets: ReferenceSummaryTarget[]) => void;
     publishProcedureTransition: (state: ProcedureEngineState) => void;
+    recordRecoveryIntent?: boolean;
+    onTerminal?: (result?: IntentRuntimeTerminal) => void;
 }): ControlPlaneCommandResult<RefreshReferenceSummariesDisposition, RefreshReferenceSummariesResult>;
 //# sourceMappingURL=reference-summary-refresh.d.ts.map