@xfey/tutti 0.1.0

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

@@ -0,0 +1,240 @@
+import { createWorkflowInvocationRef, } from "@tutti/shared/ids";
+import { readClarificationRoundMessagesWindow, readMainChatMessageWindow, readMainChatMessagesAfter, readMainChatMessagesAfterCursor, readMainChatMessagesBeforeCursor, markScratchpadRefreshFailed, markScratchpadRefreshStarted, readScratchpadProjection, readScratchpadSourceState, readSubmittedTaskCompileClarificationRounds, readSubmittedTaskCompileClarificationRoundsAfterCursor, } 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;
+const SCRATCHPAD_REFRESH_FAILURE_BACKOFF_MS = 60_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;
+    }
+}
+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 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,
+        };
+    }
+    if (latestClarificationRound?.submitted_at !== undefined) {
+        cursorUpdate.task_compile_cursor = {
+            submitted_at: latestClarificationRound.submitted_at,
+            round_id: latestClarificationRound.id,
+        };
+    }
+    const projectBrief = readScratchpadProjectBrief({
+        store,
+        ...(options.projectContext === undefined ? {} : { projectContext: options.projectContext }),
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    return {
+        workflow_input: {
+            ...(projectBrief === undefined ? {} : { project_brief: projectBrief }),
+            previous: compactPreviousScratchpad(scratchpad),
+            recent_messages: compactScratchpadSourceMessages(recentMessages),
+            new_messages: compactScratchpadSourceMessages(sourceMessages),
+        },
+        cursor_update: cursorUpdate,
+        source_message_count: sourceMessages.length + (isInitialMainChatRefresh ? recentMessages.length : 0),
+    };
+}
+export async function runControlPlaneScratchpadRefreshProcedure(options) {
+    markScratchpadRefreshStarted(options.store.db, {
+        activityRef: options.activityRef,
+        now: options.now,
+    });
+    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;
+    }
+    return applyScratchpadRefreshOutput({
+        store: options.store,
+        events: options.events,
+        output,
+        workflowRef: options.workflowRef,
+        activityRef: options.activityRef,
+        cursorUpdate: options.sourceBatch.cursor_update,
+        now: options.now,
+    });
+}
+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: options.publishProcedureTransition,
+        onError: ({ context, error }) => logProcedureExecutionError({
+            logger: options.logger,
+            workflowKind: "scratchpad_refresh",
+            workflowRef,
+            activityRef: context.activity_ref,
+            error,
+        }),
+        execute: async (context) => runControlPlaneScratchpadRefreshProcedure({
+            runner: runnerResolution.runner,
+            workflowRef,
+            activityRef: context.activity_ref,
+            store: options.store,
+            events: options.events,
+            sourceBatch,
+            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,29 @@
+import type { ActivityRef, WorkflowInvocationRef } from "@tutti/shared/ids";
+import type { ScratchpadSourceCursorUpdate } from "../collaboration-state/scratchpad-source-state.js";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import type { HostProjectStore } from "../store/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;
+    now: () => Date;
+}): {
+    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,55 @@
+import { createMainChatAgentMessage, markScratchpadRefreshSucceeded, upsertScratchpadProjection, } from "../collaboration-state/index.js";
+import { mainChatInvalidates, scratchpadRefreshInvalidates, } from "./invalidations.js";
+export function applyScratchpadRefreshOutput(input) {
+    if (input.output.decision === "needs_human") {
+        const message = createMainChatAgentMessage(input.store.db, {
+            body: input.output.request_payload.request,
+            refs: {
+                workflow_ref: input.workflowRef,
+                activity_ref: input.activityRef,
+                scratchpad_source: "include",
+            },
+            now: input.now,
+        });
+        input.events.publish({
+            event_type: "message.created",
+            payload: { message },
+            invalidates: mainChatInvalidates(),
+        });
+        markScratchpadRefreshSucceeded(input.store.db, {
+            now: input.now,
+        });
+        return {
+            kind: "needs_human",
+            summary: input.output.request_payload.summary,
+            result_anchor: { kind: "workflow", workflow_ref: input.workflowRef },
+        };
+    }
+    const scratchpad = upsertScratchpadProjection(input.store.db, {
+        topic: input.output.scratchpad_snapshot.topic,
+        background_summary: input.output.scratchpad_snapshot.background_summary,
+        current_consensus: input.output.scratchpad_snapshot.current_consensus,
+        open_questions: input.output.scratchpad_snapshot.open_questions,
+        task_changes: input.output.scratchpad_snapshot.task_changes,
+        updated_by_activity_ref: input.activityRef,
+        now: input.now,
+    });
+    markScratchpadRefreshSucceeded(input.store.db, {
+        ...input.cursorUpdate,
+        now: input.now,
+    });
+    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,10 @@
+import type { MessageProjection, ScratchpadProjection } from "@tutti/shared/schemas/api";
+import type { ScratchpadRefreshSourceMessageInput, ScratchpadRefreshWorkflowInput } from "./workflows/index.js";
+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"];
+//# sourceMappingURL=scratchpad-source-messages.d.ts.map

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

@@ -0,0 +1,131 @@
+const MAX_COMPACT_SOURCE_MESSAGES = 20;
+const MAX_SOURCE_MESSAGE_TEXT_CHARS = 2_000;
+const MAX_SOURCE_MESSAGES_TOTAL_CHARS = 10_000;
+export function shouldUseMessageAsScratchpadSource(message) {
+    const explicitSource = message.refs?.scratchpad_source;
+    if (explicitSource !== undefined) {
+        return explicitSource === "include";
+    }
+    if (message.scope.kind !== "main_chat") {
+        return false;
+    }
+    if (message.message_kind === "user_text" && message.author.kind === "human") {
+        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 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) {
+    const trimmed = text.trim();
+    if (trimmed.length <= MAX_SOURCE_MESSAGE_TEXT_CHARS) {
+        return trimmed;
+    }
+    return `${trimmed.slice(0, MAX_SOURCE_MESSAGE_TEXT_CHARS - 3)}...`;
+}
+function sourceReferenceLabel(message) {
+    const reference = message.refs?.reference_file;
+    if (reference === undefined) {
+        return undefined;
+    }
+    return `${reference.category}:${reference.name}`;
+}
+function sourceAuthorDisplayName(message) {
+    if (message.author.kind !== "human") {
+        return undefined;
+    }
+    const displayName = message.author.display_name?.trim();
+    return displayName === "" ? undefined : displayName;
+}
+function compactSourceMessage(message) {
+    const ref = sourceReferenceLabel(message);
+    const authorDisplayName = sourceAuthorDisplayName(message);
+    return {
+        role: compactRole(message),
+        ...(authorDisplayName === undefined ? {} : { author_display_name: authorDisplayName }),
+        text: truncateSourceText(message.body),
+        ...(ref === undefined ? {} : { ref }),
+    };
+}
+function mergeCompactSourceMessages(messages) {
+    const merged = [];
+    for (const message of 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}`);
+            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;
+    }
+    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 {};
+    }
+    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 }),
+    };
+}
+//# 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 StartupRecoveryReplaySealedRound = (sealed: SealedClarificationRoundWithoutSuccessor, roundId: ClarificationRoundRef) => boolean;
+export declare function runControlPlaneStartupRecovery(input: {
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    options?: StartupRecoveryOptions;
+    now: () => Date;
+    getExecutionStatus: () => ExecutionStatusProjection;
+    setLastRecoveryConclusion: (conclusion: LastRecoveryConclusion) => void;
+    replaySealedRound: StartupRecoveryReplaySealedRound;
+}): StartupRecoveryResult;
+export {};
+//# sourceMappingURL=startup-recovery.d.ts.map

package/dist/control-plane/startup-recovery.js

@@ -0,0 +1,113 @@
+import { deleteStaleClarificationSubmitReplayHints, readSealedClarificationRoundsWithoutSuccessor, recoverStaleRunningTasksAsFailed, recordRecoverySummary, } from "../collaboration-state/index.js";
+import { formatStartupRecoverySummary } from "./formatters.js";
+import { EXECUTION_STATUS_INVALIDATES, STARTUP_RECOVERY_INVALIDATES, taskRunInvalidates, } from "./invalidations.js";
+export function runControlPlaneStartupRecovery(input) {
+    const options = input.options ?? {};
+    const cleanup = options.cleanupStaleRunWorkspaces?.() ?? {
+        removed_run_workspace_count: 0,
+        removed_temp_branch_count: 0,
+        warnings: [],
+    };
+    const staleReplayHintCount = deleteStaleClarificationSubmitReplayHints(input.store.db);
+    const recovered = recoverStaleRunningTasksAsFailed(input.store.db, { now: input.now });
+    const sealedRounds = readSealedClarificationRoundsWithoutSuccessor(input.store.db);
+    const replayedRoundIds = [];
+    for (const sealed of sealedRounds) {
+        if (sealed.thread.status !== "active") {
+            continue;
+        }
+        const roundId = sealed.round.id;
+        if (input.replaySealedRound(sealed, roundId)) {
+            replayedRoundIds.push(roundId);
+        }
+    }
+    const interruptedCommandCount = options.interruptedCommandCount ?? 0;
+    const affectedActivities = recovered.recovered_runs.map((recoveredRun) => recoveredRun.activity_ref);
+    const shouldRecord = affectedActivities.length > 0 ||
+        replayedRoundIds.length > 0 ||
+        interruptedCommandCount > 0 ||
+        cleanup.removed_run_workspace_count > 0 ||
+        cleanup.removed_temp_branch_count > 0 ||
+        cleanup.warnings.length > 0 ||
+        staleReplayHintCount > 0;
+    if (!shouldRecord) {
+        return { kind: "noop" };
+    }
+    const summary = formatStartupRecoverySummary({
+        recoveredRunCount: recovered.recovered_runs.length,
+        replayedRoundCount: replayedRoundIds.length,
+        interruptedCommandCount,
+        removedRunWorkspaceCount: cleanup.removed_run_workspace_count,
+        removedTempBranchCount: cleanup.removed_temp_branch_count,
+        cleanupWarningCount: cleanup.warnings.length,
+        staleReplayHintCount,
+    });
+    const recorded = recordRecoverySummary(input.store.db, {
+        summary,
+        affected_activities: affectedActivities,
+        now: input.now,
+    });
+    input.setLastRecoveryConclusion({
+        kind: "recovered",
+        summary,
+        ...(affectedActivities[0] === undefined ? {} : { activity_ref: affectedActivities[0] }),
+        occurred_at: recorded.recovery_summary.created_at,
+    });
+    for (const recoveredRun of recovered.recovered_runs) {
+        const taskId = recoveredRun.task.id;
+        const invalidates = taskRunInvalidates(taskId);
+        input.events.publish({
+            event_type: "worklist.changed",
+            payload: {
+                reason: "task_result_recorded",
+                activity_ref: recoveredRun.activity_ref,
+                changed_task_ids: [taskId],
+            },
+            invalidates,
+        });
+        input.events.publish({
+            event_type: "task.updated",
+            payload: { task: recoveredRun.task },
+            invalidates,
+        });
+        input.events.publish({
+            event_type: "task_detail.updated",
+            payload: {
+                task_id: taskId,
+                task: recoveredRun.task,
+                detail: recoveredRun.task_detail,
+                latest_run_result_id: recoveredRun.run_result.id,
+            },
+            invalidates,
+        });
+    }
+    input.events.publish({
+        event_type: "workspace.recovered",
+        payload: {
+            recovery_summary_id: recorded.recovery_summary.recovery_summary_id,
+            summary: recorded.recovery_summary.summary,
+            affected_activities: recorded.recovery_summary.affected_activities,
+            ...(replayedRoundIds.length === 0 ? {} : { replayed_round_ids: replayedRoundIds }),
+        },
+        invalidates: STARTUP_RECOVERY_INVALIDATES,
+    });
+    input.events.publish({
+        event_type: "execution_status.changed",
+        payload: {
+            execution_status: input.getExecutionStatus(),
+        },
+        invalidates: EXECUTION_STATUS_INVALIDATES,
+    });
+    return {
+        kind: "recovered",
+        recovery_summary: recorded.recovery_summary,
+        recovered_run_count: recovered.recovered_runs.length,
+        replayed_round_ids: replayedRoundIds,
+        interrupted_command_count: interruptedCommandCount,
+        removed_run_workspace_count: cleanup.removed_run_workspace_count,
+        removed_temp_branch_count: cleanup.removed_temp_branch_count,
+        cleanup_warning_count: cleanup.warnings.length,
+        stale_replay_hint_count: staleReplayHintCount,
+    };
+}
+//# sourceMappingURL=startup-recovery.js.map

package/dist/control-plane/task-compile-continuation.d.ts

@@ -0,0 +1,25 @@
+import type { ClarificationRoundRef } from "@tutti/shared/ids";
+import type { ProcedureEngine, ProcedureEngineState } from "../procedure-engine/index.js";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import type { HostProjectStore } from "../store/index.js";
+import type { ControlPlaneLogger } from "./types.js";
+import type { ProcedureWorkflowRunnerResolver } from "./workflows/index.js";
+export declare function startControlPlaneTaskCompileContinuation(options: {
+    engine: ProcedureEngine;
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    owner: {
+        kind: "task_compile";
+        workflow_ref: string;
+    } | {
+        kind: "task";
+        task_id: string;
+    };
+    roundId: ClarificationRoundRef;
+    resolveWorkflowRunner: ProcedureWorkflowRunnerResolver;
+    logger?: ControlPlaneLogger | undefined;
+    now: () => Date;
+    publishProcedureTransition: (state: ProcedureEngineState) => void;
+    onTasksAdded: () => void;
+}): boolean;
+//# sourceMappingURL=task-compile-continuation.d.ts.map