@xfey/tutti 0.1.95 → 0.1.97

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

package/dist/control-plane/reference-summary-refresh.js

@@ -1,7 +1,9 @@
 import { createWorkflowInvocationRef } from "@tutti/shared/ids";
 import { recordProjectTimelineEvent } from "../project-timeline/index.js";
+import { withHostStoreTransaction } from "../store/index.js";
 import { WorkspaceOpsError, readReferenceSummaryTargets, updateReferenceSummaries, } from "../workspace-ops/index.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
+import { enqueueControlPlaneIntent, readControlPlaneIntentByDedupeKey, settlePendingControlPlaneIntent, } from "./dispatch-intents.js";
 const REFERENCE_SUMMARY_CONCURRENCY = 1;
 const REFERENCE_SUMMARY_MAX_ATTEMPTS = 2;
 function publishReferenceSummaryTimelineChanged(input) {
@@ -357,7 +359,27 @@ export function startReferenceSummaryRefreshProcedure(input) {
         title: "Refresh Reference Summaries",
         summary: "Summarizing reference files.",
         now: input.now,
-        onTransition: input.publishProcedureTransition,
+        onTransition: (state) => {
+            if (state.transition_kind === "terminal" && input.recordRecoveryIntent !== false) {
+                const intent = readControlPlaneIntentByDedupeKey(input.store.db, `reference_summary_refresh:${state.activity.activity_ref}`);
+                if (intent?.state === "pending") {
+                    settlePendingControlPlaneIntent(input.store.db, {
+                        intentId: intent.intent_id,
+                        state: state.activity.status === "failed" ? "failed" : "completed",
+                        ...(state.activity.status === "failed"
+                            ? { errorCode: "reference_summary_failed" }
+                            : {}),
+                        now: input.now,
+                    });
+                }
+            }
+            input.publishProcedureTransition(state);
+            if (state.transition_kind === "terminal") {
+                input.onTerminal?.(state.activity.status === "failed"
+                    ? { state: "failed", errorCode: "reference_summary_failed" }
+                    : undefined);
+            }
+        },
         onError: ({ context, error }) => logProcedureExecutionError({
             logger: input.logger,
             workflowKind: "reference_summary_refresh",
@@ -366,9 +388,22 @@ export function startReferenceSummaryRefreshProcedure(input) {
             error,
         }),
         execute: async (context) => {
-            input.onExecuteStart?.({
-                activityRef: context.activity_ref,
-                workflowRef,
+            withHostStoreTransaction(input.store.db, (tx) => {
+                if (input.recordRecoveryIntent !== false) {
+                    enqueueControlPlaneIntent(tx, {
+                        kind: "reference_summary_refresh",
+                        ownerKind: "reference_summary",
+                        ownerRef: context.activity_ref,
+                        dedupeKey: `reference_summary_refresh:${context.activity_ref}`,
+                        lane: "foreground",
+                        priority: 50,
+                        now: input.now,
+                    });
+                }
+                input.onExecuteStart?.({
+                    activityRef: context.activity_ref,
+                    workflowRef,
+                });
             });
             return runReferenceSummaryRefresh({
                 store: input.store,

package/dist/control-plane/run-dispatch-intents.d.ts

@@ -0,0 +1,15 @@
+import type { ActivityRef } from "@tutti/shared/ids";
+import type { SqliteDatabase } from "../store/index.js";
+export declare function enqueueRunDispatchIntent(db: SqliteDatabase, input: {
+    activityRef: ActivityRef;
+    now: () => Date;
+}): {
+    intent: import("./dispatch-intents.js").ControlPlaneIntent;
+    created: boolean;
+};
+export declare function settleRunDispatchIntentAfterRecovery(db: SqliteDatabase, input: {
+    activityRef: ActivityRef;
+    errorCode: string;
+    now: () => Date;
+}): boolean;
+//# sourceMappingURL=run-dispatch-intents.d.ts.map

package/dist/control-plane/run-dispatch-intents.js

@@ -0,0 +1,40 @@
+import { enqueueControlPlaneIntent, readControlPlaneIntentByDedupeKey, settleClaimedControlPlaneIntent, settlePendingControlPlaneIntent, } from "./dispatch-intents.js";
+export function enqueueRunDispatchIntent(db, input) {
+    return enqueueControlPlaneIntent(db, {
+        kind: "run_dispatch",
+        ownerKind: "task_run",
+        ownerRef: input.activityRef,
+        dedupeKey: `run_dispatch:${input.activityRef}`,
+        lane: "run",
+        priority: 10,
+        now: input.now,
+    });
+}
+export function settleRunDispatchIntentAfterRecovery(db, input) {
+    const intent = readControlPlaneIntentByDedupeKey(db, `run_dispatch:${input.activityRef}`);
+    if (intent === null ||
+        intent.state === "completed" ||
+        intent.state === "failed" ||
+        intent.state === "cancelled") {
+        return false;
+    }
+    if (intent.state === "pending") {
+        return (settlePendingControlPlaneIntent(db, {
+            intentId: intent.intent_id,
+            state: "completed",
+            errorCode: input.errorCode,
+            now: input.now,
+        }) !== null);
+    }
+    if (intent.claim_token === undefined) {
+        return false;
+    }
+    return (settleClaimedControlPlaneIntent(db, {
+        intentId: intent.intent_id,
+        claimToken: intent.claim_token,
+        state: "completed",
+        errorCode: input.errorCode,
+        now: input.now,
+    }) !== null);
+}
+//# sourceMappingURL=run-dispatch-intents.js.map

package/dist/control-plane/run-retry.d.ts

@@ -1,6 +1,6 @@
 import { type ActivityRef, type TaskId } from "@tutti/shared/ids";
 import type { RetryTaskDisposition, RetryTaskPayload } from "@tutti/shared/schemas/api";
-import type { HostProjectStore } from "../store/index.js";
+import { type HostProjectStore } from "../store/index.js";
 import type { StartRunForTaskInput } from "./run-start.js";
 import type { ControlPlaneCommandResult, RunPipelineResolver } from "./types.js";
 type ActiveActivity = {

package/dist/control-plane/run-retry.js

@@ -1,13 +1,15 @@
 import { createActivityRef, } from "@tutti/shared/ids";
 import { materializeTaskRetryRun, readNextRunnableTask, readTaskDetailProjection, readTaskRunResultsPage, } from "../collaboration-state/index.js";
+import { withHostStoreTransaction } from "../store/index.js";
 import { toDomainRunLineage } from "./run-lineage.js";
+import { enqueueRunDispatchIntent } from "./run-dispatch-intents.js";
 function retryCorrectionContext(result, detail) {
     const resultProjection = detail.detail.result;
     const reasonCode = result.result_kind === "failed"
         ? result.error_code
         : resultProjection.checks === "failed"
             ? "checks_failed"
-            : resultProjection.promotion?.reason_code ?? "previous_run_failed";
+            : (resultProjection.promotion?.reason_code ?? "previous_run_failed");
     return {
         previous_provider_result: result.result_kind === "finished"
             ? {
@@ -58,11 +60,17 @@ export function retryControlPlaneTask(input) {
         return { disposition: { kind: "task_not_failed" } };
     }
     const activityRef = createActivityRef();
-    const materialized = materializeTaskRetryRun(input.store.db, {
-        task_id: input.taskId,
-        expected_latest_run_result_id: input.payload.expected_latest_run_result_id,
-        activity_ref: activityRef,
-        now: input.now,
+    const materialized = withHostStoreTransaction(input.store.db, (tx) => {
+        const retry = materializeTaskRetryRun(tx, {
+            task_id: input.taskId,
+            expected_latest_run_result_id: input.payload.expected_latest_run_result_id,
+            activity_ref: activityRef,
+            now: input.now,
+        });
+        if (retry.disposition.kind === "accepted") {
+            enqueueRunDispatchIntent(tx, { activityRef, now: input.now });
+        }
+        return retry;
     });
     if (materialized.disposition.kind !== "accepted") {
         return materialized;

package/dist/control-plane/run-scheduler.d.ts

@@ -1,7 +1,7 @@
 import { type ActivityRef } from "@tutti/shared/ids";
 import type { RunSchedulerNowDisposition, RunSchedulerNowPayload, ProcedureLane } from "@tutti/shared/schemas/api";
 import type { StartRunResult } from "../run-engine/index.js";
-import type { HostProjectStore } from "../store/index.js";
+import { type HostProjectStore } from "../store/index.js";
 import type { ControlPlaneCommandResult, RunPipelineResolver } from "./types.js";
 import type { StartRunForTaskInput } from "./run-start.js";
 type ActiveActivity = {

package/dist/control-plane/run-scheduler.js

@@ -1,5 +1,7 @@
 import { createActivityRef, } from "@tutti/shared/ids";
 import { markTaskRunStarted, readActiveClarificationProjection, readNextRunnableTask, readTaskDetailProjection, } from "../collaboration-state/index.js";
+import { withHostStoreTransaction } from "../store/index.js";
+import { enqueueRunDispatchIntent } from "./run-dispatch-intents.js";
 function runControlPlaneScheduler(input) {
     const activeActivity = input.readSchedulerBlocker();
     if (activeActivity !== null) {
@@ -49,10 +51,16 @@ function runControlPlaneScheduler(input) {
         return { disposition: { kind: "nothing_to_run" } };
     }
     const activityRef = createActivityRef();
-    const started = markTaskRunStarted(input.store.db, {
-        task_id: nextTaskId,
-        activity_ref: activityRef,
-        now: input.now,
+    const started = withHostStoreTransaction(input.store.db, (tx) => {
+        const materialized = markTaskRunStarted(tx, {
+            task_id: nextTaskId,
+            activity_ref: activityRef,
+            now: input.now,
+        });
+        if (materialized.kind === "started") {
+            enqueueRunDispatchIntent(tx, { activityRef, now: input.now });
+        }
+        return materialized;
     });
     if (started.kind !== "started") {
         return { disposition: { kind: "nothing_to_run" } };

package/dist/control-plane/scratchpad-refresh-start.d.ts

@@ -1,11 +1,12 @@
-import { createWorkflowInvocationRef, type ActivityRef } from "@tutti/shared/ids";
+import { createWorkflowInvocationRef, type ActivityRef, type ControlPlaneIntentId } from "@tutti/shared/ids";
 import type { RefreshScratchpadDisposition, RefreshScratchpadResult, ProcedureLane } from "@tutti/shared/schemas/api";
 import type { ScratchpadSourceCursorUpdate } from "../collaboration-state/scratchpad-source-state.js";
-import type { ScratchpadSourceRefInput } from "../collaboration-state/types.js";
+import type { ScratchpadSourceRefInput, TaskCompileSubmissionRecord } from "../collaboration-state/types.js";
 import type { ProcedureEngine, ProcedureEngineState } from "../procedure-engine/index.js";
 import type { HostProjectStore } from "../store/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
 import type { ControlPlaneCommandResult, ControlPlaneLogger } from "./types.js";
+import type { IntentRuntimeTerminal } from "./intent-dispatcher.js";
 import type { ProcedureWorkflowRunner, ProcedureWorkflowRunnerResolver } from "./workflows/index.js";
 type ScratchpadProjectContext = {
     workspaceRoot: string;
@@ -18,6 +19,7 @@ export type ScratchpadSourceBatch = {
 };
 export declare function readControlPlaneScratchpadSourceBatch(store: HostProjectStore, options?: {
     projectContext?: ScratchpadProjectContext | undefined;
+    sourceWindow?: TaskCompileSubmissionRecord["source_window"];
     now?: () => Date;
 }): ScratchpadSourceBatch;
 export declare function runControlPlaneScratchpadRefreshProcedure(options: {
@@ -27,6 +29,9 @@ export declare function runControlPlaneScratchpadRefreshProcedure(options: {
     store: HostProjectStore;
     events: WorkspaceEventBus;
     sourceBatch: ScratchpadSourceBatch;
+    lane: ProcedureLane;
+    recordRecoveryIntent?: boolean;
+    recoveryIntentId?: ControlPlaneIntentId;
     now: () => Date;
 }): Promise<{
     kind: "needs_human";
@@ -57,6 +62,9 @@ export declare function startControlPlaneScratchpadRefresh(options: {
     logger?: ControlPlaneLogger | undefined;
     now: () => Date;
     publishProcedureTransition: (state: ProcedureEngineState) => void;
+    recordRecoveryIntent?: boolean;
+    recoveryIntentId?: ControlPlaneIntentId;
+    onTerminal?: (result?: IntentRuntimeTerminal) => void;
 }): ControlPlaneCommandResult<RefreshScratchpadDisposition, RefreshScratchpadResult>;
 export {};
 //# sourceMappingURL=scratchpad-refresh-start.d.ts.map

package/dist/control-plane/scratchpad-refresh-start.js

@@ -1,7 +1,9 @@
 import { createWorkflowInvocationRef, } from "@tutti/shared/ids";
 import { readActiveTaskCompileContext, readMainChatMessagesForScratchpadCycle, readScratchpadSourceState, readWorklistProjection, markScratchpadRefreshFailed, markScratchpadRefreshStarted, } from "../collaboration-state/index.js";
 import { readProjectBriefProjection, readProjectBriefSourceDocuments, } from "../project-brief/index.js";
+import { withHostStoreTransaction } from "../store/index.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
+import { enqueueControlPlaneIntent, readControlPlaneIntentByDedupeKey, settlePendingControlPlaneIntent, } from "./dispatch-intents.js";
 import { applyScratchpadRefreshOutput } from "./scratchpad-refresh.js";
 import { compactScratchpadSourceMessages, compactScratchpadWorklist, filterScratchpadSourceMessages, MAX_SOURCE_MESSAGES_TOTAL_CHARS, MIN_SOURCE_MESSAGE_TEXT_CHARS, ScratchpadSourceBudgetExceededError, } from "./scratchpad-source-messages.js";
 const SCRATCHPAD_REFRESH_FAILURE_BACKOFF_MS = 60_000;
@@ -76,7 +78,14 @@ function fitScratchpadRefreshWorkflowInput(input) {
 }
 export function readControlPlaneScratchpadSourceBatch(store, options = {}) {
     const sourceState = readScratchpadSourceState(store.db);
-    const mainChatMessages = readMainChatMessagesForScratchpadCycle(store.db, sourceState.cycle_start_cursor);
+    const mainChatMessages = readMainChatMessagesForScratchpadCycle(store.db, options.sourceWindow?.after ?? sourceState.cycle_start_cursor).filter((message) => {
+        const through = options.sourceWindow?.through;
+        if (through === undefined) {
+            return true;
+        }
+        const timeOrder = message.created_at.localeCompare(through.created_at);
+        return timeOrder < 0 || (timeOrder === 0 && message.id <= through.message_id);
+    });
     const sourceMessages = filterScratchpadSourceMessages(mainChatMessages);
     const latestSource = sourceMessages.at(-1);
     const unrefreshedSourceCount = sourceMessages.filter((message) => {
@@ -95,9 +104,7 @@ export function readControlPlaneScratchpadSourceBatch(store, options = {}) {
     });
     const workflowInput = fitScratchpadRefreshWorkflowInput({
         ...(projectBrief === undefined ? {} : { projectBrief }),
-        ...(activeContext === null
-            ? {}
-            : { activeTaskCompile: activeContext.scratchpad_snapshot }),
+        ...(activeContext === null ? {} : { activeTaskCompile: activeContext.scratchpad_snapshot }),
         worklist: readWorklistProjection(store.db),
         sourceMessages,
     });
@@ -120,9 +127,24 @@ export function readControlPlaneScratchpadSourceBatch(store, options = {}) {
     };
 }
 export async function runControlPlaneScratchpadRefreshProcedure(options) {
-    markScratchpadRefreshStarted(options.store.db, {
-        activityRef: options.activityRef,
-        now: options.now,
+    withHostStoreTransaction(options.store.db, (tx) => {
+        let intentId = options.recoveryIntentId;
+        if (options.recordRecoveryIntent !== false) {
+            intentId = enqueueControlPlaneIntent(tx, {
+                kind: "scratchpad_refresh",
+                ownerKind: "scratchpad",
+                ownerRef: options.activityRef,
+                dedupeKey: `scratchpad_refresh:${options.activityRef}`,
+                lane: options.lane,
+                priority: options.lane === "scratchpad_background" ? 80 : 40,
+                now: options.now,
+            }).intent.intent_id;
+        }
+        markScratchpadRefreshStarted(tx, {
+            activityRef: options.activityRef,
+            ...(intentId === undefined ? {} : { intentId }),
+            now: options.now,
+        });
     });
     let output;
     try {
@@ -196,7 +218,27 @@ export function startControlPlaneScratchpadRefresh(options) {
         title: "Refresh Scratchpad",
         summary: "Refreshing Scratchpad from main chat.",
         now: options.now,
-        onTransition: options.publishProcedureTransition,
+        onTransition: (state) => {
+            if (state.transition_kind === "terminal" && options.recordRecoveryIntent !== false) {
+                const intent = readControlPlaneIntentByDedupeKey(options.store.db, `scratchpad_refresh:${state.activity.activity_ref}`);
+                if (intent?.state === "pending") {
+                    settlePendingControlPlaneIntent(options.store.db, {
+                        intentId: intent.intent_id,
+                        state: state.activity.status === "failed" ? "failed" : "completed",
+                        ...(state.activity.status === "failed"
+                            ? { errorCode: "scratchpad_refresh_failed" }
+                            : {}),
+                        now: options.now,
+                    });
+                }
+            }
+            options.publishProcedureTransition(state);
+            if (state.transition_kind === "terminal") {
+                options.onTerminal?.(state.activity.status === "failed"
+                    ? { state: "failed", errorCode: "scratchpad_refresh_failed" }
+                    : undefined);
+            }
+        },
         onError: ({ context, error }) => logProcedureExecutionError({
             logger: options.logger,
             workflowKind: "scratchpad_refresh",
@@ -211,6 +253,13 @@ export function startControlPlaneScratchpadRefresh(options) {
             store: options.store,
             events: options.events,
             sourceBatch,
+            lane: options.lane ?? "foreground",
+            ...(options.recordRecoveryIntent === undefined
+                ? {}
+                : { recordRecoveryIntent: options.recordRecoveryIntent }),
+            ...(options.recoveryIntentId === undefined
+                ? {}
+                : { recoveryIntentId: options.recoveryIntentId }),
             now: options.now,
         }),
     });

package/dist/control-plane/scratchpad-refresh.js

@@ -1,5 +1,5 @@
-import { createMainChatAgentMessage, markScratchpadRefreshSucceeded, markScratchpadSourceDirty, upsertScratchpadProjection, } from "../collaboration-state/index.js";
-import { mainChatInvalidates, scratchpadRefreshInvalidates, } from "./invalidations.js";
+import { createMainChatAgentMessage, markScratchpadRefreshSucceeded, upsertScratchpadProjection, } from "../collaboration-state/index.js";
+import { mainChatInvalidates, scratchpadRefreshInvalidates } from "./invalidations.js";
 export function applyScratchpadRefreshOutput(input) {
     if (input.output.decision === "needs_human") {
         const message = createMainChatAgentMessage(input.store.db, {
@@ -7,7 +7,7 @@ export function applyScratchpadRefreshOutput(input) {
             refs: {
                 workflow_ref: input.workflowRef,
                 activity_ref: input.activityRef,
-                scratchpad_source: "include",
+                scratchpad_source: "exclude",
             },
             now: input.now,
         });
@@ -20,7 +20,6 @@ export function applyScratchpadRefreshOutput(input) {
             ...input.cursorUpdate,
             now: input.now,
         });
-        markScratchpadSourceDirty(input.store.db, { now: input.now });
         return {
             kind: "needs_human",
             summary: input.output.request_payload.summary,

package/dist/control-plane/startup-recovery.d.ts

@@ -5,7 +5,7 @@ import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js
 import { type HostProjectStore } from "../store/index.js";
 import type { StartupRecoveryOptions, StartupRecoveryResult } from "./types.js";
 type LastRecoveryConclusion = NonNullable<ExecutionStatusProjection["last_conclusion"]>;
-export type StartupRecoveryReplaySealedRound = (sealed: SealedClarificationRoundWithoutSuccessor, roundId: ClarificationRoundRef) => boolean;
+export type StartupRecoveryEnqueueSealedRound = (sealed: SealedClarificationRoundWithoutSuccessor, roundId: ClarificationRoundRef) => boolean;
 export declare function runControlPlaneStartupRecovery(input: {
     store: HostProjectStore;
     events: WorkspaceEventBus;
@@ -13,7 +13,7 @@ export declare function runControlPlaneStartupRecovery(input: {
     now: () => Date;
     getExecutionStatus: () => ExecutionStatusProjection;
     setLastRecoveryConclusion: (conclusion: LastRecoveryConclusion) => void;
-    replaySealedRound: StartupRecoveryReplaySealedRound;
+    enqueueSealedRound: StartupRecoveryEnqueueSealedRound;
 }): StartupRecoveryResult;
 export {};
 //# sourceMappingURL=startup-recovery.d.ts.map