@xfey/tenso 0.1.130

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

@@ -0,0 +1,771 @@
+import { createWorkflowInvocationRef, } from "@tutti/shared/ids";
+import { workflowLanguageContext, sourceLanguageEvidence, logLanguageContext, } from "./communication-language.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";
+import { linkTaskCompileActivity, closeFailedTaskCompileRequest, } from "../collaboration-state/task-compile-requests.js";
+export function startControlPlaneTaskCompile(options) {
+    const activeContext = readActiveTaskCompileContext(options.store.db);
+    if (activeContext !== null) {
+        return {
+            result: {
+                submission_ref: activeContext.workflow_ref,
+                activity_ref: activeContext.captured_by_activity_ref,
+            },
+            disposition: {
+                kind: "already_running",
+                activity_ref: activeContext.captured_by_activity_ref,
+            },
+        };
+    }
+    const pendingSubmission = readPendingTaskCompileSubmission(options.store.db);
+    if (pendingSubmission !== null) {
+        return {
+            result: {
+                submission_ref: pendingSubmission.workflow_ref,
+                activity_ref: pendingSubmission.accepted_activity_ref,
+            },
+            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) {
+        return {
+            disposition: {
+                kind: "stale_scratchpad",
+                current_scratchpad: scratchpad,
+            },
+        };
+    }
+    const runnerResolution = options.resolveWorkflowRunner();
+    if (runnerResolution.kind === "not_configured") {
+        return { disposition: { kind: "provider_not_configured" } };
+    }
+    if (runnerResolution.kind === "unavailable") {
+        return {
+            disposition: {
+                kind: "provider_unavailable",
+                reason: runnerResolution.reason,
+                retryable: runnerResolution.retryable,
+            },
+        };
+    }
+    const taskCompileWorkflowRef = createWorkflowInvocationRef();
+    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,
+            store: options.store,
+        });
+        if (activeScratchpadRefresh !== undefined) {
+            return {
+                disposition: {
+                    kind: "already_running",
+                    activity_ref: activeScratchpadRefresh,
+                },
+            };
+        }
+        const started = startScratchpadRefreshBeforeTaskCompileActivity({
+            ...options,
+            runner: runnerResolution.runner,
+            sourceBatch,
+            taskCompileWorkflowRef,
+            recordRecoveryIntent: false,
+            onAccepted: (activityRef) => recordTaskCompileSubmissionIntent({
+                store: options.store,
+                workflowRef: taskCompileWorkflowRef,
+                acceptedActivityRef: activityRef,
+                sourceBatch,
+                now: options.now,
+            }),
+        });
+        return withSubmissionRef(started, taskCompileWorkflowRef);
+    }
+    if (!scratchpadHasSubmittableContent(scratchpad)) {
+        return { disposition: { kind: "scratchpad_empty" } };
+    }
+    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 withSubmissionRef(started, taskCompileWorkflowRef);
+}
+function withSubmissionRef(result, submissionRef) {
+    return result.disposition.kind === "accepted"
+        ? { ...result, result: { ...result.result, submission_ref: submissionRef } }
+        : result;
+}
+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)) {
+        return { disposition: { kind: "scratchpad_empty" } };
+    }
+    const workflowRef = options.taskCompileWorkflowRef;
+    const start = options.engine.startProcedure({
+        workflow_ref: workflowRef,
+        workflow_kind: "task_compile",
+        lane: "foreground",
+        title: "Compile Worklist",
+        summary: "Compiling Scratchpad into Worklist tasks.",
+        now: options.now,
+        onTransition: (state) => {
+            linkTaskCompileActivity(options.store.db, options.taskCompileWorkflowRef, state.activity.activity_ref);
+            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",
+            workflowRef,
+            activityRef: context.activity_ref,
+            error,
+        }),
+        execute: async (context) => runControlPlaneTaskCompileProcedure({
+            logger: options.logger,
+            runner: options.runner,
+            store: options.store,
+            events: options.events,
+            projectContext: options.projectContext,
+            workflowRef,
+            activityRef: context.activity_ref,
+            reportProgress: context.reportProgress,
+            now: options.now,
+            onTasksAdded: options.onTasksAdded,
+        }),
+    });
+    if (start.kind === "already_running") {
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: start.activity_ref,
+            },
+        };
+    }
+    return {
+        disposition: { kind: "accepted" },
+        result: {
+            activity_ref: start.activity.activity_ref,
+            workflow_ref: workflowRef,
+        },
+    };
+}
+function startScratchpadRefreshBeforeTaskCompileActivity(options) {
+    const workflowRef = createWorkflowInvocationRef();
+    let recoveryIntentId = options.recoveryIntentId;
+    const start = options.engine.startProcedure({
+        workflow_ref: workflowRef,
+        workflow_kind: "scratchpad_refresh",
+        lane: "foreground",
+        title: "Refresh Scratchpad",
+        summary: "Refreshing Scratchpad before submitting to Worklist.",
+        now: options.now,
+        onTransition: (state) => {
+            linkTaskCompileActivity(options.store.db, options.taskCompileWorkflowRef, state.activity.activity_ref);
+            options.publishProcedureTransition(state);
+            if (state.transition_kind !== "terminal") {
+                return;
+            }
+            if (state.activity.status !== "finished") {
+                rollbackTaskCompileContext(options.store.db, {
+                    workflow_ref: options.taskCompileWorkflowRef,
+                    now: options.now,
+                });
+                options.onChainTerminal?.({
+                    state: "failed",
+                    errorCode: "scratchpad_refresh_failed",
+                });
+                return;
+            }
+            if (options.shouldContinue?.() === false) {
+                return;
+            }
+            const scratchpad = readScratchpadProjection(options.store.db);
+            if (!scratchpadHasSubmittableContent(scratchpad)) {
+                withHostStoreTransaction(options.store.db, (tx) => {
+                    closeFailedTaskCompileRequest(tx, options.taskCompileWorkflowRef, options.now().toISOString(), "scratchpad_empty_after_refresh");
+                    tx.prepare("DELETE FROM pending_task_compile_submissions WHERE workflow_ref = ?").run(options.taskCompileWorkflowRef);
+                });
+                options.onChainTerminal?.({
+                    state: "failed",
+                    errorCode: "scratchpad_empty_after_refresh",
+                });
+                return;
+            }
+            const next = startReferenceSummaryGateOrNextStage(options);
+            if (next.disposition.kind !== "accepted" && next.disposition.kind !== "already_running") {
+                rollbackTaskCompileContext(options.store.db, {
+                    workflow_ref: options.taskCompileWorkflowRef,
+                    now: options.now,
+                });
+                options.onChainTerminal?.({
+                    state: "failed",
+                    errorCode: "task_compile_stage_unavailable",
+                });
+            }
+        },
+        onError: ({ context, error }) => logProcedureExecutionError({
+            logger: options.logger,
+            workflowKind: "scratchpad_refresh",
+            workflowRef,
+            activityRef: context.activity_ref,
+            error,
+        }),
+        execute: async (context) => runControlPlaneScratchpadRefreshProcedure({
+            logger: options.logger,
+            runner: options.runner,
+            store: options.store,
+            events: options.events,
+            workflowRef,
+            activityRef: context.activity_ref,
+            sourceBatch: options.sourceBatch,
+            lane: "foreground",
+            ...(options.recordRecoveryIntent === undefined
+                ? {}
+                : { recordRecoveryIntent: options.recordRecoveryIntent }),
+            ...(recoveryIntentId === undefined ? {} : { recoveryIntentId }),
+            now: options.now,
+        }),
+    });
+    if (start.kind === "already_running") {
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: start.activity_ref,
+            },
+        };
+    }
+    recoveryIntentId =
+        options.onAccepted?.(start.activity.activity_ref) ?? recoveryIntentId;
+    return {
+        disposition: { kind: "accepted" },
+        result: {
+            activity_ref: start.activity.activity_ref,
+            workflow_ref: workflowRef,
+        },
+    };
+}
+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);
+    const referenceSources = readRecentReferenceSources(options.store.db, sourceRefs);
+    const pendingPaths = options.projectContext === undefined
+        ? []
+        : readPendingRecentReferenceSummaryPaths({
+            workspaceRoot: options.projectContext.workspaceRoot,
+            sources: referenceSources,
+            now: options.now,
+        });
+    if (pendingPaths.length === 0) {
+        return startNextTaskCompileStage(options);
+    }
+    const activeReferenceSummary = options.engine
+        .getActiveProcedures()
+        .find((activity) => activity.lane === "foreground" && activity.workflow_kind === "reference_summary_refresh");
+    if (activeReferenceSummary !== undefined) {
+        readOrCaptureTaskCompileContext({
+            store: options.store,
+            workflowRef: options.taskCompileWorkflowRef,
+            activityRef: activeReferenceSummary.activity_ref,
+            now: options.now,
+        });
+        registerReferenceSummaryGateWaiter(options, activeReferenceSummary.activity_ref);
+        return {
+            result: {
+                submission_ref: options.taskCompileWorkflowRef,
+                activity_ref: activeReferenceSummary.activity_ref,
+            },
+            disposition: {
+                kind: "already_running",
+                activity_ref: activeReferenceSummary.activity_ref,
+            },
+        };
+    }
+    const started = startReferenceSummaryRefreshProcedure({
+        engine: options.engine,
+        store: options.store,
+        events: options.events,
+        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 };
+        },
+        projectContext: options.projectContext,
+        logger: options.logger,
+        now: options.now,
+        onExecuteStart: ({ activityRef }) => {
+            readOrCaptureTaskCompileContext({
+                store: options.store,
+                workflowRef: options.taskCompileWorkflowRef,
+                activityRef,
+                now: options.now,
+            });
+        },
+        publishProcedureTransition: options.publishProcedureTransition,
+    });
+    if (started.disposition.kind === "accepted") {
+        const activityRef = started.result?.activity_ref;
+        const workflowRef = started.result?.workflow_ref;
+        if (activityRef === undefined || workflowRef === undefined) {
+            throw new Error("Accepted reference summary gate is missing activity identity");
+        }
+        registerReferenceSummaryGateWaiter(options, activityRef);
+        return {
+            disposition: { kind: "accepted" },
+            result: {
+                activity_ref: activityRef,
+                workflow_ref: workflowRef,
+            },
+        };
+    }
+    if (started.disposition.kind === "already_running") {
+        return { disposition: started.disposition };
+    }
+    if (started.disposition.kind === "no_targets") {
+        return startNextTaskCompileStage(options);
+    }
+    return { disposition: started.disposition };
+}
+function registerReferenceSummaryGateWaiter(options, activityRef) {
+    options.registerReferenceSummaryWaiter(activityRef, (state) => {
+        if (state.activity.status !== "finished" || options.shouldContinue?.() === false) {
+            rollbackTaskCompileContext(options.store.db, {
+                workflow_ref: options.taskCompileWorkflowRef,
+                now: options.now,
+            });
+            options.onChainTerminal?.({ state: "failed", errorCode: "reference_summary_failed" });
+            return;
+        }
+        void startReferenceSummaryGateOrNextStage(options);
+    });
+}
+function startNextTaskCompileStage(options) {
+    if (shouldInitializeControlPlaneProjectContext(options)) {
+        return startProjectContextBootstrapActivity(options);
+    }
+    return startControlPlaneTaskCompileActivity(options);
+}
+function shouldInitializeControlPlaneProjectContext(options) {
+    if (options.projectContext === undefined) {
+        return false;
+    }
+    const status = readProjectDocsInitializationStatus({
+        workspaceRoot: options.projectContext.workspaceRoot,
+        now: options.now,
+    });
+    return !status.ready;
+}
+function startProjectContextBootstrapActivity(options) {
+    if (options.projectContext === undefined) {
+        return startControlPlaneTaskCompileActivity(options);
+    }
+    const workflowRef = createWorkflowInvocationRef();
+    const start = options.engine.startProcedure({
+        workflow_ref: workflowRef,
+        workflow_kind: "project_context_bootstrap",
+        lane: "foreground",
+        title: "Prepare Project Context",
+        summary: "Preparing project docs before compiling the Worklist.",
+        now: options.now,
+        onTransition: (state) => {
+            options.publishProcedureTransition(state);
+            if (state.transition_kind !== "terminal") {
+                return;
+            }
+            if (state.activity.status !== "finished") {
+                rollbackTaskCompileContext(options.store.db, {
+                    workflow_ref: options.taskCompileWorkflowRef,
+                    now: options.now,
+                });
+                options.onChainTerminal?.({ state: "failed", errorCode: "project_context_failed" });
+                return;
+            }
+            if (options.shouldContinue?.() === false) {
+                rollbackTaskCompileContext(options.store.db, {
+                    workflow_ref: options.taskCompileWorkflowRef,
+                    now: options.now,
+                });
+                return;
+            }
+            if (shouldInitializeControlPlaneProjectContext(options)) {
+                return;
+            }
+            if (readActiveTaskCompileContext(options.store.db, options.taskCompileWorkflowRef) === null) {
+                return;
+            }
+            void startControlPlaneTaskCompileActivity(options);
+        },
+        onError: ({ context, error }) => logProcedureExecutionError({
+            logger: options.logger,
+            workflowKind: "project_context_bootstrap",
+            workflowRef,
+            activityRef: context.activity_ref,
+            error,
+        }),
+        execute: async (context) => {
+            if (options.projectContext === undefined) {
+                return {
+                    kind: "failed",
+                    summary: "Project context is unavailable.",
+                };
+            }
+            const taskCompileContext = readOrCaptureTaskCompileContext({
+                store: options.store,
+                workflowRef: options.taskCompileWorkflowRef,
+                activityRef: context.activity_ref,
+                now: options.now,
+            });
+            try {
+                const initializationContext = buildProjectDocsInitializationContext(taskCompileContext.scratchpad_snapshot);
+                const modelDocuments = await tryProjectContextBootstrapDocuments({
+                    communicationLanguage: {
+                        ...workflowLanguageContext(options.store.db, {
+                            workflowRef: options.taskCompileWorkflowRef,
+                            sources: [],
+                        }),
+                        scope: "documents",
+                    },
+                    runner: options.runner,
+                    projectContext: options.projectContext,
+                    scratchpad: taskCompileContext.scratchpad_snapshot,
+                    projectName: options.projectContext.projectName,
+                    workflowRef,
+                    activityRef: context.activity_ref,
+                    logger: options.logger,
+                    reportProgress: context.reportProgress,
+                    now: options.now,
+                });
+                const initialized = initializeProjectDocs({
+                    workspaceRoot: options.projectContext.workspaceRoot,
+                    projectName: options.projectContext.projectName,
+                    context: initializationContext,
+                    ...(modelDocuments === undefined ? {} : { documents: modelDocuments }),
+                    now: options.now,
+                });
+                if (projectBriefShouldRefreshForUpdatedPaths(initialized.created_paths)) {
+                    await refreshProjectBriefProjection({
+                        store: options.store,
+                        projectContext: options.projectContext,
+                        reason: "project_context_bootstrap",
+                        runner: options.runner,
+                        workflowRef,
+                        activityRef: context.activity_ref,
+                        logger: options.logger,
+                        now: options.now,
+                    });
+                }
+                return applyProjectDocsInitializationResult({
+                    events: options.events,
+                    logger: options.logger,
+                    result: initialized,
+                    workflowRef,
+                    activityRef: context.activity_ref,
+                });
+            }
+            catch (error) {
+                rollbackTaskCompileContext(options.store.db, {
+                    workflow_ref: options.taskCompileWorkflowRef,
+                    now: options.now,
+                });
+                throw error;
+            }
+        },
+    });
+    if (start.kind === "already_running") {
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: start.activity_ref,
+            },
+        };
+    }
+    return {
+        disposition: { kind: "accepted" },
+        result: {
+            activity_ref: start.activity.activity_ref,
+            workflow_ref: workflowRef,
+        },
+    };
+}
+export async function runControlPlaneTaskCompileProcedure(options) {
+    const context = readOrCaptureTaskCompileContext({
+        store: options.store,
+        workflowRef: options.workflowRef,
+        activityRef: options.activityRef,
+        now: options.now,
+    });
+    if (!scratchpadSnapshotHasSubmittableContent(context.scratchpad_snapshot)) {
+        rollbackTaskCompileContext(options.store.db, {
+            workflow_ref: options.workflowRef,
+            now: options.now,
+        });
+        return {
+            kind: "failed",
+            summary: "Scratchpad is empty. Discuss more before running.",
+        };
+    }
+    try {
+        const recentReferences = options.projectContext === undefined
+            ? []
+            : materializeRecentReferences({
+                workspaceRoot: options.projectContext.workspaceRoot,
+                sources: readRecentReferenceSources(options.store.db, context.sources),
+                now: options.now,
+            });
+        const sourceMessages = materializePromptSourceMessages(options.store.db, context.sources);
+        const language = workflowLanguageContext(options.store.db, {
+            workflowRef: options.workflowRef,
+            sources: sourceLanguageEvidence(options.store.db, context.sources),
+        });
+        logLanguageContext(options.logger, language, {
+            workflow_ref: options.workflowRef,
+            activity_ref: options.activityRef,
+        });
+        const output = await options.runner.runTaskCompile({
+            communication_language: language,
+            workflow_ref: options.workflowRef,
+            scratchpad: context.scratchpad_snapshot,
+            source_messages: sourceMessages,
+            worklist: readWorklistProjection(options.store.db),
+            ...(recentReferences.length === 0 ? {} : { recent_references: recentReferences }),
+        }, {
+            workflow_ref: options.workflowRef,
+            activity_ref: options.activityRef,
+            ...(options.reportProgress === undefined ? {} : { reportProgress: options.reportProgress }),
+        });
+        logLanguageContext(options.logger, language, { workflow_ref: options.workflowRef, activity_ref: options.activityRef }, output.communication_language);
+        return applyTaskCompileProcedureOutput({
+            store: options.store,
+            events: options.events,
+            output,
+            workflowRef: options.workflowRef,
+            activityRef: options.activityRef,
+            now: options.now,
+            onTasksAdded: options.onTasksAdded,
+        });
+    }
+    catch (error) {
+        rollbackTaskCompileContext(options.store.db, {
+            workflow_ref: options.workflowRef,
+            now: options.now,
+        });
+        throw error;
+    }
+}
+function readOrCaptureTaskCompileContext(input) {
+    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,
+            });
+        linkTaskCompileActivity(tx, input.workflowRef, input.activityRef);
+        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") {
+        return false;
+    }
+    return [
+        scratchpad.topic,
+        scratchpad.background_summary,
+        ...scratchpad.current_consensus,
+        ...scratchpad.open_questions,
+        ...scratchpad.task_changes,
+    ].some((item) => item.trim().length > 0);
+}
+function scratchpadSnapshotHasSubmittableContent(scratchpad) {
+    return [
+        scratchpad.topic,
+        scratchpad.background_summary,
+        ...scratchpad.current_consensus,
+        ...scratchpad.open_questions,
+        ...scratchpad.task_changes,
+    ].some((item) => item.trim().length > 0);
+}
+//# sourceMappingURL=task-compile-start.js.map