@xfey/tutti 0.1.95 → 0.1.97

package/dist/control-plane/startup-recovery.js

@@ -1,13 +1,31 @@
-import { deleteStaleClarificationSubmitReplayHints, readStaleRunningTaskIdentities, readSealedClarificationRoundsWithoutSuccessor, recoverStaleRunningTasksAsFailed, recordRunResult, recordRecoverySummary, } from "../collaboration-state/index.js";
+import { deleteStaleClarificationSubmitReplayHints, readActiveClarificationProjection, readActiveTaskCompileContext, readPendingTaskCompileSubmission, readStaleRunningTaskIdentities, readSealedClarificationRoundsWithoutSuccessor, readRunResultProjectionByActivityRef, recoverStaleRunningTasksAsFailed, recordRunResult, recordRecoverySummary, recoverStaleScratchpadRefresh, } from "../collaboration-state/index.js";
 import { docsStatusForChangedPaths } from "../run-pipeline/result-projections.js";
 import { recoverInProgressCommandIdempotencyRecords, } from "../store/index.js";
 import { recoverAcceptedCheckpoint } from "../workspace-ops/index.js";
 import { resolveControlPlaneCommandRecovery } from "./command-recovery.js";
 import { formatStartupRecoverySummary } from "./formatters.js";
+import { enqueueControlPlaneIntent, listActiveControlPlaneIntentClaims, listNonTerminalControlPlaneIntentsByKind, requeueOrphanedControlPlaneIntentClaim, } from "./dispatch-intents.js";
+import { settleRunDispatchIntentAfterRecovery } from "./run-dispatch-intents.js";
 import { EXECUTION_STATUS_INVALIDATES, STARTUP_RECOVERY_INVALIDATES, taskRunResultInvalidates, } from "./invalidations.js";
 export function runControlPlaneStartupRecovery(input) {
     const options = input.options ?? {};
+    for (const intent of listActiveControlPlaneIntentClaims(input.store.db)) {
+        if (intent.kind === "run_dispatch" || intent.claim_token === undefined) {
+            continue;
+        }
+        requeueOrphanedControlPlaneIntentClaim(input.store.db, {
+            intentId: intent.intent_id,
+            expectedClaimToken: intent.claim_token,
+            errorCode: "host_restarted",
+            now: input.now,
+        });
+    }
     const staleReplayHintCount = deleteStaleClarificationSubmitReplayHints(input.store.db);
+    const recoveredScratchpadRefreshCount = recoverStaleScratchpadRefresh(input.store.db, {
+        now: input.now,
+    })
+        ? 1
+        : 0;
     const checkpointRecoveredRuns = [];
     const checkpointConflictRuns = [];
     if (options.workspaceRoot !== undefined) {
@@ -78,6 +96,16 @@ export function runControlPlaneStartupRecovery(input) {
         ...checkpointConflictRuns,
         ...interrupted.recovered_runs,
     ];
+    for (const intent of listNonTerminalControlPlaneIntentsByKind(input.store.db, "run_dispatch")) {
+        const activityRef = intent.owner_ref;
+        if (readRunResultProjectionByActivityRef(input.store.db, activityRef) !== null) {
+            settleRunDispatchIntentAfterRecovery(input.store.db, {
+                activityRef,
+                errorCode: "run_startup_reconciled",
+                now: input.now,
+            });
+        }
+    }
     const commandRecovery = options.recoverInProgressCommands
         ? recoverInProgressCommandIdempotencyRecords(input.store.db, {
             resolve: resolveControlPlaneCommandRecovery,
@@ -91,16 +119,54 @@ export function runControlPlaneStartupRecovery(input) {
             continue;
         }
         const roundId = sealed.round.id;
-        if (input.replaySealedRound(sealed, roundId)) {
+        if (input.enqueueSealedRound(sealed, roundId)) {
             replayedRoundIds.push(roundId);
         }
     }
+    const activeTaskCompileContext = readActiveTaskCompileContext(input.store.db);
+    const activeClarification = readActiveClarificationProjection(input.store.db);
+    const taskCompileWaitingForHuman = activeTaskCompileContext !== null &&
+        activeClarification.state === "active" &&
+        activeClarification.thread.owner.kind === "task_compile" &&
+        activeClarification.thread.owner.workflow_ref === activeTaskCompileContext.workflow_ref;
+    let recoveredTaskCompileCount = 0;
+    const pendingTaskCompileSubmission = readPendingTaskCompileSubmission(input.store.db);
+    if (activeTaskCompileContext === null && pendingTaskCompileSubmission !== null) {
+        const ensured = enqueueControlPlaneIntent(input.store.db, {
+            kind: "task_compile_start",
+            ownerKind: "task_compile",
+            ownerRef: pendingTaskCompileSubmission.workflow_ref,
+            dedupeKey: `task_compile_start:${pendingTaskCompileSubmission.workflow_ref}`,
+            lane: "foreground",
+            priority: 30,
+            now: input.now,
+        }).intent;
+        if (ensured.state === "pending" || ensured.state === "claimed" || ensured.state === "running") {
+            recoveredTaskCompileCount = 1;
+        }
+    }
+    if (activeTaskCompileContext !== null && !taskCompileWaitingForHuman) {
+        const ensured = enqueueControlPlaneIntent(input.store.db, {
+            kind: "task_compile_start",
+            ownerKind: "task_compile",
+            ownerRef: activeTaskCompileContext.workflow_ref,
+            dedupeKey: `task_compile_start:${activeTaskCompileContext.workflow_ref}`,
+            lane: "foreground",
+            priority: 30,
+            now: input.now,
+        }).intent;
+        if (ensured.state === "pending" || ensured.state === "claimed" || ensured.state === "running") {
+            recoveredTaskCompileCount = 1;
+        }
+    }
     const interruptedCommandCount = (options.interruptedCommandCount ?? 0) + (commandRecovery?.interrupted_count ?? 0);
     const affectedActivities = recoveredRuns.map((recoveredRun) => recoveredRun.activity_ref);
     const shouldRecord = affectedActivities.length > 0 ||
         replayedRoundIds.length > 0 ||
         interruptedCommandCount > 0 ||
-        staleReplayHintCount > 0;
+        staleReplayHintCount > 0 ||
+        recoveredTaskCompileCount > 0 ||
+        recoveredScratchpadRefreshCount > 0;
     if (!shouldRecord) {
         return { kind: "noop" };
     }
@@ -110,6 +176,8 @@ export function runControlPlaneStartupRecovery(input) {
         replayedRoundCount: replayedRoundIds.length,
         interruptedCommandCount,
         staleReplayHintCount,
+        recoveredTaskCompileCount,
+        recoveredScratchpadRefreshCount,
     });
     const recorded = recordRecoverySummary(input.store.db, {
         summary,
@@ -175,6 +243,8 @@ export function runControlPlaneStartupRecovery(input) {
         replayed_round_ids: replayedRoundIds,
         interrupted_command_count: interruptedCommandCount,
         stale_replay_hint_count: staleReplayHintCount,
+        recovered_task_compile_count: recoveredTaskCompileCount,
+        recovered_scratchpad_refresh_count: recoveredScratchpadRefreshCount,
     };
 }
 //# sourceMappingURL=startup-recovery.js.map

package/dist/control-plane/task-compile-continuation.d.ts

@@ -2,6 +2,7 @@ import type { ClarificationRoundRef } from "@tutti/shared/ids";
 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 { IntentRuntimeStartResult, IntentRuntimeTerminal } from "./intent-dispatcher.js";
 import type { ControlPlaneLogger } from "./types.js";
 import type { Phase5ControlPlaneOptions } from "./types.js";
 import type { ProcedureWorkflowRunnerResolver } from "./workflows/index.js";
@@ -23,5 +24,6 @@ export declare function startControlPlaneTaskCompileContinuation(options: {
     now: () => Date;
     publishProcedureTransition: (state: ProcedureEngineState) => void;
     onTasksAdded: () => void;
-}): boolean;
+    onTerminal?: (result?: IntentRuntimeTerminal) => void;
+}): IntentRuntimeStartResult;
 //# sourceMappingURL=task-compile-continuation.d.ts.map

package/dist/control-plane/task-compile-continuation.js

@@ -5,18 +5,18 @@ import { applyTaskCompileProcedureOutput } from "./task-compile-output.js";
 import { readTaskCompileClarificationRounds } from "./task-compile-clarification-context.js";
 import { materializePromptSourceMessages } from "./task-source-context.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
-import { materializeRecentReferences, readRecentReferenceSources, } from "./recent-references.js";
+import { materializeRecentReferences, readRecentReferenceSources } from "./recent-references.js";
 export function startControlPlaneTaskCompileContinuation(options) {
     if (options.owner.kind !== "task_compile") {
-        return false;
+        return { kind: "obsolete", errorCode: "owner_kind_mismatch" };
     }
     const workflowRef = options.owner.workflow_ref;
     if (readActiveTaskCompileContext(options.store.db, workflowRef) === null) {
-        return false;
+        return { kind: "obsolete", errorCode: "task_compile_context_absent" };
     }
     const runnerResolution = options.resolveWorkflowRunner();
     if (runnerResolution.kind !== "ready") {
-        return false;
+        return { kind: "not_ready", errorCode: "workflow_runner_unavailable" };
     }
     const start = options.engine.startProcedure({
         workflow_ref: workflowRef,
@@ -25,7 +25,14 @@ export function startControlPlaneTaskCompileContinuation(options) {
         title: "Continue Worklist Compile",
         summary: "Continuing task_compile from clarification input.",
         now: options.now,
-        onTransition: options.publishProcedureTransition,
+        onTransition: (state) => {
+            options.publishProcedureTransition(state);
+            if (state.transition_kind === "terminal") {
+                options.onTerminal?.(state.activity.status === "failed"
+                    ? { state: "failed", errorCode: "procedure_failed" }
+                    : undefined);
+            }
+        },
         onError: ({ context, error }) => logProcedureExecutionError({
             logger: options.logger,
             workflowKind: "task_compile",
@@ -57,9 +64,7 @@ export function startControlPlaneTaskCompileContinuation(options) {
                     scratchpad: taskCompileContext.scratchpad_snapshot,
                     source_messages: materializePromptSourceMessages(options.store.db, taskCompileContext.sources),
                     worklist: readWorklistProjection(options.store.db),
-                    ...(recentReferences.length === 0
-                        ? {}
-                        : { recent_references: recentReferences }),
+                    ...(recentReferences.length === 0 ? {} : { recent_references: recentReferences }),
                     clarification_rounds: clarificationRounds,
                 }, {
                     workflow_ref: workflowRef,
@@ -108,6 +113,6 @@ export function startControlPlaneTaskCompileContinuation(options) {
             }
         },
     });
-    return start.kind === "accepted";
+    return start.kind === "accepted" ? { kind: "accepted" } : { kind: "busy" };
 }
 //# sourceMappingURL=task-compile-continuation.js.map

package/dist/control-plane/task-compile-start.d.ts

@@ -1,9 +1,10 @@
-import { type ActivityRef, type WorkflowInvocationRef } from "@tutti/shared/ids";
+import { type ActivityRef, type ControlPlaneIntentId, type WorkflowInvocationRef } from "@tutti/shared/ids";
 import type { SubmitWorklistDisposition, SubmitWorklistPayload, SubmitWorklistResult } from "@tutti/shared/schemas/api";
 import type { ProcedureEngine, ProcedureEngineState, ProcedureProgressUpdate } from "../procedure-engine/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
 import type { HostProjectStore } from "../store/index.js";
 import type { ControlPlaneCommandResult, ControlPlaneLogger, Phase5ControlPlaneOptions } from "./types.js";
+import type { IntentRuntimeStartResult, IntentRuntimeTerminal } from "./intent-dispatcher.js";
 import type { ProcedureWorkflowRunner, ProcedureWorkflowRunnerResolver } from "./workflows/index.js";
 export declare function startControlPlaneTaskCompile(options: {
     engine: ProcedureEngine;
@@ -19,6 +20,37 @@ export declare function startControlPlaneTaskCompile(options: {
     onTasksAdded: () => void;
     shouldContinue?: () => boolean;
 }): ControlPlaneCommandResult<SubmitWorklistDisposition, SubmitWorklistResult>;
+export declare function resumePendingTaskCompileSubmission(options: {
+    engine: ProcedureEngine;
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    taskCompileWorkflowRef: WorkflowInvocationRef;
+    recoveryIntentId: ControlPlaneIntentId;
+    resolveWorkflowRunner: ProcedureWorkflowRunnerResolver;
+    projectContext: Phase5ControlPlaneOptions["projectContext"] | undefined;
+    logger: ControlPlaneLogger | undefined;
+    now: () => Date;
+    publishProcedureTransition: (state: ProcedureEngineState) => void;
+    registerReferenceSummaryWaiter: (activityRef: ActivityRef, waiter: (state: ProcedureEngineState) => void) => void;
+    onTasksAdded: () => void;
+    shouldContinue?: () => boolean;
+    onChainTerminal: (result?: IntentRuntimeTerminal) => void;
+}): IntentRuntimeStartResult;
+export declare function resumeControlPlaneTaskCompileChain(options: {
+    engine: ProcedureEngine;
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    taskCompileWorkflowRef: WorkflowInvocationRef;
+    resolveWorkflowRunner: ProcedureWorkflowRunnerResolver;
+    projectContext: Phase5ControlPlaneOptions["projectContext"] | undefined;
+    logger: ControlPlaneLogger | undefined;
+    now: () => Date;
+    publishProcedureTransition: (state: ProcedureEngineState) => void;
+    registerReferenceSummaryWaiter: (activityRef: ActivityRef, waiter: (state: ProcedureEngineState) => void) => void;
+    onTasksAdded: () => void;
+    shouldContinue?: () => boolean;
+    onChainTerminal: (result?: IntentRuntimeTerminal) => void;
+}): IntentRuntimeStartResult;
 export declare function runControlPlaneTaskCompileProcedure(options: {
     runner: ProcedureWorkflowRunner;
     workflowRef: WorkflowInvocationRef;

package/dist/control-plane/task-compile-start.js

@@ -1,11 +1,13 @@
 import { createWorkflowInvocationRef, } from "@tutti/shared/ids";
-import { captureTaskCompileContext, readActiveTaskCompileContext, readCurrentScratchpadSourceRefs, readScratchpadProjection, readWorklistProjection, rollbackTaskCompileContext, } from "../collaboration-state/index.js";
+import { captureTaskCompileContext, readActiveTaskCompileContext, readCurrentScratchpadSourceRefs, readPendingTaskCompileSubmission, readScratchpadProjection, readScratchpadSourceState, readWorklistProjection, recordTaskCompileSubmission, rollbackTaskCompileContext, } from "../collaboration-state/index.js";
+import { withHostStoreTransaction } from "../store/index.js";
 import { initializeProjectDocs, readProjectDocsInitializationStatus, } from "../workspace-ops/index.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
 import { projectBriefShouldRefreshForUpdatedPaths, refreshProjectBriefProjection, } from "./project-brief-refresh.js";
 import { applyProjectDocsInitializationResult, buildProjectDocsInitializationContext, tryProjectContextBootstrapDocuments, } from "./project-context-bootstrap.js";
 import { readActiveScratchpadRefreshActivityRef, readControlPlaneScratchpadSourceBatch, runControlPlaneScratchpadRefreshProcedure, } from "./scratchpad-refresh-start.js";
 import { applyTaskCompileProcedureOutput } from "./task-compile-output.js";
+import { enqueueControlPlaneIntent } from "./dispatch-intents.js";
 import { materializePromptSourceMessages } from "./task-source-context.js";
 import { materializeRecentReferences, readPendingRecentReferenceSummaryPaths, readRecentReferenceSources, } from "./recent-references.js";
 import { startReferenceSummaryRefreshProcedure } from "./reference-summary-refresh.js";
@@ -19,6 +21,15 @@ export function startControlPlaneTaskCompile(options) {
             },
         };
     }
+    const pendingSubmission = readPendingTaskCompileSubmission(options.store.db);
+    if (pendingSubmission !== null) {
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: pendingSubmission.accepted_activity_ref,
+            },
+        };
+    }
     const scratchpad = readScratchpadProjection(options.store.db);
     if (options.payload.expected_scratchpad_updated_at !== undefined &&
         options.payload.expected_scratchpad_updated_at !== scratchpad.updated_at) {
@@ -43,7 +54,10 @@ export function startControlPlaneTaskCompile(options) {
         };
     }
     const taskCompileWorkflowRef = createWorkflowInvocationRef();
-    const sourceBatch = readControlPlaneScratchpadSourceBatch(options.store);
+    const sourceBatch = readControlPlaneScratchpadSourceBatch(options.store, {
+        ...(options.projectContext === undefined ? {} : { projectContext: options.projectContext }),
+        now: options.now,
+    });
     if (sourceBatch.source_message_count > 0) {
         const activeScratchpadRefresh = readActiveScratchpadRefreshActivityRef({
             engine: options.engine,
@@ -62,22 +76,70 @@ export function startControlPlaneTaskCompile(options) {
             runner: runnerResolution.runner,
             sourceBatch,
             taskCompileWorkflowRef,
+            recordRecoveryIntent: false,
+            onAccepted: (activityRef) => recordTaskCompileSubmissionIntent({
+                store: options.store,
+                workflowRef: taskCompileWorkflowRef,
+                acceptedActivityRef: activityRef,
+                sourceBatch,
+                now: options.now,
+            }),
         });
     }
     if (!scratchpadHasSubmittableContent(scratchpad)) {
         return { disposition: { kind: "scratchpad_empty" } };
     }
-    return startReferenceSummaryGateOrNextStage({
+    const started = startReferenceSummaryGateOrNextStage({
         ...options,
         runner: runnerResolution.runner,
         taskCompileWorkflowRef,
     });
+    if (started.disposition.kind === "accepted") {
+        const activityRef = started.result?.activity_ref;
+        if (activityRef === undefined) {
+            throw new Error("Accepted Task Compile chain is missing activity identity");
+        }
+        recordTaskCompileSubmissionIntent({
+            store: options.store,
+            workflowRef: taskCompileWorkflowRef,
+            acceptedActivityRef: activityRef,
+            sourceBatch,
+            now: options.now,
+        });
+    }
+    return started;
+}
+function recordTaskCompileSubmissionIntent(options) {
+    return withHostStoreTransaction(options.store.db, (tx) => {
+        const sourceState = readScratchpadSourceState(tx);
+        const through = options.sourceBatch.cursor_update.refreshed_through_cursor ??
+            sourceState.refreshed_through_cursor;
+        recordTaskCompileSubmission(tx, {
+            workflow_ref: options.workflowRef,
+            accepted_activity_ref: options.acceptedActivityRef,
+            source_window: {
+                ...(sourceState.cycle_start_cursor === undefined
+                    ? {}
+                    : { after: sourceState.cycle_start_cursor }),
+                ...(through === undefined ? {} : { through }),
+            },
+            now: options.now,
+        });
+        return enqueueControlPlaneIntent(tx, {
+            kind: "task_compile_start",
+            ownerKind: "task_compile",
+            ownerRef: options.workflowRef,
+            dedupeKey: `task_compile_start:${options.workflowRef}`,
+            lane: "foreground",
+            priority: 30,
+            now: options.now,
+        }).intent.intent_id;
+    });
 }
 function startControlPlaneTaskCompileActivity(options) {
     const activeContext = readActiveTaskCompileContext(options.store.db, options.taskCompileWorkflowRef);
     const scratchpad = readScratchpadProjection(options.store.db);
-    if (activeContext === null &&
-        !scratchpadHasSubmittableContent(scratchpad)) {
+    if (activeContext === null && !scratchpadHasSubmittableContent(scratchpad)) {
         return { disposition: { kind: "scratchpad_empty" } };
     }
     const workflowRef = options.taskCompileWorkflowRef;
@@ -88,7 +150,14 @@ function startControlPlaneTaskCompileActivity(options) {
         title: "Compile Worklist",
         summary: "Compiling Scratchpad into Worklist tasks.",
         now: options.now,
-        onTransition: options.publishProcedureTransition,
+        onTransition: (state) => {
+            options.publishProcedureTransition(state);
+            if (state.transition_kind === "terminal") {
+                options.onChainTerminal?.(state.activity.status === "failed"
+                    ? { state: "failed", errorCode: "procedure_failed" }
+                    : undefined);
+            }
+        },
         onError: ({ context, error }) => logProcedureExecutionError({
             logger: options.logger,
             workflowKind: "task_compile",
@@ -126,6 +195,7 @@ function startControlPlaneTaskCompileActivity(options) {
 }
 function startScratchpadRefreshBeforeTaskCompileActivity(options) {
     const workflowRef = createWorkflowInvocationRef();
+    let recoveryIntentId = options.recoveryIntentId;
     const start = options.engine.startProcedure({
         workflow_ref: workflowRef,
         workflow_kind: "scratchpad_refresh",
@@ -135,7 +205,14 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
         now: options.now,
         onTransition: (state) => {
             options.publishProcedureTransition(state);
-            if (state.transition_kind !== "terminal" || state.activity.status !== "finished") {
+            if (state.transition_kind !== "terminal") {
+                return;
+            }
+            if (state.activity.status !== "finished") {
+                options.onChainTerminal?.({
+                    state: "failed",
+                    errorCode: "scratchpad_refresh_failed",
+                });
                 return;
             }
             if (options.shouldContinue?.() === false) {
@@ -143,9 +220,19 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
             }
             const scratchpad = readScratchpadProjection(options.store.db);
             if (!scratchpadHasSubmittableContent(scratchpad)) {
+                options.onChainTerminal?.({
+                    state: "failed",
+                    errorCode: "scratchpad_empty_after_refresh",
+                });
                 return;
             }
-            void startReferenceSummaryGateOrNextStage(options);
+            const next = startReferenceSummaryGateOrNextStage(options);
+            if (next.disposition.kind !== "accepted" && next.disposition.kind !== "already_running") {
+                options.onChainTerminal?.({
+                    state: "failed",
+                    errorCode: "task_compile_stage_unavailable",
+                });
+            }
         },
         onError: ({ context, error }) => logProcedureExecutionError({
             logger: options.logger,
@@ -161,6 +248,11 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
             workflowRef,
             activityRef: context.activity_ref,
             sourceBatch: options.sourceBatch,
+            lane: "foreground",
+            ...(options.recordRecoveryIntent === undefined
+                ? {}
+                : { recordRecoveryIntent: options.recordRecoveryIntent }),
+            ...(recoveryIntentId === undefined ? {} : { recoveryIntentId }),
             now: options.now,
         }),
     });
@@ -172,6 +264,8 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
             },
         };
     }
+    recoveryIntentId =
+        options.onAccepted?.(start.activity.activity_ref) ?? recoveryIntentId;
     return {
         disposition: { kind: "accepted" },
         result: {
@@ -180,6 +274,116 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
         },
     };
 }
+function cursorIncludes(current, required) {
+    if (required === undefined) {
+        return true;
+    }
+    if (current === undefined) {
+        return false;
+    }
+    const timeOrder = current.created_at.localeCompare(required.created_at);
+    return timeOrder > 0 || (timeOrder === 0 && current.message_id >= required.message_id);
+}
+export function resumePendingTaskCompileSubmission(options) {
+    const submission = readPendingTaskCompileSubmission(options.store.db, options.taskCompileWorkflowRef);
+    if (submission === null) {
+        return { kind: "obsolete", errorCode: "task_compile_submission_absent" };
+    }
+    const runnerResolution = options.resolveWorkflowRunner();
+    if (runnerResolution.kind !== "ready") {
+        return {
+            kind: "not_ready",
+            errorCode: runnerResolution.kind === "not_configured"
+                ? "provider_not_configured"
+                : "provider_unavailable",
+        };
+    }
+    const sourceState = readScratchpadSourceState(options.store.db);
+    if (cursorIncludes(sourceState.refreshed_through_cursor, submission.source_window.through)) {
+        const result = startReferenceSummaryGateOrNextStage({
+            ...options,
+            runner: runnerResolution.runner,
+        });
+        if (result.disposition.kind === "accepted") {
+            return { kind: "accepted" };
+        }
+        if (result.disposition.kind === "already_running") {
+            const activityRef = result.disposition.activity_ref;
+            const attached = options.engine
+                .getActiveProcedures()
+                .some((activity) => activity.activity_ref === activityRef &&
+                activity.workflow_kind === "reference_summary_refresh");
+            return attached ? { kind: "accepted" } : { kind: "busy" };
+        }
+        return { kind: "not_ready", errorCode: "task_compile_stage_unavailable" };
+    }
+    if (readActiveScratchpadRefreshActivityRef(options) !== undefined) {
+        return { kind: "busy" };
+    }
+    if (sourceState.backoff_until !== undefined &&
+        sourceState.backoff_until > options.now().toISOString()) {
+        return {
+            kind: "not_ready",
+            errorCode: "scratchpad_refresh_backoff",
+            availableAt: sourceState.backoff_until,
+        };
+    }
+    const sourceBatch = readControlPlaneScratchpadSourceBatch(options.store, {
+        ...(options.projectContext === undefined ? {} : { projectContext: options.projectContext }),
+        sourceWindow: submission.source_window,
+        now: options.now,
+    });
+    if (sourceBatch.source_message_count === 0) {
+        return {
+            kind: "not_ready",
+            errorCode: "task_compile_source_boundary_unavailable",
+        };
+    }
+    const result = startScratchpadRefreshBeforeTaskCompileActivity({
+        ...options,
+        runner: runnerResolution.runner,
+        sourceBatch,
+        taskCompileWorkflowRef: submission.workflow_ref,
+        recordRecoveryIntent: false,
+        recoveryIntentId: options.recoveryIntentId,
+    });
+    return result.disposition.kind === "accepted"
+        ? { kind: "accepted" }
+        : result.disposition.kind === "already_running"
+            ? { kind: "busy" }
+            : { kind: "not_ready", errorCode: "scratchpad_refresh_unavailable" };
+}
+export function resumeControlPlaneTaskCompileChain(options) {
+    if (readActiveTaskCompileContext(options.store.db, options.taskCompileWorkflowRef) === null) {
+        return { kind: "obsolete", errorCode: "task_compile_context_absent" };
+    }
+    const runnerResolution = options.resolveWorkflowRunner();
+    if (runnerResolution.kind !== "ready") {
+        return { kind: "not_ready", errorCode: "workflow_runner_unavailable" };
+    }
+    const result = startReferenceSummaryGateOrNextStage({
+        ...options,
+        runner: runnerResolution.runner,
+    });
+    if (result.disposition.kind === "accepted") {
+        return { kind: "accepted" };
+    }
+    if (result.disposition.kind === "already_running") {
+        const activityRef = result.disposition.activity_ref;
+        const attached = options.engine
+            .getActiveProcedures()
+            .some((activity) => activity.activity_ref === activityRef &&
+            activity.workflow_kind === "reference_summary_refresh");
+        return attached ? { kind: "accepted" } : { kind: "busy" };
+    }
+    if (result.disposition.kind === "provider_not_configured") {
+        return { kind: "not_ready", errorCode: "provider_not_configured" };
+    }
+    if (result.disposition.kind === "provider_unavailable") {
+        return { kind: "not_ready", errorCode: "provider_unavailable" };
+    }
+    return { kind: "not_ready", errorCode: "task_compile_stage_unavailable" };
+}
 function startReferenceSummaryGateOrNextStage(options) {
     const sourceRefs = readActiveTaskCompileContext(options.store.db, options.taskCompileWorkflowRef)?.sources ??
         readCurrentScratchpadSourceRefs(options.store.db);
@@ -194,8 +398,9 @@ function startReferenceSummaryGateOrNextStage(options) {
     if (pendingPaths.length === 0) {
         return startNextTaskCompileStage(options);
     }
-    const activeReferenceSummary = options.engine.getActiveProcedures().find((activity) => activity.lane === "foreground" &&
-        activity.workflow_kind === "reference_summary_refresh");
+    const activeReferenceSummary = options.engine
+        .getActiveProcedures()
+        .find((activity) => activity.lane === "foreground" && activity.workflow_kind === "reference_summary_refresh");
     if (activeReferenceSummary !== undefined) {
         readOrCaptureTaskCompileContext({
             store: options.store,
@@ -218,10 +423,10 @@ function startReferenceSummaryGateOrNextStage(options) {
         paths: pendingPaths,
         resolveWorkflowRunner: () => ({ kind: "ready", runner: options.runner }),
         readActiveActivity: () => {
-            const active = options.engine.getActiveProcedures().find((activity) => activity.lane === "foreground");
-            return active === undefined
-                ? null
-                : { activity_ref: active.activity_ref };
+            const active = options.engine
+                .getActiveProcedures()
+                .find((activity) => activity.lane === "foreground");
+            return active === undefined ? null : { activity_ref: active.activity_ref };
         },
         projectContext: options.projectContext,
         logger: options.logger,
@@ -266,6 +471,7 @@ function registerReferenceSummaryGateWaiter(options, activityRef) {
                 workflow_ref: options.taskCompileWorkflowRef,
                 now: options.now,
             });
+            options.onChainTerminal?.({ state: "failed", errorCode: "reference_summary_failed" });
             return;
         }
         void startReferenceSummaryGateOrNextStage(options);
@@ -301,7 +507,11 @@ function startProjectContextBootstrapActivity(options) {
         now: options.now,
         onTransition: (state) => {
             options.publishProcedureTransition(state);
-            if (state.transition_kind !== "terminal" || state.activity.status !== "finished") {
+            if (state.transition_kind !== "terminal") {
+                return;
+            }
+            if (state.activity.status !== "finished") {
+                options.onChainTerminal?.({ state: "failed", errorCode: "project_context_failed" });
                 return;
             }
             if (options.shouldContinue?.() === false) {
@@ -434,15 +644,11 @@ export async function runControlPlaneTaskCompileProcedure(options) {
             scratchpad: context.scratchpad_snapshot,
             source_messages: materializePromptSourceMessages(options.store.db, context.sources),
             worklist: readWorklistProjection(options.store.db),
-            ...(recentReferences.length === 0
-                ? {}
-                : { recent_references: recentReferences }),
+            ...(recentReferences.length === 0 ? {} : { recent_references: recentReferences }),
         }, {
             workflow_ref: options.workflowRef,
             activity_ref: options.activityRef,
-            ...(options.reportProgress === undefined
-                ? {}
-                : { reportProgress: options.reportProgress }),
+            ...(options.reportProgress === undefined ? {} : { reportProgress: options.reportProgress }),
         });
         return applyTaskCompileProcedureOutput({
             store: options.store,
@@ -463,12 +669,24 @@ export async function runControlPlaneTaskCompileProcedure(options) {
     }
 }
 function readOrCaptureTaskCompileContext(input) {
-    return (readActiveTaskCompileContext(input.store.db, input.workflowRef) ??
-        captureTaskCompileContext(input.store.db, {
-            workflow_ref: input.workflowRef,
-            captured_by_activity_ref: input.activityRef,
+    return withHostStoreTransaction(input.store.db, (tx) => {
+        const context = readActiveTaskCompileContext(tx, input.workflowRef) ??
+            captureTaskCompileContext(tx, {
+                workflow_ref: input.workflowRef,
+                captured_by_activity_ref: input.activityRef,
+                now: input.now,
+            });
+        enqueueControlPlaneIntent(tx, {
+            kind: "task_compile_start",
+            ownerKind: "task_compile",
+            ownerRef: input.workflowRef,
+            dedupeKey: `task_compile_start:${input.workflowRef}`,
+            lane: "foreground",
+            priority: 30,
             now: input.now,
-        }));
+        });
+        return context;
+    });
 }
 function scratchpadHasSubmittableContent(scratchpad) {
     if (scratchpad.state !== "ready") {