@xfey/tutti 0.1.60 → 0.1.61

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

@@ -1,4 +1,5 @@
-import { applyTaskCompileProposal, openNextTaskCompileClarificationRound, openTaskCompileClarificationRound, readWorklistProjection, submitScratchpadProjection, } from "../collaboration-state/index.js";
+import { applyTaskCompileProposal, completeTaskCompileContext, materializeClarificationSuccessor, openNextTaskCompileClarificationRound, openTaskCompileClarificationRound, readClarificationRoundProjection, readWorklistProjection, } from "../collaboration-state/index.js";
+import { withHostStoreTransaction } from "../store/index.js";
 import { clarificationInvalidates, taskCompileInvalidates, } from "./invalidations.js";
 import { normalizeTaskCompileProposal } from "./task-proposal.js";
 const EMPTY_INITIAL_WORKLIST_CLARIFICATION = {
@@ -72,25 +73,45 @@ export function applyTaskCompileProcedureOutput(input) {
     }
     const currentWorklist = readWorklistProjection(input.store.db);
     const proposal = normalizeTaskCompileProposal(input.output.proposal);
-    if (proposal.tasks.length === 0 && countWorklistTasks(currentWorklist) === 0) {
+    if (input.continueFromRoundId === undefined &&
+        proposal.tasks.length === 0 &&
+        countWorklistTasks(currentWorklist) === 0) {
         return openTaskCompileNeedsHuman({
             ...input,
             requestPayload: EMPTY_INITIAL_WORKLIST_CLARIFICATION,
         });
     }
-    const applied = applyTaskCompileProposal(input.store.db, {
-        workflow_ref: input.workflowRef,
-        proposal,
-        now: input.now,
+    const continuationRound = input.continueFromRoundId === undefined
+        ? null
+        : readClarificationRoundProjection(input.store.db, input.continueFromRoundId);
+    const committed = withHostStoreTransaction(input.store.db, (tx) => {
+        const applied = applyTaskCompileProposal(tx, {
+            workflow_ref: input.workflowRef,
+            proposal,
+            now: input.now,
+        });
+        const scratchpad = completeTaskCompileContext(tx, {
+            workflow_ref: input.workflowRef,
+            activity_ref: input.activityRef,
+            now: input.now,
+        });
+        if (input.continueFromRoundId !== undefined) {
+            materializeClarificationSuccessor(tx, {
+                round_id: input.continueFromRoundId,
+                successor_ref: {
+                    kind: "proposal_applied",
+                    workflow_ref: input.workflowRef,
+                },
+                close_thread: true,
+                now: input.now,
+            });
+        }
+        return { applied, scratchpad };
     });
+    const { applied } = committed;
     if (applied.changed_task_ids.length > 0) {
         input.onTasksAdded?.();
     }
-    const submittedScratchpad = submitScratchpadProjection(input.store.db, {
-        workflow_ref: input.workflowRef,
-        activity_ref: input.activityRef,
-        now: input.now,
-    });
     input.events.publish({
         event_type: "worklist.changed",
         payload: {
@@ -105,21 +126,36 @@ export function applyTaskCompileProcedureOutput(input) {
     input.events.publish({
         event_type: "scratchpad.updated",
         payload: {
-            scratchpad: submittedScratchpad,
+            scratchpad: committed.scratchpad,
             activity_ref: input.activityRef,
         },
         invalidates: taskCompileInvalidates(),
     });
+    if (input.continueFromRoundId !== undefined && continuationRound !== null) {
+        input.events.publish({
+            event_type: "clarification.changed",
+            payload: {
+                reason: "successor_materialized",
+                thread_id: continuationRound.thread_id,
+                round_id: input.continueFromRoundId,
+                successor_ref: {
+                    kind: "proposal_applied",
+                    workflow_ref: input.workflowRef,
+                },
+            },
+            invalidates: clarificationInvalidates(input.continueFromRoundId, continuationRound.thread_id),
+        });
+    }
     if (input.continueFromRoundId !== undefined) {
         return {
             kind: "completed",
-            summary: "Worklist compiled.",
+            summary: proposal.tasks.length === 0 ? "No new task created." : "Worklist compiled.",
             result_anchor: { kind: "workflow", workflow_ref: input.workflowRef },
         };
     }
     return {
         kind: "completed",
-        summary: "Worklist compiled.",
+        summary: proposal.tasks.length === 0 ? "No new task created." : "Worklist compiled.",
         result_anchor: { kind: "workflow", workflow_ref: input.workflowRef },
     };
 }

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

@@ -1,5 +1,5 @@
 import { createWorkflowInvocationRef, } from "@tutti/shared/ids";
-import { readScratchpadProjection, readWorklistProjection } from "../collaboration-state/index.js";
+import { captureTaskCompileContext, readActiveTaskCompileContext, readScratchpadProjection, readWorklistProjection, rollbackTaskCompileContext, } from "../collaboration-state/index.js";
 import { initializeProjectDocs, readProjectDocsInitializationStatus, } from "../workspace-ops/index.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
 import { projectBriefShouldRefreshForUpdatedPaths, refreshProjectBriefProjection, } from "./project-brief-refresh.js";
@@ -7,6 +7,15 @@ import { applyProjectDocsInitializationResult, buildProjectDocsInitializationCon
 import { readActiveScratchpadRefreshActivityRef, readControlPlaneScratchpadSourceBatch, runControlPlaneScratchpadRefreshProcedure, } from "./scratchpad-refresh-start.js";
 import { applyTaskCompileProcedureOutput } from "./task-compile-output.js";
 export function startControlPlaneTaskCompile(options) {
+    const activeContext = readActiveTaskCompileContext(options.store.db);
+    if (activeContext !== null) {
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: activeContext.captured_by_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) {
@@ -31,6 +40,7 @@ export function startControlPlaneTaskCompile(options) {
             },
         };
     }
+    const taskCompileWorkflowRef = createWorkflowInvocationRef();
     const sourceBatch = readControlPlaneScratchpadSourceBatch(options.store);
     if (sourceBatch.source_message_count > 0) {
         const activeScratchpadRefresh = readActiveScratchpadRefreshActivityRef({
@@ -49,6 +59,7 @@ export function startControlPlaneTaskCompile(options) {
             ...options,
             runner: runnerResolution.runner,
             sourceBatch,
+            taskCompileWorkflowRef,
         });
     }
     if (!scratchpadHasSubmittableContent(scratchpad)) {
@@ -58,19 +69,23 @@ export function startControlPlaneTaskCompile(options) {
         return startProjectContextBootstrapActivity({
             ...options,
             runner: runnerResolution.runner,
+            taskCompileWorkflowRef,
         });
     }
     return startControlPlaneTaskCompileActivity({
         ...options,
         runner: runnerResolution.runner,
+        taskCompileWorkflowRef,
     });
 }
 function startControlPlaneTaskCompileActivity(options) {
+    const activeContext = readActiveTaskCompileContext(options.store.db, options.taskCompileWorkflowRef);
     const scratchpad = readScratchpadProjection(options.store.db);
-    if (!scratchpadHasSubmittableContent(scratchpad)) {
+    if (activeContext === null &&
+        !scratchpadHasSubmittableContent(scratchpad)) {
         return { disposition: { kind: "scratchpad_empty" } };
     }
-    const workflowRef = createWorkflowInvocationRef();
+    const workflowRef = options.taskCompileWorkflowRef;
     const start = options.engine.startProcedure({
         workflow_ref: workflowRef,
         workflow_kind: "task_compile",
@@ -201,8 +216,7 @@ function startProjectContextBootstrapActivity(options) {
             if (shouldInitializeControlPlaneProjectContext(options)) {
                 return;
             }
-            const scratchpad = readScratchpadProjection(options.store.db);
-            if (!scratchpadHasSubmittableContent(scratchpad)) {
+            if (readActiveTaskCompileContext(options.store.db, options.taskCompileWorkflowRef) === null) {
                 return;
             }
             void startControlPlaneTaskCompileActivity(options);
@@ -221,44 +235,59 @@ function startProjectContextBootstrapActivity(options) {
                     summary: "Project context is unavailable.",
                 };
             }
-            const initializationContext = buildProjectDocsInitializationContext(readScratchpadProjection(options.store.db));
-            const modelDocuments = await tryProjectContextBootstrapDocuments({
-                runner: options.runner,
-                projectContext: options.projectContext,
-                scratchpad: readScratchpadProjection(options.store.db),
-                projectName: options.projectContext.projectName,
-                workflowRef,
+            const taskCompileContext = readOrCaptureTaskCompileContext({
+                store: options.store,
+                workflowRef: options.taskCompileWorkflowRef,
                 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",
+            try {
+                const initializationContext = buildProjectDocsInitializationContext(taskCompileContext.scratchpad_snapshot);
+                const modelDocuments = await tryProjectContextBootstrapDocuments({
                     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;
             }
-            return applyProjectDocsInitializationResult({
-                events: options.events,
-                logger: options.logger,
-                result: initialized,
-                workflowRef,
-                activityRef: context.activity_ref,
-            });
         },
     });
     if (start.kind === "already_running") {
@@ -278,33 +307,59 @@ function startProjectContextBootstrapActivity(options) {
     };
 }
 export async function runControlPlaneTaskCompileProcedure(options) {
-    const scratchpad = readScratchpadProjection(options.store.db);
-    if (!scratchpadHasSubmittableContent(scratchpad)) {
-        return {
-            kind: "failed",
-            summary: "Scratchpad is empty. Discuss more before running.",
-        };
-    }
-    const output = await options.runner.runTaskCompile({
-        workflow_ref: options.workflowRef,
-        scratchpad,
-        worklist: readWorklistProjection(options.store.db),
-    }, {
-        workflow_ref: options.workflowRef,
-        activity_ref: options.activityRef,
-        ...(options.reportProgress === undefined
-            ? {}
-            : { reportProgress: options.reportProgress }),
-    });
-    return applyTaskCompileProcedureOutput({
+    const context = readOrCaptureTaskCompileContext({
         store: options.store,
-        events: options.events,
-        output,
         workflowRef: options.workflowRef,
         activityRef: options.activityRef,
         now: options.now,
-        onTasksAdded: options.onTasksAdded,
     });
+    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 output = await options.runner.runTaskCompile({
+            workflow_ref: options.workflowRef,
+            scratchpad: context.scratchpad_snapshot,
+            worklist: readWorklistProjection(options.store.db),
+        }, {
+            workflow_ref: options.workflowRef,
+            activity_ref: options.activityRef,
+            ...(options.reportProgress === undefined
+                ? {}
+                : { reportProgress: options.reportProgress }),
+        });
+        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 (readActiveTaskCompileContext(input.store.db, input.workflowRef) ??
+        captureTaskCompileContext(input.store.db, {
+            workflow_ref: input.workflowRef,
+            captured_by_activity_ref: input.activityRef,
+            now: input.now,
+        }));
 }
 function scratchpadHasSubmittableContent(scratchpad) {
     if (scratchpad.state !== "ready") {
@@ -318,4 +373,13 @@ function scratchpadHasSubmittableContent(scratchpad) {
         ...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

package/dist/control-plane/workflows/openai.d.ts

@@ -2,7 +2,7 @@ import type { ProjectId } from "@tutti/shared/ids";
 import type { ProviderUsageRecorder } from "../../provider-usage/index.js";
 import { type OpenAiStructuredOutputClient } from "../../providers/openai/sdk-procedure-runner.js";
 import { type OpenAiProviderConfig } from "../../providers/openai/provider-config.js";
-import type { ProcedureWorkflowRunner, ProcedureWorkflowRunnerResolution } from "./types.js";
+import type { ProcedureWorkflowRunner, ProcedureWorkflowRunnerResolution, TaskCompilePromptInput, TaskCompileWorkflowInput } from "./types.js";
 import type { CodexAppServerAgentContextRuntime } from "../../providers/openai/app-server/skills.js";
 export type OpenAiProcedureWorkflowRunnerOptions = {
     config: OpenAiProviderConfig;
@@ -30,6 +30,7 @@ export type ProjectOpenAiProcedureWorkflowRunnerOptions = {
     agentContext?: CodexAppServerAgentContextRuntime;
     recordUsage?: ProviderUsageRecorder;
 };
+export declare function buildTaskCompilePromptInput(input: TaskCompileWorkflowInput): TaskCompilePromptInput;
 export declare function createOpenAiProcedureWorkflowRunner(options: OpenAiProcedureWorkflowRunnerOptions): ProcedureWorkflowRunner;
 export declare function resolveProjectOpenAiProcedureWorkflowRunner(options: ProjectOpenAiProcedureWorkflowRunnerOptions): ProcedureWorkflowRunnerResolution;
 //# sourceMappingURL=openai.d.ts.map

package/dist/control-plane/workflows/openai.js

@@ -137,7 +137,7 @@ function followUpCheckWorkflowOutput(output) {
         summary: output.result.requires_retasking.summary,
     };
 }
-function taskCompilePromptInput(input) {
+export function buildTaskCompilePromptInput(input) {
     const promptInput = {
         scratchpad: {
             topic: input.scratchpad.topic,
@@ -160,34 +160,20 @@ function taskCompilePromptInput(input) {
             })),
         },
     };
-    if (input.clarification !== undefined) {
-        const request = {
-            ...(input.clarification.request_payload.title === undefined
-                ? {}
-                : { title: input.clarification.request_payload.title }),
-            summary: input.clarification.request_payload.summary,
-            request: input.clarification.request_payload.request,
-        };
-        promptInput.clarification = {
-            request,
-            answer_messages: input.clarification.messages
-                .filter((message) => message.message_kind === "user_text" || message.message_kind === "agent_text")
-                .map(taskCompileClarificationMessage),
-        };
+    if (input.clarification_rounds !== undefined) {
+        promptInput.clarification_rounds = input.clarification_rounds.map((round) => ({
+            request: {
+                ...(round.request_payload.title === undefined
+                    ? {}
+                    : { title: round.request_payload.title }),
+                summary: round.request_payload.summary,
+                request: round.request_payload.request,
+            },
+            answer_messages: round.answer_messages,
+        }));
     }
     return promptInput;
 }
-function taskCompileClarificationMessage(message) {
-    const role = message.author.kind === "agent" ? "tutti" : "human";
-    const authorDisplayName = message.author.display_name?.trim();
-    return {
-        role,
-        ...(role === "human" && authorDisplayName !== undefined && authorDisplayName !== ""
-            ? { author_display_name: authorDisplayName }
-            : {}),
-        text: message.body.trim(),
-    };
-}
 function taskCompileWorkflowOutput(output) {
     if ("clarification_request_payload" in output.result) {
         return {
@@ -280,7 +266,7 @@ export function createOpenAiProcedureWorkflowRunner(options) {
                 templateKey: "procedures.task_compile",
                 ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
                 variables: {
-                    workflow_input_json: taskCompilePromptInput(input),
+                    workflow_input_json: buildTaskCompilePromptInput(input),
                 },
             });
             const result = await runCodexAppServerReadOnlyProcedure({

package/dist/control-plane/workflows/types.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionRuntimeSnapshot, MessageProjection, RunResultProjection, ScratchpadProjection, TaskDetailProjection, WorklistProjection } from "@tutti/shared/schemas/api";
+import type { ExecutionRuntimeSnapshot, MessageProjection, RunResultProjection, TaskDetailProjection, WorklistProjection } from "@tutti/shared/schemas/api";
 import type { ClarificationRequestPayload, TaskContractProjection } from "@tutti/shared/schemas/api";
 import type { ProjectDocKey } from "@tutti/shared/schemas/api";
 import type { ActivityRef, ClarificationRoundRef, ClarificationThreadRef, MessageId, TaskId, TaskModuleId, WorkflowInvocationRef } from "@tutti/shared/ids";
@@ -6,21 +6,31 @@ import type { RunLineage } from "@tutti/shared/domain";
 import type { ProjectBriefSnapshot, ProjectBriefSourceDocument } from "../../project-brief/index.js";
 export type ScratchpadRefreshWorkflowInput = {
     project_brief?: ProjectBriefSnapshot;
-    previous: {
-        topic?: string;
-        background?: string;
-        consensus?: string[];
-        questions?: string[];
-        changes?: string[];
-    };
-    recent_messages: ScratchpadRefreshSourceMessageInput[];
-    new_messages: ScratchpadRefreshSourceMessageInput[];
+    worklist: ScratchpadRefreshWorklistInput;
+    active_task_compile?: ScratchpadWorkflowSnapshot;
+    messages: ScratchpadRefreshSourceMessageInput[];
+};
+export type ScratchpadWorkflowSnapshot = {
+    topic: string;
+    background_summary: string;
+    current_consensus: string[];
+    open_questions: string[];
+    task_changes: string[];
+};
+export type ScratchpadRefreshWorklistInput = {
+    modules: Array<{
+        name: string;
+        tasks: Array<{
+            title: string;
+            summary?: string;
+            status: WorklistProjection["modules"][number]["tasks"][number]["status"];
+        }>;
+    }>;
 };
 export type ScratchpadRefreshSourceMessageInput = {
     role: "human" | "tutti";
     author_display_name?: string;
     text: string;
-    ref?: string;
 };
 export type ScratchpadRefreshWorkflowContext = {
     workflow_ref: WorkflowInvocationRef;
@@ -68,12 +78,12 @@ export type TaskCompileProposalTask = {
 };
 export type TaskCompileWorkflowInput = {
     workflow_ref: WorkflowInvocationRef;
-    scratchpad: ScratchpadProjection;
+    scratchpad: ScratchpadWorkflowSnapshot;
     worklist: WorklistProjection;
-    clarification?: {
+    clarification_rounds?: Array<{
         request_payload: ClarificationRequestPayload;
-        messages: MessageProjection[];
-    };
+        answer_messages: TaskCompilePromptClarificationMessage[];
+    }>;
 };
 export type TaskCompileWorkflowOutput = {
     decision: "ready";
@@ -103,14 +113,14 @@ export type TaskCompilePromptInput = {
             }>;
         }>;
     };
-    clarification?: {
+    clarification_rounds?: Array<{
         request: {
             title?: string;
             summary: string;
             request: string;
         };
         answer_messages: TaskCompilePromptClarificationMessage[];
-    };
+    }>;
 };
 export type TaskCompilePromptClarificationMessage = {
     role: "human" | "tutti";

package/migrations/0014_scratchpad_task_compile_context.sql

@@ -0,0 +1,147 @@
+DROP TABLE IF EXISTS scratchpad_receipt_sources;
+DROP TABLE IF EXISTS scratchpad_source_refs;
+DROP TABLE IF EXISTS scratchpad_source_state;
+
+CREATE TABLE scratchpad_source_state (
+  id TEXT PRIMARY KEY CHECK (id = 'current'),
+  cycle_start_cursor_created_at TEXT,
+  cycle_start_cursor_message_id TEXT,
+  refreshed_through_cursor_created_at TEXT,
+  refreshed_through_cursor_message_id TEXT,
+  dirty_since TEXT,
+  in_flight_activity_ref TEXT,
+  in_flight_started_at TEXT,
+  last_completed_at TEXT,
+  last_failed_at TEXT,
+  backoff_until TEXT,
+  updated_at TEXT NOT NULL,
+  CHECK (
+    (cycle_start_cursor_created_at IS NULL AND cycle_start_cursor_message_id IS NULL)
+    OR (
+      cycle_start_cursor_created_at IS NOT NULL
+      AND cycle_start_cursor_message_id IS NOT NULL
+    )
+  ),
+  CHECK (
+    (
+      refreshed_through_cursor_created_at IS NULL
+      AND refreshed_through_cursor_message_id IS NULL
+    )
+    OR (
+      refreshed_through_cursor_created_at IS NOT NULL
+      AND refreshed_through_cursor_message_id IS NOT NULL
+    )
+  ),
+  CHECK (
+    (in_flight_activity_ref IS NULL AND in_flight_started_at IS NULL)
+    OR (in_flight_activity_ref IS NOT NULL AND in_flight_started_at IS NOT NULL)
+  )
+);
+
+CREATE TABLE scratchpad_source_refs (
+  scratchpad_id TEXT NOT NULL DEFAULT 'current' CHECK (scratchpad_id = 'current'),
+  message_id TEXT NOT NULL,
+  source_scope TEXT NOT NULL DEFAULT 'main_chat' CHECK (source_scope = 'main_chat'),
+  created_at TEXT NOT NULL,
+  PRIMARY KEY (scratchpad_id, message_id),
+  FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_scratchpad_source_refs_created_at
+  ON scratchpad_source_refs (scratchpad_id, created_at ASC, message_id ASC);
+
+CREATE TABLE scratchpad_receipt_sources (
+  workflow_ref TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  source_scope TEXT NOT NULL DEFAULT 'main_chat' CHECK (source_scope = 'main_chat'),
+  created_at TEXT NOT NULL,
+  PRIMARY KEY (workflow_ref, message_id),
+  FOREIGN KEY (workflow_ref) REFERENCES scratchpad_receipts(workflow_ref) ON DELETE CASCADE,
+  FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_scratchpad_receipt_sources_created_at
+  ON scratchpad_receipt_sources (workflow_ref, created_at ASC, message_id ASC);
+
+CREATE TABLE active_task_compile_context (
+  id TEXT PRIMARY KEY CHECK (id = 'current'),
+  workflow_ref TEXT NOT NULL UNIQUE,
+  captured_by_activity_ref TEXT NOT NULL,
+  submitted_at TEXT NOT NULL,
+  topic TEXT NOT NULL,
+  background_summary TEXT NOT NULL,
+  current_consensus_json TEXT NOT NULL CHECK (
+    json_valid(current_consensus_json) AND json_type(current_consensus_json) = 'array'
+  ),
+  open_questions_json TEXT NOT NULL CHECK (
+    json_valid(open_questions_json) AND json_type(open_questions_json) = 'array'
+  ),
+  task_changes_json TEXT NOT NULL CHECK (
+    json_valid(task_changes_json) AND json_type(task_changes_json) = 'array'
+  ),
+  scratchpad_updated_at TEXT NOT NULL,
+  source_window_after_created_at TEXT,
+  source_window_after_message_id TEXT,
+  source_window_through_created_at TEXT,
+  source_window_through_message_id TEXT,
+  CHECK (
+    (source_window_after_created_at IS NULL AND source_window_after_message_id IS NULL)
+    OR (
+      source_window_after_created_at IS NOT NULL
+      AND source_window_after_message_id IS NOT NULL
+    )
+  ),
+  CHECK (
+    (source_window_through_created_at IS NULL AND source_window_through_message_id IS NULL)
+    OR (
+      source_window_through_created_at IS NOT NULL
+      AND source_window_through_message_id IS NOT NULL
+    )
+  ),
+  CHECK (
+    source_window_after_created_at IS NULL
+    OR source_window_through_created_at IS NULL
+    OR source_window_through_created_at > source_window_after_created_at
+    OR (
+      source_window_through_created_at = source_window_after_created_at
+      AND source_window_through_message_id >= source_window_after_message_id
+    )
+  )
+);
+
+CREATE TRIGGER active_task_compile_context_immutable
+BEFORE UPDATE ON active_task_compile_context
+BEGIN
+  SELECT RAISE(ABORT, 'active Task Compile Context is immutable');
+END;
+
+CREATE TABLE active_task_compile_context_sources (
+  workflow_ref TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  PRIMARY KEY (workflow_ref, message_id),
+  FOREIGN KEY (workflow_ref) REFERENCES active_task_compile_context(workflow_ref)
+    ON DELETE CASCADE,
+  FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_active_task_compile_context_sources_order
+  ON active_task_compile_context_sources (workflow_ref, created_at ASC, message_id ASC);
+
+CREATE TRIGGER active_task_compile_context_sources_main_chat_only
+BEFORE INSERT ON active_task_compile_context_sources
+WHEN NOT EXISTS (
+  SELECT 1
+  FROM messages
+  WHERE messages.id = NEW.message_id
+    AND messages.scope_kind = 'main_chat'
+)
+BEGIN
+  SELECT RAISE(ABORT, 'Task Compile Context source must be a main-chat message');
+END;
+
+CREATE TRIGGER active_task_compile_context_sources_immutable
+BEFORE UPDATE ON active_task_compile_context_sources
+BEGIN
+  SELECT RAISE(ABORT, 'Task Compile Context sources are immutable');
+END;