@xfey/tutti 0.1.60 → 0.1.61

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

@@ -1,16 +1,11 @@
 import { createWorkflowInvocationRef, } from "@tutti/shared/ids";
-import { readClarificationRoundMessagesWindow, readMainChatMessageWindow, readMainChatMessagesAfter, readMainChatMessagesAfterCursor, readMainChatMessagesBeforeCursor, markScratchpadRefreshFailed, markScratchpadRefreshStarted, readScratchpadProjection, readScratchpadSourceState, readSubmittedTaskCompileClarificationRounds, readSubmittedTaskCompileClarificationRoundsAfterCursor, } from "../collaboration-state/index.js";
+import { readActiveTaskCompileContext, readMainChatMessagesForScratchpadCycle, readScratchpadSourceState, readWorklistProjection, markScratchpadRefreshFailed, markScratchpadRefreshStarted, } from "../collaboration-state/index.js";
 import { readProjectBriefProjection, readProjectBriefSourceDocuments, } from "../project-brief/index.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
 import { applyScratchpadRefreshOutput } from "./scratchpad-refresh.js";
-import { compactPreviousScratchpad, compactScratchpadSourceMessages, filterClarificationRoundScratchpadSourceMessages, filterScratchpadSourceMessages, sortScratchpadSourceMessages, } from "./scratchpad-source-messages.js";
-const DEFAULT_SCRATCHPAD_SOURCE_MESSAGE_LIMIT = 50;
-const INCREMENTAL_SCRATCHPAD_SOURCE_MESSAGE_LIMIT = 200;
-const RECENT_CONTEXT_RAW_MESSAGE_LIMIT = 12;
-const RECENT_MESSAGE_WINDOW_SIZE = 5;
-const DEFAULT_CLARIFICATION_SOURCE_ROUND_LIMIT = 20;
-const CLARIFICATION_SOURCE_MESSAGE_LIMIT = 50;
+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;
+const MAX_SCRATCHPAD_WORKFLOW_INPUT_CHARS = 30_000;
 function readScratchpadProjectBrief(input) {
     if (input.projectContext === undefined) {
         return undefined;
@@ -35,105 +30,93 @@ function readScratchpadProjectBrief(input) {
         return undefined;
     }
 }
-export function readControlPlaneScratchpadSourceBatch(store, options = {}) {
-    const sourceState = readScratchpadSourceState(store.db);
-    const scratchpad = readScratchpadProjection(store.db);
-    const sourceFallbackSince = scratchpad.state === "ready" ? scratchpad.updated_at : undefined;
-    const isInitialMainChatRefresh = sourceState.main_chat_cursor === undefined && sourceFallbackSince === undefined;
-    const messages = sourceState.main_chat_cursor === undefined
-        ? sourceFallbackSince === undefined
-            ? readMainChatMessageWindow(store.db, {
-                limit: DEFAULT_SCRATCHPAD_SOURCE_MESSAGE_LIMIT,
-            }).items
-            : readMainChatMessagesAfter(store.db, {
-                after_created_at: sourceFallbackSince,
-                limit: INCREMENTAL_SCRATCHPAD_SOURCE_MESSAGE_LIMIT,
-            })
-        : readMainChatMessagesAfterCursor(store.db, {
-            after_created_at: sourceState.main_chat_cursor.created_at,
-            after_id: sourceState.main_chat_cursor.message_id,
-            limit: INCREMENTAL_SCRATCHPAD_SOURCE_MESSAGE_LIMIT,
-        });
-    const mainChatSourceMessages = filterScratchpadSourceMessages(messages);
-    const newMainChatSourceMessages = isInitialMainChatRefresh ? [] : mainChatSourceMessages;
-    const recentMessageLimit = Math.max(0, RECENT_MESSAGE_WINDOW_SIZE - newMainChatSourceMessages.length);
-    const firstNewMainChatSource = newMainChatSourceMessages[0];
-    const recentMessages = recentMessageLimit === 0
-        ? []
-        : isInitialMainChatRefresh
-            ? mainChatSourceMessages.slice(-recentMessageLimit)
-            : firstNewMainChatSource === undefined
-                ? filterScratchpadSourceMessages(readMainChatMessageWindow(store.db, {
-                    limit: RECENT_CONTEXT_RAW_MESSAGE_LIMIT,
-                }).items).slice(-recentMessageLimit)
-                : filterScratchpadSourceMessages(readMainChatMessagesBeforeCursor(store.db, {
-                    before_created_at: firstNewMainChatSource.created_at,
-                    before_id: firstNewMainChatSource.id,
-                    limit: RECENT_CONTEXT_RAW_MESSAGE_LIMIT,
-                })).slice(-recentMessageLimit);
-    const clarificationRounds = sourceState.task_compile_cursor === undefined
-        ? readSubmittedTaskCompileClarificationRounds(store.db, sourceFallbackSince === undefined
-            ? {
-                limit: DEFAULT_CLARIFICATION_SOURCE_ROUND_LIMIT,
-            }
-            : {
-                afterSubmittedAt: sourceFallbackSince,
-                limit: DEFAULT_CLARIFICATION_SOURCE_ROUND_LIMIT,
-            })
-        : readSubmittedTaskCompileClarificationRoundsAfterCursor(store.db, {
-            afterSubmittedAt: sourceState.task_compile_cursor.submitted_at,
-            afterRoundId: sourceState.task_compile_cursor.round_id,
-            limit: DEFAULT_CLARIFICATION_SOURCE_ROUND_LIMIT,
-        });
-    const clarificationSourceMessages = clarificationRounds.flatMap((round) => {
-        const window = readClarificationRoundMessagesWindow(store.db, round.id, {
-            anchor: "start",
-            limit: CLARIFICATION_SOURCE_MESSAGE_LIMIT,
-        });
-        return filterClarificationRoundScratchpadSourceMessages(window?.items ?? []);
-    });
-    const sourceMessages = sortScratchpadSourceMessages([
-        ...newMainChatSourceMessages,
-        ...clarificationSourceMessages,
-    ]);
-    const sourceRefMessages = sortScratchpadSourceMessages([
-        ...(isInitialMainChatRefresh ? recentMessages : []),
-        ...sourceMessages,
-    ]);
-    const latestMainChatSource = mainChatSourceMessages.at(-1);
-    const latestClarificationRound = clarificationRounds.at(-1);
-    const cursorUpdate = {};
-    if (latestMainChatSource !== undefined) {
-        cursorUpdate.main_chat_cursor = {
-            created_at: latestMainChatSource.created_at,
-            message_id: latestMainChatSource.id,
+function workflowInputSize(input) {
+    return JSON.stringify(input).length;
+}
+function fitScratchpadRefreshWorkflowInput(input) {
+    const base = {
+        ...(input.projectBrief === undefined ? {} : { project_brief: input.projectBrief }),
+        ...(input.activeTaskCompile === undefined
+            ? {}
+            : { active_task_compile: input.activeTaskCompile }),
+    };
+    const worklistVariants = [
+        compactScratchpadWorklist(input.worklist),
+        compactScratchpadWorklist(input.worklist, { summaryChars: 320 }),
+        compactScratchpadWorklist(input.worklist, { includeSummaries: false }),
+    ];
+    for (const worklist of worklistVariants) {
+        const candidate = {
+            ...base,
+            worklist,
+            messages: compactScratchpadSourceMessages(input.sourceMessages),
         };
+        if (workflowInputSize(candidate) <= MAX_SCRATCHPAD_WORKFLOW_INPUT_CHARS) {
+            return candidate;
+        }
     }
-    if (latestClarificationRound?.submitted_at !== undefined) {
-        cursorUpdate.task_compile_cursor = {
-            submitted_at: latestClarificationRound.submitted_at,
-            round_id: latestClarificationRound.id,
+    const worklist = worklistVariants.at(-1);
+    if (worklist === undefined) {
+        throw new ScratchpadSourceBudgetExceededError();
+    }
+    const minimumMessageBudget = input.sourceMessages.length * MIN_SOURCE_MESSAGE_TEXT_CHARS;
+    for (let messageBudget = MAX_SOURCE_MESSAGES_TOTAL_CHARS - 1_000; messageBudget >= minimumMessageBudget; messageBudget -= 1_000) {
+        const candidate = {
+            ...base,
+            worklist,
+            messages: compactScratchpadSourceMessages(input.sourceMessages, {
+                totalTextChars: messageBudget,
+            }),
         };
+        if (workflowInputSize(candidate) <= MAX_SCRATCHPAD_WORKFLOW_INPUT_CHARS) {
+            return candidate;
+        }
     }
+    throw new ScratchpadSourceBudgetExceededError();
+}
+export function readControlPlaneScratchpadSourceBatch(store, options = {}) {
+    const sourceState = readScratchpadSourceState(store.db);
+    const mainChatMessages = readMainChatMessagesForScratchpadCycle(store.db, sourceState.cycle_start_cursor);
+    const sourceMessages = filterScratchpadSourceMessages(mainChatMessages);
+    const latestSource = sourceMessages.at(-1);
+    const unrefreshedSourceCount = sourceMessages.filter((message) => {
+        const refreshedThrough = sourceState.refreshed_through_cursor;
+        if (refreshedThrough === undefined) {
+            return true;
+        }
+        const timeOrder = message.created_at.localeCompare(refreshedThrough.created_at);
+        return timeOrder > 0 || (timeOrder === 0 && message.id > refreshedThrough.message_id);
+    }).length;
+    const activeContext = readActiveTaskCompileContext(store.db);
     const projectBrief = readScratchpadProjectBrief({
         store,
         ...(options.projectContext === undefined ? {} : { projectContext: options.projectContext }),
         ...(options.now === undefined ? {} : { now: options.now }),
     });
+    const workflowInput = fitScratchpadRefreshWorkflowInput({
+        ...(projectBrief === undefined ? {} : { projectBrief }),
+        ...(activeContext === null
+            ? {}
+            : { activeTaskCompile: activeContext.scratchpad_snapshot }),
+        worklist: readWorklistProjection(store.db),
+        sourceMessages,
+    });
     return {
-        workflow_input: {
-            ...(projectBrief === undefined ? {} : { project_brief: projectBrief }),
-            previous: compactPreviousScratchpad(scratchpad),
-            recent_messages: compactScratchpadSourceMessages(recentMessages),
-            new_messages: compactScratchpadSourceMessages(sourceMessages),
-        },
-        cursor_update: cursorUpdate,
-        source_refs: sourceRefMessages.map((message) => ({
+        workflow_input: workflowInput,
+        cursor_update: latestSource === undefined
+            ? {}
+            : {
+                refreshed_through_cursor: {
+                    created_at: latestSource.created_at,
+                    message_id: latestSource.id,
+                },
+            },
+        source_refs: sourceMessages.map((message) => ({
             message_id: message.id,
-            source_scope: message.scope.kind,
+            source_scope: "main_chat",
             created_at: message.created_at,
         })),
-        source_message_count: sourceMessages.length + (isInitialMainChatRefresh ? recentMessages.length : 0),
+        source_message_count: unrefreshedSourceCount,
     };
 }
 export async function runControlPlaneScratchpadRefreshProcedure(options) {

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

@@ -1,4 +1,4 @@
-import { createMainChatAgentMessage, markScratchpadRefreshSucceeded, upsertScratchpadProjection, } from "../collaboration-state/index.js";
+import { createMainChatAgentMessage, markScratchpadRefreshSucceeded, markScratchpadSourceDirty, upsertScratchpadProjection, } from "../collaboration-state/index.js";
 import { mainChatInvalidates, scratchpadRefreshInvalidates, } from "./invalidations.js";
 export function applyScratchpadRefreshOutput(input) {
     if (input.output.decision === "needs_human") {
@@ -17,8 +17,10 @@ export function applyScratchpadRefreshOutput(input) {
             invalidates: mainChatInvalidates(),
         });
         markScratchpadRefreshSucceeded(input.store.db, {
+            ...input.cursorUpdate,
             now: input.now,
         });
+        markScratchpadSourceDirty(input.store.db, { now: input.now });
         return {
             kind: "needs_human",
             summary: input.output.request_payload.summary,

package/dist/control-plane/scratchpad-source-messages.d.ts

@@ -1,10 +1,18 @@
-import type { MessageProjection, ScratchpadProjection } from "@tutti/shared/schemas/api";
-import type { ScratchpadRefreshSourceMessageInput, ScratchpadRefreshWorkflowInput } from "./workflows/index.js";
+import type { MessageProjection, WorklistProjection } from "@tutti/shared/schemas/api";
+import type { ScratchpadRefreshSourceMessageInput, ScratchpadRefreshWorklistInput } from "./workflows/index.js";
+export declare const MAX_SOURCE_MESSAGES_TOTAL_CHARS = 10000;
+export declare const MIN_SOURCE_MESSAGE_TEXT_CHARS = 160;
+export declare class ScratchpadSourceBudgetExceededError extends Error {
+    constructor();
+}
 export declare function shouldUseMessageAsScratchpadSource(message: MessageProjection): boolean;
-export declare function shouldUseClarificationRoundMessageAsScratchpadSource(message: MessageProjection): boolean;
 export declare function filterScratchpadSourceMessages(messages: MessageProjection[]): MessageProjection[];
-export declare function filterClarificationRoundScratchpadSourceMessages(messages: MessageProjection[]): MessageProjection[];
-export declare function sortScratchpadSourceMessages(messages: MessageProjection[]): MessageProjection[];
-export declare function compactScratchpadSourceMessages(messages: MessageProjection[]): ScratchpadRefreshSourceMessageInput[];
-export declare function compactPreviousScratchpad(scratchpad: ScratchpadProjection): ScratchpadRefreshWorkflowInput["previous"];
+export declare function truncateTextMiddle(text: string, maxChars: number): string;
+export declare function compactScratchpadSourceMessages(messages: MessageProjection[], options?: {
+    totalTextChars?: number;
+}): ScratchpadRefreshSourceMessageInput[];
+export declare function compactScratchpadWorklist(worklist: WorklistProjection, options?: {
+    summaryChars?: number;
+    includeSummaries?: boolean;
+}): ScratchpadRefreshWorklistInput;
 //# sourceMappingURL=scratchpad-source-messages.d.ts.map

package/dist/control-plane/scratchpad-source-messages.js

@@ -1,10 +1,19 @@
-const MAX_COMPACT_SOURCE_MESSAGES = 20;
 const MAX_SOURCE_MESSAGE_TEXT_CHARS = 2_000;
-const MAX_SOURCE_MESSAGES_TOTAL_CHARS = 10_000;
+export const MAX_SOURCE_MESSAGES_TOTAL_CHARS = 10_000;
+export const MIN_SOURCE_MESSAGE_TEXT_CHARS = 160;
+const MESSAGE_BOUNDARY = "\n\n--- next message ---\n\n";
+const MIDDLE_OMISSION = "\n...[middle omitted by Tutti]...\n";
+const MAX_WORKLIST_SUMMARY_CHARS = 800;
+export class ScratchpadSourceBudgetExceededError extends Error {
+    constructor() {
+        super("Scratchpad source messages exceed the minimum deterministic context budget");
+        this.name = "ScratchpadSourceBudgetExceededError";
+    }
+}
 export function shouldUseMessageAsScratchpadSource(message) {
     const explicitSource = message.refs?.scratchpad_source;
     if (explicitSource !== undefined) {
-        return explicitSource === "include";
+        return message.scope.kind === "main_chat" && explicitSource === "include";
     }
     if (message.scope.kind !== "main_chat") {
         return false;
@@ -17,47 +26,31 @@ export function shouldUseMessageAsScratchpadSource(message) {
     }
     return false;
 }
-export function shouldUseClarificationRoundMessageAsScratchpadSource(message) {
-    const explicitSource = message.refs?.scratchpad_source;
-    if (explicitSource !== undefined) {
-        return explicitSource === "include";
-    }
-    if (message.scope.kind !== "clarification_round") {
-        return false;
-    }
-    if (message.message_kind === "clarification_request") {
-        return true;
-    }
-    return message.message_kind === "user_text" && message.author.kind === "human";
-}
 export function filterScratchpadSourceMessages(messages) {
     return messages.filter(shouldUseMessageAsScratchpadSource);
 }
-export function filterClarificationRoundScratchpadSourceMessages(messages) {
-    return messages.filter(shouldUseClarificationRoundMessageAsScratchpadSource);
-}
-export function sortScratchpadSourceMessages(messages) {
-    return [...messages].sort((left, right) => {
-        const timeOrder = left.created_at.localeCompare(right.created_at);
-        return timeOrder === 0 ? left.id.localeCompare(right.id) : timeOrder;
-    });
-}
 function compactRole(message) {
     return message.author.kind === "agent" ? "tutti" : "human";
 }
-function truncateSourceText(text) {
+export function truncateTextMiddle(text, maxChars) {
     const trimmed = text.trim();
-    if (trimmed.length <= MAX_SOURCE_MESSAGE_TEXT_CHARS) {
+    if (trimmed.length <= maxChars) {
         return trimmed;
     }
-    return `${trimmed.slice(0, MAX_SOURCE_MESSAGE_TEXT_CHARS - 3)}...`;
+    if (maxChars < MIDDLE_OMISSION.length + 2) {
+        throw new ScratchpadSourceBudgetExceededError();
+    }
+    const remaining = maxChars - MIDDLE_OMISSION.length;
+    const headLength = Math.ceil(remaining / 2);
+    const tailLength = Math.floor(remaining / 2);
+    return `${trimmed.slice(0, headLength)}${MIDDLE_OMISSION}${trimmed.slice(-tailLength)}`;
 }
-function sourceReferenceLabel(message) {
+function sourceText(message) {
     const reference = message.refs?.reference_file;
     if (reference === undefined) {
-        return undefined;
+        return message.body;
     }
-    return `${reference.category}:${reference.name}`;
+    return `Reference file (${reference.category}:${reference.name})\n${message.body}`;
 }
 function sourceAuthorDisplayName(message) {
     if (message.author.kind !== "human") {
@@ -66,14 +59,12 @@ function sourceAuthorDisplayName(message) {
     const displayName = message.author.display_name?.trim();
     return displayName === "" ? undefined : displayName;
 }
-function compactSourceMessage(message) {
-    const ref = sourceReferenceLabel(message);
+function compactSourceMessage(message, maxChars) {
     const authorDisplayName = sourceAuthorDisplayName(message);
     return {
         role: compactRole(message),
         ...(authorDisplayName === undefined ? {} : { author_display_name: authorDisplayName }),
-        text: truncateSourceText(message.body),
-        ...(ref === undefined ? {} : { ref }),
+        text: truncateTextMiddle(sourceText(message), maxChars),
     };
 }
 function mergeCompactSourceMessages(messages) {
@@ -82,50 +73,43 @@ function mergeCompactSourceMessages(messages) {
         const previous = merged.at(-1);
         if (previous !== undefined &&
             previous.role === message.role &&
-            previous.ref === message.ref &&
             previous.author_display_name === message.author_display_name) {
-            previous.text = truncateSourceText(`${previous.text}\n${message.text}`);
+            previous.text = `${previous.text}${MESSAGE_BOUNDARY}${message.text}`;
             continue;
         }
         merged.push({ ...message });
     }
     return merged;
 }
-function enforceTotalSourceTextLimit(messages) {
-    const result = [];
-    let remaining = MAX_SOURCE_MESSAGES_TOTAL_CHARS;
-    for (const message of messages.toReversed()) {
-        if (remaining <= 0) {
-            break;
-        }
-        const text = message.text.length <= remaining
-            ? message.text
-            : `${message.text.slice(0, Math.max(0, remaining - 3))}...`;
-        result.push({
-            ...message,
-            text,
-        });
-        remaining -= text.length;
+export function compactScratchpadSourceMessages(messages, options = {}) {
+    if (messages.length === 0) {
+        return [];
     }
-    return result.reverse();
-}
-export function compactScratchpadSourceMessages(messages) {
-    return enforceTotalSourceTextLimit(mergeCompactSourceMessages(messages.map(compactSourceMessage)).slice(-MAX_COMPACT_SOURCE_MESSAGES));
-}
-export function compactPreviousScratchpad(scratchpad) {
-    if (scratchpad.state !== "ready") {
-        return {};
+    const totalTextChars = options.totalTextChars ?? MAX_SOURCE_MESSAGES_TOTAL_CHARS;
+    const boundaryBudget = MESSAGE_BOUNDARY.length * Math.max(0, messages.length - 1);
+    const availableTextChars = totalTextChars - boundaryBudget;
+    if (availableTextChars < messages.length * MIN_SOURCE_MESSAGE_TEXT_CHARS) {
+        throw new ScratchpadSourceBudgetExceededError();
     }
+    const perMessageChars = Math.min(MAX_SOURCE_MESSAGE_TEXT_CHARS, Math.floor(availableTextChars / messages.length));
+    return mergeCompactSourceMessages(messages.map((message) => compactSourceMessage(message, perMessageChars)));
+}
+export function compactScratchpadWorklist(worklist, options = {}) {
+    const summaryChars = options.summaryChars ?? MAX_WORKLIST_SUMMARY_CHARS;
+    const includeSummaries = options.includeSummaries ?? true;
     return {
-        ...(scratchpad.topic.trim() === "" ? {} : { topic: scratchpad.topic }),
-        ...(scratchpad.background_summary.trim() === ""
-            ? {}
-            : { background: scratchpad.background_summary }),
-        ...(scratchpad.current_consensus.length === 0
-            ? {}
-            : { consensus: scratchpad.current_consensus }),
-        ...(scratchpad.open_questions.length === 0 ? {} : { questions: scratchpad.open_questions }),
-        ...(scratchpad.task_changes.length === 0 ? {} : { changes: scratchpad.task_changes }),
+        modules: worklist.modules
+            .filter((entry) => !entry.module.archived)
+            .map((entry) => ({
+            name: entry.module.name,
+            tasks: entry.tasks.map((task) => ({
+                title: task.title,
+                ...(includeSummaries && task.summary.trim() !== ""
+                    ? { summary: truncateTextMiddle(task.summary, summaryChars) }
+                    : {}),
+                status: task.status,
+            })),
+        })),
     };
 }
 //# sourceMappingURL=scratchpad-source-messages.js.map

package/dist/control-plane/task-compile-clarification-context.d.ts

@@ -0,0 +1,9 @@
+import type { ClarificationRoundRef, WorkflowInvocationRef } from "@tutti/shared/ids";
+import type { HostProjectStore } from "../store/index.js";
+import type { TaskCompileWorkflowInput } from "./workflows/index.js";
+export declare function readTaskCompileClarificationRounds(input: {
+    store: HostProjectStore;
+    workflowRef: WorkflowInvocationRef;
+    throughRoundId: ClarificationRoundRef;
+}): NonNullable<TaskCompileWorkflowInput["clarification_rounds"]>;
+//# sourceMappingURL=task-compile-clarification-context.d.ts.map

package/dist/control-plane/task-compile-clarification-context.js

@@ -0,0 +1,70 @@
+import { readActiveClarificationProjection, readClarificationRoundProjection, readClarificationRoundsForThread, readMessageProjectionById, } from "../collaboration-state/index.js";
+import { ScratchpadSourceBudgetExceededError, truncateTextMiddle } from "./scratchpad-source-messages.js";
+const MAX_CLARIFICATION_MESSAGE_CHARS = 4_000;
+const MAX_CLARIFICATION_MESSAGES_TOTAL_CHARS = 16_000;
+const MIN_CLARIFICATION_MESSAGE_CHARS = 160;
+function answerMessage(store, messageId, roundId) {
+    const message = readMessageProjectionById(store.db, messageId);
+    if (message === null ||
+        message.scope.kind !== "clarification_round" ||
+        message.scope.clarification_round_ref !== roundId ||
+        (message.message_kind !== "user_text" && message.message_kind !== "agent_text")) {
+        return null;
+    }
+    const role = message.author.kind === "agent" ? "tutti" : "human";
+    const displayName = message.author.display_name?.trim();
+    return {
+        role,
+        ...(role === "human" && displayName !== undefined && displayName !== ""
+            ? { author_display_name: displayName }
+            : {}),
+        text: message.body,
+    };
+}
+export function readTaskCompileClarificationRounds(input) {
+    const active = readActiveClarificationProjection(input.store.db);
+    if (active.state !== "active" ||
+        active.thread.owner.kind !== "task_compile" ||
+        active.thread.owner.workflow_ref !== input.workflowRef ||
+        active.round.id !== input.throughRoundId) {
+        throw new Error("Task Compile clarification owner does not match its pinned context");
+    }
+    const throughRound = readClarificationRoundProjection(input.store.db, input.throughRoundId);
+    if (throughRound === null || throughRound.status !== "sealed") {
+        throw new Error("Task Compile continuation requires a sealed clarification round");
+    }
+    const rounds = readClarificationRoundsForThread(input.store.db, throughRound.thread_id, {
+        throughRoundIndex: throughRound.round_index,
+    });
+    const contextRounds = rounds.map((round) => {
+        if (round.status !== "sealed") {
+            throw new Error("Task Compile clarification context cannot include a writable round");
+        }
+        const answerMessages = (round.submitted_message_refs ?? [])
+            .filter((messageId) => messageId !== round.opening_message_id && messageId !== round.card_message_id)
+            .flatMap((messageId) => {
+            const mapped = answerMessage(input.store, messageId, round.id);
+            return mapped === null ? [] : [mapped];
+        });
+        return {
+            request_payload: round.request_payload,
+            answer_messages: answerMessages,
+        };
+    });
+    const answerCount = contextRounds.reduce((count, round) => count + round.answer_messages.length, 0);
+    if (answerCount === 0) {
+        return contextRounds;
+    }
+    if (answerCount * MIN_CLARIFICATION_MESSAGE_CHARS > MAX_CLARIFICATION_MESSAGES_TOTAL_CHARS) {
+        throw new ScratchpadSourceBudgetExceededError();
+    }
+    const perMessageChars = Math.min(MAX_CLARIFICATION_MESSAGE_CHARS, Math.floor(MAX_CLARIFICATION_MESSAGES_TOTAL_CHARS / answerCount));
+    return contextRounds.map((round) => ({
+        request_payload: round.request_payload,
+        answer_messages: round.answer_messages.map((message) => ({
+            ...message,
+            text: truncateTextMiddle(message.text, perMessageChars),
+        })),
+    }));
+}
+//# sourceMappingURL=task-compile-clarification-context.js.map

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

@@ -1,12 +1,17 @@
-import { advanceScratchpadTaskCompileSourceCursor, materializeClarificationSuccessor, readClarificationRoundMessagesWindow, readClarificationRoundProjection, readScratchpadProjection, readWorklistProjection, } from "../collaboration-state/index.js";
+import { materializeClarificationSuccessor, readActiveTaskCompileContext, readClarificationRoundProjection, readWorklistProjection, rollbackTaskCompileContext, } from "../collaboration-state/index.js";
+import { withHostStoreTransaction } from "../store/index.js";
 import { clarificationInvalidates } from "./invalidations.js";
 import { applyTaskCompileProcedureOutput } from "./task-compile-output.js";
+import { readTaskCompileClarificationRounds } from "./task-compile-clarification-context.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
 export function startControlPlaneTaskCompileContinuation(options) {
     if (options.owner.kind !== "task_compile") {
         return false;
     }
     const workflowRef = options.owner.workflow_ref;
+    if (readActiveTaskCompileContext(options.store.db, workflowRef) === null) {
+        return false;
+    }
     const runnerResolution = options.resolveWorkflowRunner();
     if (runnerResolution.kind !== "ready") {
         return false;
@@ -29,28 +34,26 @@ export function startControlPlaneTaskCompileContinuation(options) {
         execute: async (context) => {
             const round = readClarificationRoundProjection(options.store.db, options.roundId);
             try {
-                const messagesWindow = round === null
-                    ? null
-                    : readClarificationRoundMessagesWindow(options.store.db, options.roundId, {
-                        anchor: "start",
-                    });
-                const clarification = round === null
-                    ? undefined
-                    : {
-                        request_payload: round.request_payload,
-                        messages: messagesWindow?.items ?? [],
-                    };
+                const taskCompileContext = readActiveTaskCompileContext(options.store.db, workflowRef);
+                if (taskCompileContext === null) {
+                    throw new Error("Active Task Compile Context is unavailable");
+                }
+                const clarificationRounds = readTaskCompileClarificationRounds({
+                    store: options.store,
+                    workflowRef,
+                    throughRoundId: options.roundId,
+                });
                 const output = await runnerResolution.runner.runTaskCompile({
                     workflow_ref: workflowRef,
-                    scratchpad: readScratchpadProjection(options.store.db),
+                    scratchpad: taskCompileContext.scratchpad_snapshot,
                     worklist: readWorklistProjection(options.store.db),
-                    ...(clarification === undefined ? {} : { clarification }),
+                    clarification_rounds: clarificationRounds,
                 }, {
                     workflow_ref: workflowRef,
                     activity_ref: context.activity_ref,
                     reportProgress: context.reportProgress,
                 });
-                const conclusion = applyTaskCompileProcedureOutput({
+                return applyTaskCompileProcedureOutput({
                     store: options.store,
                     events: options.events,
                     output,
@@ -60,52 +63,21 @@ export function startControlPlaneTaskCompileContinuation(options) {
                     continueFromRoundId: options.roundId,
                     onTasksAdded: options.onTasksAdded,
                 });
-                if (output.decision === "ready" &&
-                    conclusion.kind === "completed" &&
-                    round?.submitted_at !== undefined) {
-                    advanceScratchpadTaskCompileSourceCursor(options.store.db, {
-                        submitted_at: round.submitted_at,
+            }
+            catch (error) {
+                const threadId = round?.thread_id;
+                withHostStoreTransaction(options.store.db, (tx) => {
+                    materializeClarificationSuccessor(tx, {
                         round_id: options.roundId,
+                        successor_ref: { kind: "chain_closed" },
+                        close_thread: true,
+                        closed_reason: "cancelled",
                         now: options.now,
                     });
-                }
-                if (output.decision === "ready") {
-                    const threadId = round?.thread_id;
-                    materializeClarificationSuccessor(options.store.db, {
-                        round_id: options.roundId,
-                        successor_ref: {
-                            kind: "proposal_applied",
-                            workflow_ref: workflowRef,
-                        },
-                        close_thread: true,
+                    rollbackTaskCompileContext(tx, {
+                        workflow_ref: workflowRef,
                         now: options.now,
                     });
-                    if (threadId !== undefined) {
-                        options.events.publish({
-                            event_type: "clarification.changed",
-                            payload: {
-                                reason: "successor_materialized",
-                                thread_id: threadId,
-                                round_id: options.roundId,
-                                successor_ref: {
-                                    kind: "proposal_applied",
-                                    workflow_ref: workflowRef,
-                                },
-                            },
-                            invalidates: clarificationInvalidates(options.roundId, threadId),
-                        });
-                    }
-                }
-                return conclusion;
-            }
-            catch (error) {
-                const threadId = round?.thread_id;
-                materializeClarificationSuccessor(options.store.db, {
-                    round_id: options.roundId,
-                    successor_ref: { kind: "chain_closed" },
-                    close_thread: true,
-                    closed_reason: "cancelled",
-                    now: options.now,
                 });
                 if (threadId !== undefined) {
                     options.events.publish({