@xfey/tutti 0.1.0

package/dist/collaboration-state/run-recording.js

@@ -0,0 +1,216 @@
+import { createEventRef, createRunResultId, } from "@tutti/shared/ids";
+import { withHostStoreTransaction } from "../store/index.js";
+import { nowIso, stringifyJson } from "./serialization.js";
+import { mapClarificationRoundRow, mapClarificationThreadRow, readClarificationRoundRow, readClarificationThreadRow, } from "./clarification-records.js";
+import { insertTaskBoundClarificationRound } from "./clarification-rounds.js";
+import { mapMessageRow } from "./messages.js";
+import { mapRunResultRow } from "./run-results.js";
+import { readTaskDetailProjection } from "./task-details.js";
+import { readTaskProjection } from "./worklist.js";
+import { recordReadNotificationEvent } from "./read-state.js";
+export function recordRunResult(db, input) {
+    return withHostStoreTransaction(db, (tx) => {
+        if (readTaskProjection(tx, input.task_id) === null) {
+            throw new Error(`Task was not found: ${input.task_id}`);
+        }
+        const createdAt = nowIso(input.now);
+        const runResultId = createRunResultId();
+        const sourceEventRef = createEventRef();
+        const taskStatus = input.result.result_kind === "finished" && input.result.outcome === "completed"
+            ? "done"
+            : "failed";
+        const resultJson = { ...input.result };
+        const detailResult = {
+            latest_run_result_id: runResultId,
+            result_kind: input.result.result_kind,
+            run_lineage: input.run_lineage,
+            summary: input.result.summary,
+            updated_at: createdAt,
+        };
+        if (input.result.result_kind === "finished") {
+            detailResult.outcome = input.result.outcome;
+            detailResult.checks = input.result.checks;
+            detailResult.docs = input.result.docs;
+            if (input.result.skip_reason_code !== undefined) {
+                detailResult.skip_reason_code = input.result.skip_reason_code;
+            }
+            if (input.result.skip_reason_summary !== undefined) {
+                detailResult.skip_reason_summary = input.result.skip_reason_summary;
+            }
+            if (input.result.external_side_effects !== undefined) {
+                detailResult.external_side_effects = input.result.external_side_effects;
+            }
+        }
+        else {
+            detailResult.error_code = input.result.error_code;
+            detailResult.retryable = input.result.retryable;
+        }
+        if (input.result.changed_paths !== undefined) {
+            detailResult.changed_paths = input.result.changed_paths;
+        }
+        if (input.result.promotion !== undefined) {
+            detailResult.promotion = input.result.promotion;
+        }
+        tx.prepare(`
+        INSERT INTO run_results (
+          id,
+          activity_ref,
+          task_id,
+          source_event_ref,
+          run_lineage_json,
+          result_kind,
+          result_json,
+          created_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(runResultId, input.activity_ref, input.task_id, sourceEventRef, stringifyJson(input.run_lineage), input.result.result_kind, stringifyJson(resultJson), createdAt);
+        tx.prepare(`
+        UPDATE tasks
+        SET status = ?,
+            current_activity_ref = NULL,
+            latest_run_result_id = ?,
+            updated_at = ?
+        WHERE id = ?
+      `).run(taskStatus, runResultId, createdAt, input.task_id);
+        tx.prepare(`
+        UPDATE task_details
+        SET result_json = ?,
+            frozen_contract_since_activity_ref = COALESCE(
+              frozen_contract_since_activity_ref,
+              ?
+            ),
+            updated_at = ?
+        WHERE task_id = ?
+      `).run(stringifyJson(detailResult), input.activity_ref, createdAt, input.task_id);
+        recordReadNotificationEvent(tx, {
+            scope: "worklist",
+            source_kind: "task_result",
+            source_ref: runResultId,
+            occurred_at: createdAt,
+        });
+        const runResultRow = tx
+            .prepare("SELECT * FROM run_results WHERE id = ?")
+            .get(runResultId);
+        const updatedTask = readTaskProjection(tx, input.task_id);
+        const taskDetail = readTaskDetailProjection(tx, input.task_id);
+        if (runResultRow === undefined || updatedTask === null || taskDetail === null) {
+            throw new Error("Run result transaction did not produce readable projections");
+        }
+        return {
+            run_result: mapRunResultRow(runResultRow),
+            task: updatedTask,
+            task_detail: taskDetail,
+        };
+    });
+}
+export function recordRunNeedsHumanResult(db, input) {
+    return withHostStoreTransaction(db, (tx) => {
+        const taskRow = tx
+            .prepare("SELECT * FROM tasks WHERE id = ?")
+            .get(input.task_id);
+        if (taskRow === undefined) {
+            throw new Error(`Task was not found: ${input.task_id}`);
+        }
+        if (taskRow.status !== "running" || taskRow.current_activity_ref !== input.activity_ref) {
+            throw new Error("Task is not running for this Run activity");
+        }
+        const createdAt = nowIso(input.now);
+        const runResultId = createRunResultId();
+        const sourceEventRef = createEventRef();
+        const opened = insertTaskBoundClarificationRound(tx, {
+            task_id: input.task_id,
+            activity_ref: input.activity_ref,
+            request_payload: input.result.clarification_request_payload,
+            opened_at: createdAt,
+        });
+        const resultJson = {
+            ...input.result,
+            clarification_thread_ref: opened.threadId,
+        };
+        const detailResult = {
+            latest_run_result_id: runResultId,
+            result_kind: "needs_human",
+            run_lineage: input.run_lineage,
+            clarification_thread_ref: opened.threadId,
+            summary: input.result.summary,
+            updated_at: createdAt,
+        };
+        if (input.result.changed_paths !== undefined) {
+            detailResult.changed_paths = input.result.changed_paths;
+        }
+        tx.prepare(`
+        INSERT INTO run_results (
+          id,
+          activity_ref,
+          task_id,
+          source_event_ref,
+          run_lineage_json,
+          result_kind,
+          result_json,
+          created_at
+        )
+        VALUES (?, ?, ?, ?, ?, 'needs_human', ?, ?)
+      `).run(runResultId, input.activity_ref, input.task_id, sourceEventRef, stringifyJson(input.run_lineage), stringifyJson(resultJson), createdAt);
+        tx.prepare(`
+        UPDATE tasks
+        SET status = 'pending',
+            current_activity_ref = NULL,
+            active_clarification_thread_id = ?,
+            latest_run_result_id = ?,
+            updated_at = ?
+        WHERE id = ?
+      `).run(opened.threadId, runResultId, createdAt, input.task_id);
+        tx.prepare(`
+        UPDATE task_details
+        SET result_json = ?,
+            frozen_contract_since_activity_ref = COALESCE(
+              frozen_contract_since_activity_ref,
+              ?
+            ),
+            updated_at = ?
+        WHERE task_id = ?
+      `).run(stringifyJson(detailResult), input.activity_ref, createdAt, input.task_id);
+        recordReadNotificationEvent(tx, {
+            scope: "worklist",
+            source_kind: "task_result",
+            source_ref: runResultId,
+            occurred_at: createdAt,
+        });
+        const runResultRow = tx
+            .prepare("SELECT * FROM run_results WHERE id = ?")
+            .get(runResultId);
+        const updatedTask = readTaskProjection(tx, input.task_id);
+        const taskDetail = readTaskDetailProjection(tx, input.task_id);
+        const thread = readClarificationThreadRow(tx, opened.threadId);
+        const round = readClarificationRoundRow(tx, opened.roundId);
+        const messages = tx
+            .prepare(`
+          SELECT *
+          FROM messages
+          WHERE id IN (?, ?)
+          ORDER BY created_at ASC, id ASC
+        `)
+            .all(opened.cardMessageId, opened.openingMessageId);
+        const cardMessage = messages.find((message) => message.id === opened.cardMessageId);
+        const openingMessage = messages.find((message) => message.id === opened.openingMessageId);
+        if (runResultRow === undefined ||
+            updatedTask === null ||
+            taskDetail === null ||
+            thread === null ||
+            round === null ||
+            cardMessage === undefined ||
+            openingMessage === undefined) {
+            throw new Error("Run needs-human transaction did not produce readable projections");
+        }
+        return {
+            run_result: mapRunResultRow(runResultRow),
+            task: updatedTask,
+            task_detail: taskDetail,
+            thread: mapClarificationThreadRow(thread),
+            round: mapClarificationRoundRow(round),
+            card_message: mapMessageRow(cardMessage, tx),
+            opening_message: mapMessageRow(openingMessage),
+        };
+    });
+}
+//# sourceMappingURL=run-recording.js.map

package/dist/collaboration-state/run-results.d.ts

@@ -0,0 +1,12 @@
+import { type ActivityRef, type RecoverySummaryId, type TaskId } from "@tutti/shared/ids";
+import type { CursorPage, RecoverySummaryProjection, RunResultProjection } from "@tutti/shared/schemas/api";
+import { type SqliteDatabase } from "../store/index.js";
+import type { CursorPageOptions, RecordRecoverySummaryInput, RecordRecoverySummaryResult } from "./types.js";
+import type { RunResultRow } from "./storage-types.js";
+export declare function mapRunResultRow(row: RunResultRow): RunResultProjection;
+export declare function readRunResultProjectionByActivityRef(db: SqliteDatabase, activityRef: ActivityRef): RunResultProjection | null;
+export declare function readTaskRunResultsPage(db: SqliteDatabase, taskId: TaskId, options?: CursorPageOptions): CursorPage<RunResultProjection> | null;
+export declare function recordRecoverySummary(db: SqliteDatabase, input: RecordRecoverySummaryInput): RecordRecoverySummaryResult;
+export declare function readRecoverySummariesPage(db: SqliteDatabase, options?: CursorPageOptions): CursorPage<RecoverySummaryProjection>;
+export declare function readRecoverySummaryProjection(db: SqliteDatabase, recoverySummaryId: RecoverySummaryId): RecoverySummaryProjection | null;
+//# sourceMappingURL=run-results.d.ts.map

package/dist/collaboration-state/run-results.js

@@ -0,0 +1,202 @@
+import { createRecoverySummaryId, } from "@tutti/shared/ids";
+import { withHostStoreTransaction } from "../store/index.js";
+import { clampLimit, decodeCursor, encodeCursor, nowIso, parseJson, stringifyJson } from "./serialization.js";
+import { readTaskProjection } from "./worklist.js";
+export function mapRunResultRow(row) {
+    const runLineage = parseJson(row.run_lineage_json, {
+        attempt: 1,
+        kind: "initial",
+    });
+    const base = {
+        id: row.id,
+        activity_ref: row.activity_ref,
+        task_id: row.task_id,
+        run_lineage: runLineage,
+        summary: "",
+        created_at: row.created_at,
+    };
+    const result = parseJson(row.result_json, {});
+    if (row.result_kind === "needs_human") {
+        return {
+            ...base,
+            result_kind: "needs_human",
+            summary: typeof result.summary === "string" ? result.summary : "",
+            clarification_thread_ref: typeof result.clarification_thread_ref === "string" ? result.clarification_thread_ref : "",
+        };
+    }
+    if (row.result_kind === "failed") {
+        return {
+            ...base,
+            result_kind: "failed",
+            summary: typeof result.summary === "string" ? result.summary : "",
+            error_code: typeof result.error_code === "string" ? result.error_code : "unknown",
+            retryable: typeof result.retryable === "boolean" ? result.retryable : false,
+        };
+    }
+    const projection = {
+        ...base,
+        result_kind: "finished",
+        outcome: result.outcome === "failed" ? "failed" : "completed",
+        summary: typeof result.summary === "string" ? result.summary : "",
+        checks: result.checks === "failed" || result.checks === "skipped" ? result.checks : "passed",
+        docs: result.docs === "checked_no_change" ||
+            result.docs === "not_checked" ||
+            result.docs === "sync_deferred"
+            ? result.docs
+            : "updated",
+    };
+    if (projection.checks === "skipped" &&
+        (result.skip_reason_code === "no_validation_command_found" ||
+            result.skip_reason_code === "project_has_no_test_setup" ||
+            result.skip_reason_code === "validation_not_applicable" ||
+            result.skip_reason_code === "command_prerequisite_missing" ||
+            result.skip_reason_code === "command_requires_external_service" ||
+            result.skip_reason_code === "command_requires_secret" ||
+            result.skip_reason_code === "command_requires_interactive_input" ||
+            result.skip_reason_code === "command_too_expensive_for_mvp" ||
+            result.skip_reason_code === "unsafe_command_blocked" ||
+            result.skip_reason_code === "known_failing_baseline")) {
+        projection.skip_reason_code = result.skip_reason_code;
+    }
+    if (typeof result.skip_reason_summary === "string") {
+        projection.skip_reason_summary = result.skip_reason_summary;
+    }
+    if (Array.isArray(result.external_side_effects)) {
+        projection.external_side_effects =
+            result.external_side_effects;
+    }
+    return projection;
+}
+export function readRunResultProjectionByActivityRef(db, activityRef) {
+    const row = db
+        .prepare(`
+        SELECT *
+        FROM run_results
+        WHERE activity_ref = ?
+      `)
+        .get(activityRef);
+    return row === undefined ? null : mapRunResultRow(row);
+}
+export function readTaskRunResultsPage(db, taskId, options = {}) {
+    if (readTaskProjection(db, taskId) === null) {
+        return null;
+    }
+    const limit = clampLimit(options.limit);
+    const cursor = decodeCursor(options.cursor);
+    const rows = cursor === null
+        ? db
+            .prepare(`
+              SELECT *
+              FROM run_results
+              WHERE task_id = ?
+              ORDER BY created_at DESC, id DESC
+              LIMIT ?
+            `)
+            .all(taskId, limit + 1)
+        : db
+            .prepare(`
+              SELECT *
+              FROM run_results
+              WHERE task_id = ?
+                AND (created_at < ? OR (created_at = ? AND id < ?))
+              ORDER BY created_at DESC, id DESC
+              LIMIT ?
+            `)
+            .all(taskId, cursor.created_at, cursor.created_at, cursor.id, limit + 1);
+    const hasMore = rows.length > limit;
+    const items = rows.slice(0, limit).map(mapRunResultRow);
+    const last = items.at(-1);
+    const page = {
+        has_more: hasMore,
+        limit,
+    };
+    if (hasMore && last !== undefined) {
+        page.next_cursor = encodeCursor({ created_at: last.created_at, id: last.id });
+    }
+    return { items, page };
+}
+function mapRecoverySummaryRow(row) {
+    const affectedActivities = parseJson(row.affected_activities_json, []);
+    return {
+        recovery_summary_id: row.id,
+        summary: row.summary,
+        affected_activities: affectedActivities,
+        affected_activity_count: affectedActivities.length,
+        created_at: row.created_at,
+    };
+}
+export function recordRecoverySummary(db, input) {
+    return withHostStoreTransaction(db, (tx) => {
+        const createdAt = nowIso(input.now);
+        const recoverySummaryId = createRecoverySummaryId();
+        tx.prepare(`
+        INSERT INTO recovery_summaries (
+          id,
+          affected_activities_json,
+          summary,
+          created_at
+        )
+        VALUES (?, ?, ?, ?)
+      `).run(recoverySummaryId, stringifyJson(input.affected_activities), input.summary, createdAt);
+        const row = tx
+            .prepare(`
+          SELECT *
+          FROM recovery_summaries
+          WHERE id = ?
+        `)
+            .get(recoverySummaryId);
+        if (row === undefined) {
+            throw new Error("Recovery summary transaction did not produce a readable projection");
+        }
+        return {
+            recovery_summary: mapRecoverySummaryRow(row),
+        };
+    });
+}
+export function readRecoverySummariesPage(db, options = {}) {
+    const limit = clampLimit(options.limit);
+    const cursor = decodeCursor(options.cursor);
+    const rows = cursor === null
+        ? db
+            .prepare(`
+              SELECT *
+              FROM recovery_summaries
+              ORDER BY created_at DESC, id DESC
+              LIMIT ?
+            `)
+            .all(limit + 1)
+        : db
+            .prepare(`
+              SELECT *
+              FROM recovery_summaries
+              WHERE created_at < ? OR (created_at = ? AND id < ?)
+              ORDER BY created_at DESC, id DESC
+              LIMIT ?
+            `)
+            .all(cursor.created_at, cursor.created_at, cursor.id, limit + 1);
+    const hasMore = rows.length > limit;
+    const items = rows.slice(0, limit).map(mapRecoverySummaryRow);
+    const last = items.at(-1);
+    const page = {
+        has_more: hasMore,
+        limit,
+    };
+    if (hasMore && last !== undefined) {
+        page.next_cursor = encodeCursor({
+            created_at: last.created_at,
+            id: last.recovery_summary_id,
+        });
+    }
+    return { items, page };
+}
+export function readRecoverySummaryProjection(db, recoverySummaryId) {
+    const row = db
+        .prepare(`
+        SELECT *
+        FROM recovery_summaries
+        WHERE id = ?
+      `)
+        .get(recoverySummaryId);
+    return row === undefined ? null : mapRecoverySummaryRow(row);
+}
+//# sourceMappingURL=run-results.js.map

package/dist/collaboration-state/scratchpad-source-state.d.ts

@@ -0,0 +1,46 @@
+import type { ActivityRef, ClarificationRoundRef, MessageId } from "@tutti/shared/ids";
+import type { SqliteDatabase } from "../store/index.js";
+export type ScratchpadMainChatCursor = {
+    created_at: string;
+    message_id: MessageId;
+};
+export type ScratchpadTaskCompileCursor = {
+    submitted_at: string;
+    round_id: ClarificationRoundRef;
+};
+export type ScratchpadSourceState = {
+    main_chat_cursor?: ScratchpadMainChatCursor;
+    task_compile_cursor?: ScratchpadTaskCompileCursor;
+    dirty_since?: string;
+    in_flight?: {
+        activity_ref: ActivityRef;
+        started_at: string;
+    };
+    backoff_until?: string;
+    last_completed_at?: string;
+    last_failed_at?: string;
+    updated_at?: string;
+};
+export type ScratchpadSourceCursorUpdate = {
+    main_chat_cursor?: ScratchpadMainChatCursor;
+    task_compile_cursor?: ScratchpadTaskCompileCursor;
+};
+export declare function readScratchpadSourceState(db: SqliteDatabase): ScratchpadSourceState;
+export declare function markScratchpadSourceDirty(db: SqliteDatabase, input?: {
+    now?: () => Date;
+}): ScratchpadSourceState;
+export declare function advanceScratchpadTaskCompileSourceCursor(db: SqliteDatabase, input: ScratchpadTaskCompileCursor & {
+    now?: () => Date;
+}): ScratchpadSourceState;
+export declare function markScratchpadRefreshStarted(db: SqliteDatabase, input: {
+    activityRef: ActivityRef;
+    now?: () => Date;
+}): ScratchpadSourceState;
+export declare function markScratchpadRefreshSucceeded(db: SqliteDatabase, input: ScratchpadSourceCursorUpdate & {
+    now?: () => Date;
+}): ScratchpadSourceState;
+export declare function markScratchpadRefreshFailed(db: SqliteDatabase, input?: {
+    backoffUntil?: string;
+    now?: () => Date;
+}): ScratchpadSourceState;
+//# sourceMappingURL=scratchpad-source-state.d.ts.map

package/dist/collaboration-state/scratchpad-source-state.js

@@ -0,0 +1,207 @@
+import { nowIso } from "./serialization.js";
+function mapScratchpadSourceStateRow(row) {
+    const state = {};
+    if (row === undefined) {
+        return state;
+    }
+    if (row.main_chat_cursor_created_at !== null && row.main_chat_cursor_message_id !== null) {
+        state.main_chat_cursor = {
+            created_at: row.main_chat_cursor_created_at,
+            message_id: row.main_chat_cursor_message_id,
+        };
+    }
+    if (row.task_compile_cursor_submitted_at !== null &&
+        row.task_compile_cursor_round_id !== null) {
+        state.task_compile_cursor = {
+            submitted_at: row.task_compile_cursor_submitted_at,
+            round_id: row.task_compile_cursor_round_id,
+        };
+    }
+    if (row.dirty_since !== null) {
+        state.dirty_since = row.dirty_since;
+    }
+    if (row.in_flight_activity_ref !== null && row.in_flight_started_at !== null) {
+        state.in_flight = {
+            activity_ref: row.in_flight_activity_ref,
+            started_at: row.in_flight_started_at,
+        };
+    }
+    if (row.backoff_until !== null) {
+        state.backoff_until = row.backoff_until;
+    }
+    if (row.last_completed_at !== null) {
+        state.last_completed_at = row.last_completed_at;
+    }
+    if (row.last_failed_at !== null) {
+        state.last_failed_at = row.last_failed_at;
+    }
+    state.updated_at = row.updated_at;
+    return state;
+}
+function isIsoAfter(left, right) {
+    return new Date(left).getTime() > new Date(right).getTime();
+}
+function nextDirtySinceForSourceChange(current, changedAt) {
+    if (current.in_flight === undefined) {
+        return current.dirty_since ?? changedAt;
+    }
+    if (current.dirty_since !== undefined &&
+        isIsoAfter(current.dirty_since, current.in_flight.started_at)) {
+        return current.dirty_since;
+    }
+    return changedAt;
+}
+function dirtySinceAfterRefreshSuccess(current) {
+    if (current.dirty_since !== undefined &&
+        current.in_flight !== undefined &&
+        isIsoAfter(current.dirty_since, current.in_flight.started_at)) {
+        return current.dirty_since;
+    }
+    return null;
+}
+function isTaskCompileCursorAfter(left, right) {
+    const submittedOrder = left.submitted_at.localeCompare(right.submitted_at);
+    if (submittedOrder !== 0) {
+        return submittedOrder > 0;
+    }
+    return left.round_id > right.round_id;
+}
+export function readScratchpadSourceState(db) {
+    const row = db
+        .prepare(`
+        SELECT
+          main_chat_cursor_created_at,
+          main_chat_cursor_message_id,
+          task_compile_cursor_submitted_at,
+          task_compile_cursor_round_id,
+          dirty_since,
+          in_flight_activity_ref,
+          in_flight_started_at,
+          last_completed_at,
+          last_failed_at,
+          backoff_until,
+          updated_at
+        FROM scratchpad_source_state
+        WHERE id = 'current'
+      `)
+        .get();
+    return mapScratchpadSourceStateRow(row);
+}
+export function markScratchpadSourceDirty(db, input = {}) {
+    const updatedAt = nowIso(input.now);
+    const dirtySince = nextDirtySinceForSourceChange(readScratchpadSourceState(db), updatedAt);
+    db.prepare(`
+      INSERT INTO scratchpad_source_state (
+        id,
+        dirty_since,
+        updated_at
+      )
+      VALUES ('current', ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        dirty_since = excluded.dirty_since,
+        updated_at = excluded.updated_at
+    `).run(dirtySince, updatedAt);
+    return readScratchpadSourceState(db);
+}
+export function advanceScratchpadTaskCompileSourceCursor(db, input) {
+    const current = readScratchpadSourceState(db);
+    const nextCursor = {
+        submitted_at: input.submitted_at,
+        round_id: input.round_id,
+    };
+    if (current.task_compile_cursor !== undefined &&
+        !isTaskCompileCursorAfter(nextCursor, current.task_compile_cursor)) {
+        return current;
+    }
+    const updatedAt = nowIso(input.now);
+    db.prepare(`
+      INSERT INTO scratchpad_source_state (
+        id,
+        task_compile_cursor_submitted_at,
+        task_compile_cursor_round_id,
+        updated_at
+      )
+      VALUES ('current', ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        task_compile_cursor_submitted_at = excluded.task_compile_cursor_submitted_at,
+        task_compile_cursor_round_id = excluded.task_compile_cursor_round_id,
+        updated_at = excluded.updated_at
+    `).run(nextCursor.submitted_at, nextCursor.round_id, updatedAt);
+    return readScratchpadSourceState(db);
+}
+export function markScratchpadRefreshStarted(db, input) {
+    const updatedAt = nowIso(input.now);
+    db.prepare(`
+      INSERT INTO scratchpad_source_state (
+        id,
+        in_flight_activity_ref,
+        in_flight_started_at,
+        updated_at
+      )
+      VALUES ('current', ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        in_flight_activity_ref = excluded.in_flight_activity_ref,
+        in_flight_started_at = excluded.in_flight_started_at,
+        updated_at = excluded.updated_at
+    `).run(input.activityRef, updatedAt, updatedAt);
+    return readScratchpadSourceState(db);
+}
+export function markScratchpadRefreshSucceeded(db, input) {
+    const updatedAt = nowIso(input.now);
+    const current = readScratchpadSourceState(db);
+    const mainChatCursor = input.main_chat_cursor ?? current.main_chat_cursor;
+    const taskCompileCursor = input.task_compile_cursor ?? current.task_compile_cursor;
+    const dirtySince = dirtySinceAfterRefreshSuccess(current);
+    db.prepare(`
+      INSERT INTO scratchpad_source_state (
+        id,
+        main_chat_cursor_created_at,
+        main_chat_cursor_message_id,
+        task_compile_cursor_submitted_at,
+        task_compile_cursor_round_id,
+        dirty_since,
+        in_flight_activity_ref,
+        in_flight_started_at,
+        last_completed_at,
+        backoff_until,
+        updated_at
+      )
+      VALUES ('current', ?, ?, ?, ?, ?, NULL, NULL, ?, NULL, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        main_chat_cursor_created_at = excluded.main_chat_cursor_created_at,
+        main_chat_cursor_message_id = excluded.main_chat_cursor_message_id,
+        task_compile_cursor_submitted_at = excluded.task_compile_cursor_submitted_at,
+        task_compile_cursor_round_id = excluded.task_compile_cursor_round_id,
+        dirty_since = excluded.dirty_since,
+        in_flight_activity_ref = NULL,
+        in_flight_started_at = NULL,
+        last_completed_at = excluded.last_completed_at,
+        backoff_until = NULL,
+        updated_at = excluded.updated_at
+    `).run(mainChatCursor?.created_at ?? null, mainChatCursor?.message_id ?? null, taskCompileCursor?.submitted_at ?? null, taskCompileCursor?.round_id ?? null, dirtySince, updatedAt, updatedAt);
+    return readScratchpadSourceState(db);
+}
+export function markScratchpadRefreshFailed(db, input = {}) {
+    const updatedAt = nowIso(input.now);
+    db.prepare(`
+      INSERT INTO scratchpad_source_state (
+        id,
+        dirty_since,
+        in_flight_activity_ref,
+        in_flight_started_at,
+        last_failed_at,
+        backoff_until,
+        updated_at
+      )
+      VALUES ('current', ?, NULL, NULL, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        dirty_since = COALESCE(scratchpad_source_state.dirty_since, excluded.dirty_since),
+        in_flight_activity_ref = NULL,
+        in_flight_started_at = NULL,
+        last_failed_at = excluded.last_failed_at,
+        backoff_until = excluded.backoff_until,
+        updated_at = excluded.updated_at
+    `).run(updatedAt, updatedAt, input.backoffUntil ?? null, updatedAt);
+    return readScratchpadSourceState(db);
+}
+//# sourceMappingURL=scratchpad-source-state.js.map

package/dist/collaboration-state/scratchpad.d.ts

@@ -0,0 +1,8 @@
+import type { ScratchpadProjection } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
+import type { ScratchpadSnapshotInput } from "./types.js";
+export declare function createEmptyScratchpadProjection(): ScratchpadProjection;
+export declare function upsertScratchpadProjection(db: SqliteDatabase, input: ScratchpadSnapshotInput): ScratchpadProjection;
+export declare function clearScratchpadProjection(db: SqliteDatabase): ScratchpadProjection;
+export declare function readScratchpadProjection(db: SqliteDatabase): ScratchpadProjection;
+//# sourceMappingURL=scratchpad.d.ts.map