@xfey/tenso 0.1.130

package/dist/control-plane/scratchpad-refresh-start.d.ts

@@ -0,0 +1,71 @@
+import { createWorkflowInvocationRef, type ActivityRef, type ControlPlaneIntentId } from "@tutti/shared/ids";
+import type { RefreshScratchpadDisposition, RefreshScratchpadResult, ProcedureLane } from "@tutti/shared/schemas/api";
+import type { ScratchpadSourceCursorUpdate } from "../collaboration-state/scratchpad-source-state.js";
+import type { ScratchpadSourceRefInput, TaskCompileSubmissionRecord } from "../collaboration-state/types.js";
+import type { ProcedureEngine, ProcedureEngineState } from "../procedure-engine/index.js";
+import type { HostProjectStore } from "../store/index.js";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import type { ControlPlaneCommandResult, ControlPlaneLogger } from "./types.js";
+import type { IntentRuntimeTerminal } from "./intent-dispatcher.js";
+import type { ProcedureWorkflowRunner, ProcedureWorkflowRunnerResolver } from "./workflows/index.js";
+type ScratchpadProjectContext = {
+    workspaceRoot: string;
+};
+export type ScratchpadSourceBatch = {
+    workflow_input: Parameters<ProcedureWorkflowRunner["runScratchpadRefresh"]>[0];
+    cursor_update: ScratchpadSourceCursorUpdate;
+    source_refs: ScratchpadSourceRefInput[];
+    source_message_count: number;
+};
+export declare function readControlPlaneScratchpadSourceBatch(store: HostProjectStore, options?: {
+    projectContext?: ScratchpadProjectContext | undefined;
+    sourceWindow?: TaskCompileSubmissionRecord["source_window"];
+    now?: () => Date;
+}): ScratchpadSourceBatch;
+export declare function runControlPlaneScratchpadRefreshProcedure(options: {
+    runner: ProcedureWorkflowRunner;
+    workflowRef: ReturnType<typeof createWorkflowInvocationRef>;
+    activityRef: ActivityRef;
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    sourceBatch: ScratchpadSourceBatch;
+    lane: ProcedureLane;
+    logger?: ControlPlaneLogger | undefined;
+    recordRecoveryIntent?: boolean;
+    recoveryIntentId?: ControlPlaneIntentId;
+    now: () => Date;
+}): Promise<{
+    kind: "needs_human";
+    summary: string;
+    result_anchor: {
+        kind: "workflow";
+        workflow_ref: `wf_${string}`;
+    };
+} | {
+    kind: "completed";
+    summary: string;
+    result_anchor: {
+        kind: "workflow";
+        workflow_ref: `wf_${string}`;
+    };
+}>;
+export declare function readActiveScratchpadRefreshActivityRef(options: {
+    engine: ProcedureEngine;
+    store: HostProjectStore;
+}): ActivityRef | undefined;
+export declare function startControlPlaneScratchpadRefresh(options: {
+    engine: ProcedureEngine;
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    resolveWorkflowRunner: ProcedureWorkflowRunnerResolver;
+    projectContext?: ScratchpadProjectContext | undefined;
+    lane?: ProcedureLane;
+    logger?: ControlPlaneLogger | undefined;
+    now: () => Date;
+    publishProcedureTransition: (state: ProcedureEngineState) => void;
+    recordRecoveryIntent?: boolean;
+    recoveryIntentId?: ControlPlaneIntentId;
+    onTerminal?: (result?: IntentRuntimeTerminal) => void;
+}): ControlPlaneCommandResult<RefreshScratchpadDisposition, RefreshScratchpadResult>;
+export {};
+//# sourceMappingURL=scratchpad-refresh-start.d.ts.map

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

@@ -0,0 +1,295 @@
+import { createWorkflowInvocationRef, } from "@tutti/shared/ids";
+import { readActiveTaskCompileContext, readMainChatMessagesForScratchpadCycle, readScratchpadSourceState, readWorklistProjection, markScratchpadRefreshFailed, markScratchpadRefreshStarted, } from "../collaboration-state/index.js";
+import { projectLanguageContext, messageLanguageEvidence, logLanguageContext, } from "./communication-language.js";
+import { readProjectBriefProjection, readProjectBriefSourceDocuments, } from "../project-brief/index.js";
+import { withHostStoreTransaction } from "../store/index.js";
+import { logProcedureExecutionError } from "./procedure-logging.js";
+import { enqueueControlPlaneIntent, readControlPlaneIntentByDedupeKey, settlePendingControlPlaneIntent, } from "./dispatch-intents.js";
+import { applyScratchpadRefreshOutput } from "./scratchpad-refresh.js";
+import { compactScratchpadSourceMessages, compactScratchpadWorklist, filterScratchpadSourceMessages, MAX_SOURCE_MESSAGES_TOTAL_CHARS, MIN_SOURCE_MESSAGE_TEXT_CHARS, ScratchpadSourceBudgetExceededError, } from "./scratchpad-source-messages.js";
+const SCRATCHPAD_REFRESH_FAILURE_BACKOFF_MS = 60_000;
+const MAX_SCRATCHPAD_WORKFLOW_INPUT_CHARS = 30_000;
+function readScratchpadProjectBrief(input) {
+    if (input.projectContext === undefined) {
+        return undefined;
+    }
+    try {
+        const sources = readProjectBriefSourceDocuments({
+            workspaceRoot: input.projectContext.workspaceRoot,
+            ...(input.now === undefined ? {} : { now: input.now }),
+        });
+        const projection = readProjectBriefProjection(input.store.db, sources);
+        if (projection.state !== "ready") {
+            return undefined;
+        }
+        return {
+            product_summary: projection.product_summary,
+            tech_summary: projection.tech_summary,
+            structure_summary: projection.structure_summary,
+            principles_summary: projection.principles_summary,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function workflowInputSize(input) {
+    return JSON.stringify(input).length;
+}
+function fitScratchpadRefreshWorkflowInput(input) {
+    const base = {
+        communication_language: input.language,
+        ...(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;
+        }
+    }
+    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, options.sourceWindow?.after ?? sourceState.cycle_start_cursor).filter((message) => {
+        const through = options.sourceWindow?.through;
+        if (through === undefined) {
+            return true;
+        }
+        const timeOrder = message.created_at.localeCompare(through.created_at);
+        return timeOrder < 0 || (timeOrder === 0 && message.id <= through.message_id);
+    });
+    const sourceMessages = filterScratchpadSourceMessages(mainChatMessages);
+    const latestSource = sourceMessages.at(-1);
+    const unrefreshedSourceCount = sourceMessages.filter((message) => {
+        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,
+        language: projectLanguageContext(store.db, "scratchpad", sourceMessages.map(messageLanguageEvidence)),
+    });
+    return {
+        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: "main_chat",
+            created_at: message.created_at,
+        })),
+        source_message_count: unrefreshedSourceCount,
+    };
+}
+export async function runControlPlaneScratchpadRefreshProcedure(options) {
+    withHostStoreTransaction(options.store.db, (tx) => {
+        let intentId = options.recoveryIntentId;
+        if (options.recordRecoveryIntent !== false) {
+            intentId = enqueueControlPlaneIntent(tx, {
+                kind: "scratchpad_refresh",
+                ownerKind: "scratchpad",
+                ownerRef: options.activityRef,
+                dedupeKey: `scratchpad_refresh:${options.activityRef}`,
+                lane: options.lane,
+                priority: options.lane === "scratchpad_background" ? 80 : 40,
+                now: options.now,
+            }).intent.intent_id;
+        }
+        markScratchpadRefreshStarted(tx, {
+            activityRef: options.activityRef,
+            ...(intentId === undefined ? {} : { intentId }),
+            now: options.now,
+        });
+    });
+    const language = options.sourceBatch.workflow_input.communication_language;
+    if (language !== undefined)
+        logLanguageContext(options.logger, language, {
+            workflow_ref: options.workflowRef,
+            activity_ref: options.activityRef,
+        });
+    let output;
+    try {
+        output = await options.runner.runScratchpadRefresh(options.sourceBatch.workflow_input, {
+            workflow_ref: options.workflowRef,
+            activity_ref: options.activityRef,
+        });
+    }
+    catch (error) {
+        markScratchpadRefreshFailed(options.store.db, {
+            backoffUntil: new Date(options.now().getTime() + SCRATCHPAD_REFRESH_FAILURE_BACKOFF_MS).toISOString(),
+            now: options.now,
+        });
+        throw error;
+    }
+    if (language !== undefined)
+        logLanguageContext(options.logger, language, { workflow_ref: options.workflowRef, activity_ref: options.activityRef }, output.communication_language);
+    return applyScratchpadRefreshOutput({
+        store: options.store,
+        events: options.events,
+        output,
+        workflowRef: options.workflowRef,
+        activityRef: options.activityRef,
+        cursorUpdate: options.sourceBatch.cursor_update,
+        sourceRefs: options.sourceBatch.source_refs,
+        now: options.now,
+        ...(language === undefined ? {} : { languageContext: language }),
+    });
+}
+export function readActiveScratchpadRefreshActivityRef(options) {
+    const inFlight = readScratchpadSourceState(options.store.db).in_flight?.activity_ref;
+    if (inFlight !== undefined) {
+        return inFlight;
+    }
+    return options.engine.getActiveProcedures().find((activity) => {
+        return activity.workflow_kind === "scratchpad_refresh";
+    })?.activity_ref;
+}
+export function startControlPlaneScratchpadRefresh(options) {
+    const activeScratchpadRefresh = readActiveScratchpadRefreshActivityRef(options);
+    if (activeScratchpadRefresh !== undefined) {
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: activeScratchpadRefresh,
+            },
+        };
+    }
+    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 sourceBatch = readControlPlaneScratchpadSourceBatch(options.store, {
+        projectContext: options.projectContext,
+        now: options.now,
+    });
+    if (sourceBatch.source_message_count === 0) {
+        return { disposition: { kind: "no_source_messages" } };
+    }
+    const workflowRef = createWorkflowInvocationRef();
+    const start = options.engine.startProcedure({
+        workflow_ref: workflowRef,
+        workflow_kind: "scratchpad_refresh",
+        lane: options.lane ?? "foreground",
+        title: "Refresh Scratchpad",
+        summary: "Refreshing Scratchpad from main chat.",
+        now: options.now,
+        onTransition: (state) => {
+            if (state.transition_kind === "terminal" && options.recordRecoveryIntent !== false) {
+                const intent = readControlPlaneIntentByDedupeKey(options.store.db, `scratchpad_refresh:${state.activity.activity_ref}`);
+                if (intent?.state === "pending") {
+                    settlePendingControlPlaneIntent(options.store.db, {
+                        intentId: intent.intent_id,
+                        state: state.activity.status === "failed" ? "failed" : "completed",
+                        ...(state.activity.status === "failed"
+                            ? { errorCode: "scratchpad_refresh_failed" }
+                            : {}),
+                        now: options.now,
+                    });
+                }
+            }
+            options.publishProcedureTransition(state);
+            if (state.transition_kind === "terminal") {
+                options.onTerminal?.(state.activity.status === "failed"
+                    ? { state: "failed", errorCode: "scratchpad_refresh_failed" }
+                    : undefined);
+            }
+        },
+        onError: ({ context, error }) => logProcedureExecutionError({
+            logger: options.logger,
+            workflowKind: "scratchpad_refresh",
+            workflowRef,
+            activityRef: context.activity_ref,
+            error,
+        }),
+        execute: async (context) => runControlPlaneScratchpadRefreshProcedure({
+            logger: options.logger,
+            runner: runnerResolution.runner,
+            workflowRef,
+            activityRef: context.activity_ref,
+            store: options.store,
+            events: options.events,
+            sourceBatch,
+            lane: options.lane ?? "foreground",
+            ...(options.recordRecoveryIntent === undefined
+                ? {}
+                : { recordRecoveryIntent: options.recordRecoveryIntent }),
+            ...(options.recoveryIntentId === undefined
+                ? {}
+                : { recoveryIntentId: options.recoveryIntentId }),
+            now: options.now,
+        }),
+    });
+    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,
+        },
+    };
+}
+//# sourceMappingURL=scratchpad-refresh-start.js.map

package/dist/control-plane/scratchpad-refresh.d.ts

@@ -0,0 +1,33 @@
+import type { ActivityRef, WorkflowInvocationRef } from "@tutti/shared/ids";
+import type { ScratchpadSourceCursorUpdate } from "../collaboration-state/scratchpad-source-state.js";
+import type { ScratchpadSourceRefInput } from "../collaboration-state/types.js";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import type { HostProjectStore } from "../store/index.js";
+import type { CommunicationLanguageContext } from "../communication-language/index.js";
+import type { ScratchpadRefreshWorkflowOutput } from "./workflows/index.js";
+export declare function applyScratchpadRefreshOutput(input: {
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    output: ScratchpadRefreshWorkflowOutput;
+    workflowRef: WorkflowInvocationRef;
+    activityRef: ActivityRef;
+    cursorUpdate: ScratchpadSourceCursorUpdate;
+    sourceRefs: ScratchpadSourceRefInput[];
+    now: () => Date;
+    languageContext?: CommunicationLanguageContext;
+}): {
+    kind: "needs_human";
+    summary: string;
+    result_anchor: {
+        kind: "workflow";
+        workflow_ref: `wf_${string}`;
+    };
+} | {
+    kind: "completed";
+    summary: string;
+    result_anchor: {
+        kind: "workflow";
+        workflow_ref: `wf_${string}`;
+    };
+};
+//# sourceMappingURL=scratchpad-refresh.d.ts.map

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

@@ -0,0 +1,71 @@
+import { createMainChatAgentMessage, markScratchpadRefreshSucceeded, upsertScratchpadProjection, readMessageProjectionById, } from "../collaboration-state/index.js";
+import { withHostStoreTransaction } from "../store/index.js";
+import { recordScratchpadLanguage } from "./communication-language.js";
+import { mainChatInvalidates, scratchpadRefreshInvalidates } from "./invalidations.js";
+export function applyScratchpadRefreshOutput(input) {
+    const persistLanguage = () => recordScratchpadLanguage(input.store.db, {
+        ...(input.output.communication_language === undefined
+            ? {}
+            : { language: input.output.communication_language }),
+        ...(input.languageContext === undefined ? {} : { context: input.languageContext }),
+        sourceMessages: input.sourceRefs.flatMap((source) => {
+            const message = readMessageProjectionById(input.store.db, source.message_id);
+            return message === null ? [] : [message];
+        }),
+        activityRef: input.activityRef,
+        snapshot: input.output.decision === "ready",
+        now: input.now,
+    });
+    if (input.output.decision === "needs_human") {
+        const request = input.output.request_payload.request;
+        const message = withHostStoreTransaction(input.store.db, () => {
+            persistLanguage();
+            markScratchpadRefreshSucceeded(input.store.db, { ...input.cursorUpdate, now: input.now });
+            return createMainChatAgentMessage(input.store.db, {
+                body: request,
+                refs: {
+                    workflow_ref: input.workflowRef,
+                    activity_ref: input.activityRef,
+                    scratchpad_source: "exclude",
+                },
+                now: input.now,
+            });
+        });
+        input.events.publish({
+            event_type: "message.created",
+            payload: { message },
+            invalidates: mainChatInvalidates(),
+        });
+        return {
+            kind: "needs_human",
+            summary: input.output.request_payload.summary,
+            result_anchor: { kind: "workflow", workflow_ref: input.workflowRef },
+        };
+    }
+    const snapshot = input.output.scratchpad_snapshot;
+    const scratchpad = withHostStoreTransaction(input.store.db, () => {
+        persistLanguage();
+        const projection = upsertScratchpadProjection(input.store.db, {
+            ...snapshot,
+            source_refs: input.sourceRefs,
+            updated_by_activity_ref: input.activityRef,
+            now: input.now,
+        });
+        markScratchpadRefreshSucceeded(input.store.db, { ...input.cursorUpdate, now: input.now });
+        return projection;
+    });
+    input.events.publish({
+        event_type: "scratchpad.updated",
+        payload: {
+            scratchpad,
+            activity_ref: input.activityRef,
+        },
+        invalidates: scratchpadRefreshInvalidates(),
+    });
+    return {
+        kind: "completed",
+        summary: "Scratchpad refreshed.",
+        result_anchor: { kind: "workflow", workflow_ref: input.workflowRef },
+    };
+}
+//# sourceMappingURL=scratchpad-refresh.js.map

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

@@ -0,0 +1,18 @@
+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 filterScratchpadSourceMessages(messages: MessageProjection[]): MessageProjection[];
+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

@@ -0,0 +1,122 @@
+import { messageTextForModel } from "../collaboration-state/message-context.js";
+const MAX_SOURCE_MESSAGE_TEXT_CHARS = 2_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 Tenso]...\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 message.scope.kind === "main_chat" && explicitSource === "include";
+    }
+    if (message.scope.kind !== "main_chat") {
+        return false;
+    }
+    if (message.message_kind === "user_text" &&
+        (message.author.kind === "human" ||
+            (message.author.kind === "system" && message.refs?.development_operator === true))) {
+        return true;
+    }
+    if (message.message_kind === "agent_text" && message.author.kind === "agent") {
+        return message.refs?.workflow_ref === undefined && message.refs?.activity_ref === undefined;
+    }
+    return false;
+}
+export function filterScratchpadSourceMessages(messages) {
+    return messages.filter(shouldUseMessageAsScratchpadSource);
+}
+function compactRole(message) {
+    return message.refs?.development_operator === true
+        ? "operator"
+        : message.author.kind === "agent"
+            ? "tutti"
+            : "human";
+}
+export function truncateTextMiddle(text, maxChars) {
+    const trimmed = text.trim();
+    if (trimmed.length <= maxChars) {
+        return trimmed;
+    }
+    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 sourceText(message) {
+    const reference = message.refs?.reference_file;
+    if (reference === undefined) {
+        return messageTextForModel(message);
+    }
+    return `Reference file (${reference.category}:${reference.name})\n${message.body}`;
+}
+function sourceAuthorDisplayName(message) {
+    if (message.author.kind !== "human" && message.refs?.development_operator !== true) {
+        return undefined;
+    }
+    const displayName = message.author.display_name?.trim();
+    return displayName === "" ? undefined : displayName;
+}
+function compactSourceMessage(message, maxChars) {
+    const authorDisplayName = sourceAuthorDisplayName(message);
+    return {
+        role: compactRole(message),
+        ...(authorDisplayName === undefined ? {} : { author_display_name: authorDisplayName }),
+        text: truncateTextMiddle(sourceText(message), maxChars),
+    };
+}
+function mergeCompactSourceMessages(messages) {
+    const merged = [];
+    for (const message of messages) {
+        const previous = merged.at(-1);
+        if (previous !== undefined &&
+            previous.role === message.role &&
+            previous.author_display_name === message.author_display_name) {
+            previous.text = `${previous.text}${MESSAGE_BOUNDARY}${message.text}`;
+            continue;
+        }
+        merged.push({ ...message });
+    }
+    return merged;
+}
+export function compactScratchpadSourceMessages(messages, options = {}) {
+    if (messages.length === 0) {
+        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 {
+        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/startup-recovery.d.ts

@@ -0,0 +1,19 @@
+import type { ClarificationRoundRef } from "@tutti/shared/ids";
+import type { ExecutionStatusProjection } from "@tutti/shared/schemas/api";
+import { type SealedClarificationRoundWithoutSuccessor } from "../collaboration-state/index.js";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import { type HostProjectStore } from "../store/index.js";
+import type { StartupRecoveryOptions, StartupRecoveryResult } from "./types.js";
+type LastRecoveryConclusion = NonNullable<ExecutionStatusProjection["last_conclusion"]>;
+export type StartupRecoveryEnqueueSealedRound = (sealed: SealedClarificationRoundWithoutSuccessor, roundId: ClarificationRoundRef) => boolean;
+export declare function runControlPlaneStartupRecovery(input: {
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    options?: StartupRecoveryOptions;
+    now: () => Date;
+    getExecutionStatus: () => ExecutionStatusProjection;
+    setLastRecoveryConclusion: (conclusion: LastRecoveryConclusion) => void;
+    enqueueSealedRound: StartupRecoveryEnqueueSealedRound;
+}): StartupRecoveryResult;
+export {};
+//# sourceMappingURL=startup-recovery.d.ts.map