@xfey/tutti 0.1.96 → 0.1.98

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/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

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;