@xfey/tutti 0.1.20 → 0.1.22

package/dist/server-shell/http/routes/project-api/project-timeline-projection.js

@@ -1,22 +1,24 @@
-import { spawnSync } from "node:child_process";
-import { providerUsageSourceMetadata, readProviderUsageBreakdownForAnchors, readProviderUsageModelSummariesForAnchors, readProviderUsageProjection, readProviderUsageSourceSummariesForAnchors, } from "../../../../provider-usage/index.js";
-import { readProjectTimelineEventItems } from "../../../../project-timeline/index.js";
-import { HOST_MAINLINE_BRANCH } from "./constants.js";
+import { readProviderUsageBreakdownForAnchors, readProviderUsageModelSummariesForAnchors, readProviderUsageProjection, readProviderUsageSourceSummariesForAnchors, } from "../../../../provider-usage/index.js";
+import { runGitRaw } from "../../../../workspace-ops/git.js";
 const TIMELINE_LIMIT = 50;
-const COMMIT_TIMELINE_LIMIT = 30;
+const TASK_ACCEPTED_TIMELINE_LIMIT = 50;
 const RUN_RESULT_TIMELINE_LIMIT = 50;
-const TASK_TIMELINE_LIMIT = 50;
-const CLARIFICATION_TIMELINE_LIMIT = 50;
-const RECOVERY_TIMELINE_LIMIT = 30;
-const DURABLE_EVENT_TIMELINE_LIMIT = 50;
+const CHECKPOINT_TIMELINE_LIMIT = 30;
 const RUN_USAGE_SOURCES = [
     "workspace_write_run",
     "follow_up_run",
     "pipeline_self_correction",
 ];
-const TASK_ADDED_USAGE_SOURCES = ["task_compile"];
-const CONTEXT_SYNC_USAGE_SOURCES = ["context_sync"];
-const REFERENCE_SUMMARY_USAGE_SOURCES = ["reference_summary_refresh"];
+const TASK_ACCEPTED_USAGE_SOURCES = ["task_compile"];
+const TRACE_CONSENSUS_LIMIT = 3;
+const TRACE_TASK_CHANGE_LIMIT = 2;
+const TRACE_CONTRACT_SCOPE_LIMIT = 5;
+const TRACE_CHANGED_PATH_LIMIT = 6;
+const TRACE_CHECKPOINT_ITEM_LIMIT = 5;
+const TRACE_GENERATED_FILE_LIMIT = 5;
+const TRACE_SOURCE_SNIPPET_LIMIT = 3;
+const TRACE_SOURCE_SNIPPET_BODY_LIMIT = 280;
+const TRACE_CHANGE_LINK_LIMIT = 3;
 function compareTimelineItemsByTimeDesc(left, right) {
     const leftTime = Date.parse(left.occurred_at);
     const rightTime = Date.parse(right.occurred_at);
@@ -25,62 +27,26 @@ function compareTimelineItemsByTimeDesc(left, right) {
         : right.occurred_at.localeCompare(left.occurred_at);
     return byTime === 0 ? right.id.localeCompare(left.id) : byTime;
 }
-function attachProviderUsageToItem(db, item, anchors, options = {}) {
-    const tokenUsage = readProviderUsageBreakdownForAnchors(db, anchors, options);
-    if (tokenUsage.event_count <= 0) {
-        return false;
-    }
-    item.token_usage = tokenUsage;
-    item.usage_sources = readProviderUsageSourceSummariesForAnchors(db, anchors, options);
-    item.usage_models = readProviderUsageModelSummariesForAnchors(db, anchors, options);
-    return true;
-}
-function pushConsumedProcedureUsageAnchors(consumed, sources, anchors) {
-    const hasAnchor = anchors.activity_ref !== undefined ||
-        anchors.workflow_ref !== undefined ||
-        anchors.task_id !== undefined;
-    if (!hasAnchor) {
-        return;
-    }
-    for (const source of sources) {
-        if (anchors.activity_ref !== undefined) {
-            consumed.push({ source, activity_ref: anchors.activity_ref });
-        }
-        if (anchors.workflow_ref !== undefined) {
-            consumed.push({ source, workflow_ref: anchors.workflow_ref });
-        }
-        if (anchors.task_id !== undefined) {
-            consumed.push({ source, task_id: anchors.task_id });
-        }
-    }
-}
-function isProcedureUsageConsumed(row, consumed) {
-    return consumed.some((anchor) => {
-        if (anchor.source !== row.source) {
-            return false;
-        }
-        if (anchor.activity_ref !== undefined && anchor.activity_ref !== row.activity_ref) {
-            return false;
-        }
-        if (anchor.workflow_ref !== undefined && anchor.workflow_ref !== row.workflow_ref) {
-            return false;
-        }
-        if (anchor.task_id !== undefined && anchor.task_id !== row.task_id) {
-            return false;
-        }
-        return true;
-    });
-}
-function runGit(args, cwd) {
-    const result = spawnSync("git", [...args], {
-        cwd,
-        encoding: "utf8",
-        shell: false,
-    });
-    if (result.status !== 0) {
-        return null;
-    }
-    return (result.stdout ?? "").trim();
+function emptyUsageOverview() {
+    const emptyBreakdown = {
+        input_tokens: 0,
+        cached_input_tokens: 0,
+        output_tokens: 0,
+        reasoning_output_tokens: 0,
+        total_tokens: 0,
+        event_count: 0,
+    };
+    return {
+        total_tokens: 0,
+        totals: { ...emptyBreakdown },
+        by_source: [],
+        by_model: [],
+        recent_windows: {
+            today: { ...emptyBreakdown },
+            last_7_days: { ...emptyBreakdown },
+            last_30_days: { ...emptyBreakdown },
+        },
+    };
 }
 function parseJsonObject(value) {
     try {
@@ -95,6 +61,9 @@ function parseJsonObject(value) {
     return {};
 }
 function parseJsonStringArray(value) {
+    if (value === null) {
+        return [];
+    }
     try {
         const parsed = JSON.parse(value);
         if (!Array.isArray(parsed)) {
@@ -106,89 +75,324 @@ function parseJsonStringArray(value) {
         return [];
     }
 }
-function readCommitTimelineItems(workspaceRoot) {
-    if (workspaceRoot === undefined) {
-        return [];
-    }
-    const output = runGit([
-        "log",
-        HOST_MAINLINE_BRANCH,
-        `--max-count=${COMMIT_TIMELINE_LIMIT}`,
-        "--date=iso-strict",
-        "--pretty=format:%H%x00%cI%x00%s",
-    ], workspaceRoot);
-    if (output === null || output.length === 0) {
-        return [];
-    }
-    return output
-        .split("\n")
-        .map((line) => {
-        const [oid, committedAt, subject] = line.split("\0");
-        if (oid === undefined || committedAt === undefined || subject === undefined) {
-            return null;
-        }
-        return {
-            id: `commit:${oid}`,
-            kind: "commit",
-            occurred_at: committedAt,
-            title: subject.trim() === "" ? "Mainline commit" : subject,
-            commit_oid: oid,
-            commit_short_oid: oid.slice(0, 12),
-            status: "completed",
-        };
-    })
-        .filter((item) => item !== null);
+function stringValue(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
 }
-function runResultStatus(row, result) {
-    if (row.result_kind === "needs_human") {
-        return "needs_human";
-    }
-    if (row.result_kind === "failed" || result.outcome === "failed") {
-        return "failed";
+function stringArrayValue(record, key) {
+    const value = record[key];
+    if (!Array.isArray(value)) {
+        return undefined;
     }
-    return "completed";
+    return value.filter((item) => typeof item === "string" && item.trim() !== "");
 }
-function runResultTitle(row, status) {
-    const taskTitle = row.task_title ?? "Task";
-    if (status === "needs_human") {
-        return `Needs input: ${taskTitle}`;
+function parseTaskContract(value) {
+    if (value === null) {
+        return { goal: "", scope: [] };
     }
-    if (status === "failed") {
-        return `Run failed: ${taskTitle}`;
+    const parsed = parseJsonObject(value);
+    return {
+        goal: stringValue(parsed, "goal") ?? "",
+        scope: stringArrayValue(parsed, "scope") ?? [],
+    };
+}
+function attachProviderUsageToItem(db, item, anchors, options = {}) {
+    const tokenUsage = readProviderUsageBreakdownForAnchors(db, anchors, options);
+    if (tokenUsage.event_count <= 0) {
+        return;
     }
-    return `Run completed: ${taskTitle}`;
+    item.token_usage = tokenUsage;
+    item.usage_sources = readProviderUsageSourceSummariesForAnchors(db, anchors, options);
+    item.usage_models = readProviderUsageModelSummariesForAnchors(db, anchors, options);
 }
-function stringValue(record, key) {
-    const value = record[key];
-    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+function worklistTaskLink(taskId) {
+    return {
+        kind: "worklist_task",
+        label: "Open Worklist Task",
+        task_id: taskId,
+    };
 }
-function promotionCommit(result) {
-    const promotion = result.promotion;
-    if (typeof promotion !== "object" || promotion === null || Array.isArray(promotion)) {
-        return undefined;
-    }
-    return stringValue(promotion, "commit_oid");
+function chatMessageLink(messageId) {
+    return {
+        kind: "chat_message",
+        label: "Open in Chat",
+        message_id: messageId,
+    };
 }
-function runResultMeta(result) {
-    const meta = [];
-    const checks = stringValue(result, "checks");
-    const docs = stringValue(result, "docs");
-    const promotion = result.promotion;
-    if (checks !== undefined) {
-        meta.push(`checks: ${checks}`);
+function authorLabel(row) {
+    if (row.author_display_name !== null && row.author_display_name.trim() !== "") {
+        return row.author_display_name;
     }
-    if (docs !== undefined) {
-        meta.push(`docs: ${docs}`);
+    if (row.author_kind === "agent") {
+        return "Tutti";
     }
-    if (typeof promotion === "object" && promotion !== null && !Array.isArray(promotion)) {
-        const promotionStatus = stringValue(promotion, "status");
-        if (promotionStatus !== undefined) {
-            meta.push(`promotion: ${promotionStatus}`);
-        }
+    if (row.author_kind === "system") {
+        return "System";
+    }
+    return "Member";
+}
+function truncateSnippetBody(value) {
+    const trimmed = value.trim();
+    if (trimmed.length <= TRACE_SOURCE_SNIPPET_BODY_LIMIT) {
+        return trimmed;
     }
-    return meta;
+    return `${trimmed.slice(0, TRACE_SOURCE_SNIPPET_BODY_LIMIT - 3)}...`;
+}
+function readReceiptSourceCount(db, workflowRef) {
+    const row = db
+        .prepare(`
+        SELECT COUNT(*) AS source_count
+        FROM scratchpad_receipt_sources
+        WHERE workflow_ref = ?
+      `)
+        .get(workflowRef);
+    return row?.source_count ?? 0;
+}
+function readReceiptSourceSnippets(db, workflowRef) {
+    const rows = db
+        .prepare(`
+        SELECT
+          messages.id AS message_id,
+          messages.author_kind,
+          messages.author_display_name,
+          messages.body,
+          messages.created_at
+        FROM scratchpad_receipt_sources
+        JOIN messages ON messages.id = scratchpad_receipt_sources.message_id
+        WHERE scratchpad_receipt_sources.workflow_ref = ?
+        ORDER BY scratchpad_receipt_sources.created_at ASC, scratchpad_receipt_sources.message_id ASC
+        LIMIT ${TRACE_SOURCE_SNIPPET_LIMIT}
+      `)
+        .all(workflowRef);
+    return rows.map((source) => ({
+        message_id: source.message_id,
+        author: authorLabel(source),
+        body: truncateSnippetBody(source.body),
+        created_at: source.created_at,
+    }));
+}
+function clarificationChatLink(messageId) {
+    return {
+        kind: "chat_message",
+        label: "Open clarification in Chat",
+        message_id: messageId,
+    };
+}
+function readClarificationAnswerSnippets(db, submittedRefsJson) {
+    const submittedRefs = parseJsonStringArray(submittedRefsJson);
+    if (submittedRefs.length === 0) {
+        return { answer_count: 0, answers: [] };
+    }
+    const readMessage = db.prepare(`
+      SELECT
+        id AS message_id,
+        author_kind,
+        author_display_name,
+        body,
+        created_at
+      FROM messages
+      WHERE id = ?
+        AND message_kind = 'user_text'
+        AND author_kind = 'human'
+      LIMIT 1
+    `);
+    const answers = submittedRefs.flatMap((messageId) => {
+        const row = readMessage.get(messageId);
+        return row === undefined ? [] : [row];
+    });
+    const visibleAnswers = answers.slice(0, TRACE_SOURCE_SNIPPET_LIMIT).map((answer) => ({
+        message_id: answer.message_id,
+        author: authorLabel(answer),
+        body: truncateSnippetBody(answer.body),
+        created_at: answer.created_at,
+    }));
+    return {
+        answer_count: answers.length,
+        answers: visibleAnswers,
+    };
+}
+function clarificationTraceFromRow(db, row) {
+    const payload = parseJsonObject(row.request_payload_json);
+    const answers = readClarificationAnswerSnippets(db, row.submitted_message_refs_json);
+    const visibleAnswers = answers.answers;
+    const title = stringValue(payload, "title");
+    const summary = stringValue(payload, "summary");
+    const request = stringValue(payload, "request");
+    const clarification = {
+        ...(title === undefined ? {} : { title }),
+        ...(summary === undefined ? {} : { summary }),
+        ...(request === undefined ? {} : { request }),
+        status: row.round_status === "sealed" ? "resolved" : "active",
+        answer_count: answers.answer_count,
+        ...(visibleAnswers.length === 0 ? {} : { answers: visibleAnswers }),
+    };
+    const firstAnswer = visibleAnswers[0]?.body;
+    return {
+        clarification,
+        links: [clarificationChatLink(row.card_message_id)],
+        ...(firstAnswer === undefined
+            ? summary === undefined
+                ? {}
+                : { decision_summary: summary }
+            : { decision_summary: firstAnswer }),
+    };
+}
+function readLatestTaskCompileClarificationTrace(db, workflowRef) {
+    const row = db
+        .prepare(`
+        SELECT
+          clarification_threads.id AS thread_id,
+          clarification_threads.status AS thread_status,
+          clarification_rounds.id AS round_id,
+          clarification_rounds.status AS round_status,
+          clarification_rounds.request_payload_json,
+          clarification_rounds.card_message_id,
+          clarification_rounds.submitted_message_refs_json,
+          clarification_rounds.submitted_at,
+          clarification_rounds.updated_at
+        FROM clarification_rounds
+        JOIN clarification_threads
+          ON clarification_threads.id = clarification_rounds.clarification_thread_id
+        WHERE clarification_threads.owner_kind = 'task_compile'
+          AND clarification_threads.owner_workflow_ref = ?
+          AND clarification_rounds.status = 'sealed'
+          AND clarification_rounds.submitted_at IS NOT NULL
+        ORDER BY clarification_rounds.round_index DESC, clarification_rounds.submitted_at DESC
+        LIMIT 1
+      `)
+        .get(workflowRef);
+    return row === undefined ? undefined : clarificationTraceFromRow(db, row);
 }
-function readTaskTimelineItems(db, consumedProcedureUsageAnchors) {
+function readLatestClarificationTraceByThread(db, threadId) {
+    const row = db
+        .prepare(`
+        SELECT
+          clarification_threads.id AS thread_id,
+          clarification_threads.status AS thread_status,
+          clarification_rounds.id AS round_id,
+          clarification_rounds.status AS round_status,
+          clarification_rounds.request_payload_json,
+          clarification_rounds.card_message_id,
+          clarification_rounds.submitted_message_refs_json,
+          clarification_rounds.submitted_at,
+          clarification_rounds.updated_at
+        FROM clarification_threads
+        JOIN clarification_rounds
+          ON clarification_rounds.clarification_thread_id = clarification_threads.id
+        WHERE clarification_threads.id = ?
+        ORDER BY
+          CASE
+            WHEN clarification_rounds.id = clarification_threads.current_round_id THEN 0
+            ELSE 1
+          END,
+          clarification_rounds.round_index DESC,
+          clarification_rounds.updated_at DESC
+        LIMIT 1
+      `)
+        .get(threadId);
+    return row === undefined ? undefined : clarificationTraceFromRow(db, row);
+}
+function readLatestResolvedTaskClarificationTrace(db, taskId, throughCreatedAt) {
+    const row = db
+        .prepare(`
+        SELECT
+          clarification_threads.id AS thread_id,
+          clarification_threads.status AS thread_status,
+          clarification_rounds.id AS round_id,
+          clarification_rounds.status AS round_status,
+          clarification_rounds.request_payload_json,
+          clarification_rounds.card_message_id,
+          clarification_rounds.submitted_message_refs_json,
+          clarification_rounds.submitted_at,
+          clarification_rounds.updated_at
+        FROM clarification_rounds
+        JOIN clarification_threads
+          ON clarification_threads.id = clarification_rounds.clarification_thread_id
+        WHERE clarification_threads.owner_kind = 'task'
+          AND clarification_threads.owner_task_id = ?
+          AND clarification_threads.status = 'closed'
+          AND clarification_rounds.status = 'sealed'
+          AND clarification_rounds.submitted_at IS NOT NULL
+          AND clarification_rounds.submitted_at <= ?
+        ORDER BY clarification_rounds.submitted_at DESC, clarification_rounds.round_index DESC
+        LIMIT 1
+      `)
+        .get(taskId, throughCreatedAt);
+    return row === undefined ? undefined : clarificationTraceFromRow(db, row);
+}
+function taskAcceptedTraceCard(db, row) {
+    const consensus = parseJsonStringArray(row.receipt_current_consensus_json);
+    const taskChanges = parseJsonStringArray(row.receipt_task_changes_json);
+    const contract = parseTaskContract(row.contract_json);
+    const sourceCount = readReceiptSourceCount(db, row.created_from_workflow_ref);
+    const sourceSnippets = sourceCount === 0 ? [] : readReceiptSourceSnippets(db, row.created_from_workflow_ref);
+    const clarification = readLatestTaskCompileClarificationTrace(db, row.created_from_workflow_ref);
+    const decisions = [
+        ...consensus.slice(0, TRACE_CONSENSUS_LIMIT).map((summary) => ({
+            title: "Consensus",
+            summary,
+            source: "scratchpad",
+        })),
+        ...taskChanges.slice(0, TRACE_TASK_CHANGE_LIMIT).map((summary) => ({
+            title: "Task change",
+            summary,
+            source: "scratchpad",
+        })),
+        ...(clarification?.decision_summary === undefined
+            ? []
+            : [
+                {
+                    title: "Clarified decision",
+                    summary: clarification.decision_summary,
+                    source: "clarification",
+                },
+            ]),
+    ];
+    const scope = contract.scope.slice(0, TRACE_CONTRACT_SCOPE_LIMIT);
+    const hasReceipt = row.receipt_topic !== null ||
+        row.receipt_background_summary !== null ||
+        consensus.length > 0 ||
+        taskChanges.length > 0;
+    return {
+        tone: "success",
+        summary: row.summary,
+        origin: {
+            title: row.receipt_topic !== null && row.receipt_topic.trim() !== ""
+                ? row.receipt_topic
+                : row.title,
+            ...(row.receipt_background_summary === null
+                ? {}
+                : { summary: row.receipt_background_summary }),
+            ...(sourceCount === 0
+                ? {
+                    unavailable_reason: hasReceipt
+                        ? "Source message refs unavailable; showing Scratchpad summary."
+                        : "Scratchpad receipt unavailable.",
+                }
+                : {
+                    source_count: sourceCount,
+                    snippets: sourceSnippets,
+                }),
+        },
+        ...(decisions.length === 0 ? {} : { decisions }),
+        ...(clarification === undefined ? {} : { clarification: clarification.clarification }),
+        contract: {
+            goal: contract.goal,
+            scope,
+            ...(contract.scope.length > scope.length ? { truncated: true } : {}),
+        },
+        links: [
+            worklistTaskLink(row.id),
+            ...sourceSnippets.map((snippet, index) => ({
+                kind: "chat_message",
+                label: index === 0 ? "Open source in Chat" : `Open source ${index + 1} in Chat`,
+                message_id: snippet.message_id,
+            })),
+            ...(clarification?.links ?? []),
+        ],
+    };
+}
+function readTaskAcceptedTimelineItems(db) {
     if (db === undefined) {
         return [];
     }
@@ -198,39 +402,37 @@ function readTaskTimelineItems(db, consumedProcedureUsageAnchors) {
           tasks.id,
           tasks.title,
           tasks.summary,
-          tasks.status,
           tasks.created_from_workflow_ref,
           tasks.created_at,
-          task_modules.name AS module_name
+          task_modules.name AS module_name,
+          task_details.contract_json,
+          scratchpad_receipts.topic AS receipt_topic,
+          scratchpad_receipts.background_summary AS receipt_background_summary,
+          scratchpad_receipts.current_consensus_json AS receipt_current_consensus_json,
+          scratchpad_receipts.task_changes_json AS receipt_task_changes_json
         FROM tasks
         LEFT JOIN task_modules ON task_modules.id = tasks.module_id
+        LEFT JOIN task_details ON task_details.task_id = tasks.id
+        LEFT JOIN scratchpad_receipts
+          ON scratchpad_receipts.workflow_ref = tasks.created_from_workflow_ref
         ORDER BY tasks.created_at DESC, tasks.id DESC
-        LIMIT ${TASK_TIMELINE_LIMIT}
+        LIMIT ${TASK_ACCEPTED_TIMELINE_LIMIT}
       `)
         .all();
     return rows.map((row) => {
-        const meta = [`status: ${row.status}`];
-        if (row.module_name !== null && row.module_name.trim() !== "") {
-            meta.unshift(`module: ${row.module_name}`);
-        }
         const item = {
-            id: `task:${row.id}`,
-            kind: "procedure",
+            id: `task_accepted:${row.id}`,
+            kind: "task_accepted",
             occurred_at: row.created_at,
-            title: `Task added: ${row.title}`,
+            title: `Task accepted: ${row.title}`,
             summary: row.summary,
             task_id: row.id,
             task_title: row.title,
             workflow_ref: row.created_from_workflow_ref,
             status: "completed",
-            meta,
+            trace_card: taskAcceptedTraceCard(db, row),
         };
-        const anchors = { workflow_ref: row.created_from_workflow_ref };
-        if (attachProviderUsageToItem(db, item, anchors, {
-            sources: TASK_ADDED_USAGE_SOURCES,
-        })) {
-            pushConsumedProcedureUsageAnchors(consumedProcedureUsageAnchors, TASK_ADDED_USAGE_SOURCES, anchors);
-        }
+        attachProviderUsageToItem(db, item, { workflow_ref: row.created_from_workflow_ref }, { sources: TASK_ACCEPTED_USAGE_SOURCES });
         return item;
     });
 }
@@ -244,414 +446,404 @@ function readRunResultTimelineRows(db) {
           run_results.result_kind,
           run_results.result_json,
           run_results.created_at,
-          tasks.title AS task_title
+          tasks.title AS task_title,
+          task_details.contract_json
         FROM run_results
         LEFT JOIN tasks ON tasks.id = run_results.task_id
+        LEFT JOIN task_details ON task_details.task_id = run_results.task_id
         ORDER BY run_results.created_at DESC, run_results.id DESC
         LIMIT ${RUN_RESULT_TIMELINE_LIMIT}
       `)
         .all();
 }
-function readRunTimelineItems(db, rows) {
-    if (db === undefined) {
-        return [];
+function runUpdateState(row, result) {
+    if (row.result_kind === "needs_human") {
+        return "needs_input";
     }
-    return rows.map((row) => {
-        const result = parseJsonObject(row.result_json);
-        const status = runResultStatus(row, result);
-        const commitOid = promotionCommit(result);
-        const item = {
-            id: `run:${row.id}`,
-            kind: "run",
-            occurred_at: row.created_at,
-            title: runResultTitle(row, status),
-            task_id: row.task_id,
-            activity_ref: row.activity_ref,
-            status,
-            meta: runResultMeta(result),
-        };
-        const summary = stringValue(result, "summary");
-        if (summary !== undefined) {
-            item.summary = summary;
+    if (row.result_kind === "failed" || result.outcome === "failed") {
+        return "failed";
+    }
+    return "completed";
+}
+function timelineStatusForUpdate(updateState) {
+    if (updateState === "needs_input") {
+        return "needs_human";
+    }
+    if (updateState === "failed") {
+        return "failed";
+    }
+    return "completed";
+}
+function runUpdateTitle(row, updateState) {
+    const taskTitle = row.task_title ?? "Task";
+    if (updateState === "needs_input") {
+        return `Task needs input: ${taskTitle}`;
+    }
+    if (updateState === "failed") {
+        return `Task failed: ${taskTitle}`;
+    }
+    return `Task completed: ${taskTitle}`;
+}
+function traceToneForUpdate(updateState) {
+    if (updateState === "needs_input") {
+        return "warning";
+    }
+    if (updateState === "failed") {
+        return "error";
+    }
+    return "success";
+}
+function gitChangeStatus(status) {
+    if (status.startsWith("R")) {
+        return "renamed";
+    }
+    switch (status) {
+        case "A":
+            return "added";
+        case "M":
+            return "modified";
+        case "D":
+            return "deleted";
+        default:
+            return "unknown";
+    }
+}
+function isSafeRepoRelativePath(path) {
+    return (path.trim() !== "" &&
+        !path.startsWith("/") &&
+        !path.includes("\0") &&
+        !path.split("/").includes(".."));
+}
+function promotedCommitOid(result) {
+    const promotion = result.promotion;
+    if (typeof promotion !== "object" || promotion === null || Array.isArray(promotion)) {
+        return undefined;
+    }
+    const promotionRecord = promotion;
+    if (promotionRecord.status !== "promoted") {
+        return undefined;
+    }
+    return stringValue(promotionRecord, "commit_oid");
+}
+function readPromotedCommitChanges(workspaceRoot, commitOid) {
+    if (workspaceRoot === undefined || commitOid === undefined) {
+        return undefined;
+    }
+    const result = runGitRaw(["show", "--name-status", "--find-renames", "-z", "--format=", commitOid, "--"], workspaceRoot, 1024 * 1024);
+    if (result.status !== 0) {
+        return undefined;
+    }
+    const fields = result.stdout.toString("utf8").split("\0").filter((field) => field !== "");
+    const changes = [];
+    for (let index = 0; index < fields.length;) {
+        const status = fields[index];
+        if (status === undefined) {
+            break;
         }
-        if (row.task_title !== null && row.task_title.trim() !== "") {
-            item.task_title = row.task_title;
+        if (status.startsWith("R")) {
+            const previousPath = fields[index + 1];
+            const nextPath = fields[index + 2];
+            index += 3;
+            if (previousPath !== undefined &&
+                nextPath !== undefined &&
+                isSafeRepoRelativePath(previousPath) &&
+                isSafeRepoRelativePath(nextPath)) {
+                changes.push({
+                    status: "renamed",
+                    path: nextPath,
+                    previous_path: previousPath,
+                });
+            }
+            continue;
         }
-        if (commitOid !== undefined) {
-            item.commit_oid = commitOid;
-            item.commit_short_oid = commitOid.slice(0, 12);
+        const path = fields[index + 1];
+        index += 2;
+        if (path === undefined || !isSafeRepoRelativePath(path)) {
+            continue;
         }
-        const tokenUsage = readProviderUsageBreakdownForAnchors(db, {
-            activity_ref: row.activity_ref,
-            run_result_id: row.id,
-        }, {
-            sources: RUN_USAGE_SOURCES,
+        changes.push({
+            status: gitChangeStatus(status),
+            path,
         });
-        if (tokenUsage.event_count > 0) {
-            item.token_usage = tokenUsage;
-            item.usage_sources = readProviderUsageSourceSummariesForAnchors(db, {
-                activity_ref: row.activity_ref,
-                run_result_id: row.id,
-            }, {
-                sources: RUN_USAGE_SOURCES,
-            });
-            item.usage_models = readProviderUsageModelSummariesForAnchors(db, {
-                activity_ref: row.activity_ref,
-                run_result_id: row.id,
-            }, {
-                sources: RUN_USAGE_SOURCES,
-            });
-        }
-        return item;
-    });
+    }
+    return changes;
 }
-function checksStatus(value) {
-    if (value === "passed") {
-        return "completed";
+function changesTrace(result, workspaceRoot) {
+    const changedPaths = stringArrayValue(result, "changed_paths");
+    const commitChanges = readPromotedCommitChanges(workspaceRoot, promotedCommitOid(result));
+    const changeItems = commitChanges ??
+        changedPaths?.filter(isSafeRepoRelativePath).map((path) => ({
+            status: "unknown",
+            path,
+        }));
+    if (changeItems === undefined) {
+        return undefined;
     }
-    if (value === "failed") {
-        return "failed";
+    const visibleChanges = changeItems.slice(0, TRACE_CHANGED_PATH_LIMIT);
+    return {
+        items: visibleChanges,
+        total_count: changeItems.length,
+        truncated: changeItems.length > visibleChanges.length,
+    };
+}
+function changeLinks(changes) {
+    if (changes === undefined) {
+        return [];
     }
-    if (value === "skipped") {
-        return "skipped";
+    return changes.items
+        .filter((change) => change.status !== "deleted")
+        .slice(0, TRACE_CHANGE_LINK_LIMIT)
+        .map((change, index) => ({
+        kind: "repo_path",
+        label: index === 0 ? "Open changed file" : `Open changed file ${index + 1}`,
+        path: change.path,
+    }));
+}
+function verificationTrace(result) {
+    const checks = result.checks;
+    if (checks !== "passed" && checks !== "failed" && checks !== "skipped") {
+        return undefined;
     }
-    return undefined;
+    const skipReasonCode = stringValue(result, "skip_reason_code");
+    const skipReasonSummary = stringValue(result, "skip_reason_summary");
+    return {
+        checks,
+        ...(skipReasonCode === undefined ? {} : { skip_reason_code: skipReasonCode }),
+        ...(skipReasonSummary === undefined ? {} : { skip_reason_summary: skipReasonSummary }),
+    };
 }
-function readChecksTimelineItems(rows) {
-    if (rows.length === 0) {
+function promotionTrace(result) {
+    const promotion = result.promotion;
+    if (typeof promotion !== "object" || promotion === null || Array.isArray(promotion)) {
+        return undefined;
+    }
+    const promotionRecord = promotion;
+    const status = promotionRecord.status;
+    if (status !== "promoted" && status !== "not_promoted" && status !== "not_attempted") {
+        return undefined;
+    }
+    const commitOid = stringValue(promotionRecord, "commit_oid");
+    const summary = stringValue(promotionRecord, "summary");
+    const reasonCode = stringValue(promotionRecord, "reason_code");
+    return {
+        status,
+        ...(commitOid === undefined
+            ? {}
+            : { commit_oid: commitOid, commit_short_oid: commitOid.slice(0, 12) }),
+        ...(summary === undefined ? {} : { summary }),
+        ...(reasonCode === undefined ? {} : { reason_code: reasonCode }),
+    };
+}
+function runUpdateTraceCard(db, row, result, updateState, workspaceRoot) {
+    const contract = parseTaskContract(row.contract_json);
+    const summary = stringValue(result, "summary") ?? "";
+    const errorCode = stringValue(result, "error_code");
+    const changes = changesTrace(result, workspaceRoot);
+    const verification = verificationTrace(result);
+    const promotion = promotionTrace(result);
+    const clarificationThreadRef = stringValue(result, "clarification_thread_ref");
+    const clarification = updateState === "needs_input" && clarificationThreadRef !== undefined
+        ? readLatestClarificationTraceByThread(db, clarificationThreadRef)
+        : updateState === "completed" || updateState === "failed"
+            ? readLatestResolvedTaskClarificationTrace(db, row.task_id, row.created_at)
+            : undefined;
+    return {
+        tone: traceToneForUpdate(updateState),
+        summary,
+        result: {
+            summary,
+            ...(errorCode === undefined ? {} : { error_code: errorCode }),
+        },
+        contract: {
+            goal: contract.goal,
+            scope: contract.scope.slice(0, TRACE_CONTRACT_SCOPE_LIMIT),
+            ...(contract.scope.length > TRACE_CONTRACT_SCOPE_LIMIT ? { truncated: true } : {}),
+        },
+        ...(changes === undefined ? {} : { changes }),
+        ...(verification === undefined ? {} : { verification }),
+        ...(promotion === undefined ? {} : { promotion }),
+        ...(clarification === undefined ? {} : { clarification: clarification.clarification }),
+        links: [
+            worklistTaskLink(row.task_id),
+            ...(clarification?.links ?? []),
+            ...changeLinks(changes),
+        ],
+    };
+}
+function readTaskUpdateTimelineItems(db, rows, workspaceRoot) {
+    if (db === undefined) {
         return [];
     }
-    return rows.flatMap((row) => {
+    return rows.map((row) => {
         const result = parseJsonObject(row.result_json);
-        const checks = stringValue(result, "checks");
-        const status = checksStatus(checks);
-        if (checks === undefined || status === undefined) {
-            return [];
-        }
-        const taskTitle = row.task_title ?? "Task";
+        const updateState = runUpdateState(row, result);
+        const status = timelineStatusForUpdate(updateState);
         const item = {
-            id: `checks:${row.id}`,
-            kind: "checks",
+            id: `task_update:${row.id}`,
+            kind: "task_update",
             occurred_at: row.created_at,
-            title: `Checks ${checks}: ${taskTitle}`,
+            title: runUpdateTitle(row, updateState),
             task_id: row.task_id,
             activity_ref: row.activity_ref,
+            run_result_id: row.id,
             status,
-            meta: [`run result: ${row.id}`],
+            update_state: updateState,
+            trace_card: runUpdateTraceCard(db, row, result, updateState, workspaceRoot),
         };
         if (row.task_title !== null && row.task_title.trim() !== "") {
             item.task_title = row.task_title;
         }
-        const summary = stringValue(result, "skip_reason_summary") ??
-            (checks === "skipped" ? stringValue(result, "skip_reason_code") : undefined);
+        const summary = stringValue(result, "summary");
         if (summary !== undefined) {
             item.summary = summary;
         }
-        return [item];
+        attachProviderUsageToItem(db, item, { activity_ref: row.activity_ref, run_result_id: row.id }, { sources: RUN_USAGE_SOURCES });
+        return item;
     });
 }
-function usageBreakdownFromTimelineRow(row) {
-    return {
-        input_tokens: row.input_tokens ?? 0,
-        cached_input_tokens: row.cached_input_tokens ?? 0,
-        output_tokens: row.output_tokens ?? 0,
-        reasoning_output_tokens: row.reasoning_output_tokens ?? 0,
-        total_tokens: row.total_tokens ?? 0,
-        event_count: row.event_count ?? 0,
-    };
-}
-function readProcedureUsageTimelineItems(db, consumedProcedureUsageAnchors) {
-    if (db === undefined) {
-        return [];
+function parseCheckpointFeedback(refsJson) {
+    const refs = parseJsonObject(refsJson);
+    const feedback = refs.worklist_feedback;
+    if (typeof feedback !== "object" || feedback === null || Array.isArray(feedback)) {
+        return null;
     }
-    const rows = db
-        .prepare(`
-        SELECT
-          source,
-          activity_ref,
-          workflow_ref,
-          task_id,
-          MAX(recorded_at) AS occurred_at,
-          COALESCE(SUM(input_tokens), 0) AS input_tokens,
-          COALESCE(SUM(cached_input_tokens), 0) AS cached_input_tokens,
-          COALESCE(SUM(output_tokens), 0) AS output_tokens,
-          COALESCE(SUM(reasoning_output_tokens), 0) AS reasoning_output_tokens,
-          COALESCE(SUM(total_tokens), 0) AS total_tokens,
-          COUNT(*) AS event_count
-        FROM provider_usage_events
-        WHERE
-          (activity_ref IS NOT NULL OR workflow_ref IS NOT NULL) AND
-          source NOT IN ('workspace_write_run', 'follow_up_run', 'pipeline_self_correction')
-        GROUP BY source, activity_ref, workflow_ref, task_id
-        ORDER BY occurred_at DESC
-        LIMIT 50
-      `)
-        .all();
-    return rows
-        .filter((row) => !isProcedureUsageConsumed(row, consumedProcedureUsageAnchors))
-        .map((row) => {
-        const source = providerUsageSourceMetadata(row.source);
-        const anchor = row.activity_ref ?? row.workflow_ref ?? row.source;
-        const item = {
-            id: `procedure:${anchor}:${row.source}`,
-            kind: "procedure",
-            occurred_at: row.occurred_at,
-            title: source.label,
-            status: "completed",
-            token_usage: usageBreakdownFromTimelineRow(row),
-            usage_sources: [
-                {
-                    source: row.source,
-                    ...source,
-                    ...usageBreakdownFromTimelineRow(row),
-                },
-            ],
-            meta: [`category: ${source.category}`],
-        };
-        if (row.activity_ref !== null) {
-            item.activity_ref = row.activity_ref;
-        }
-        if (row.workflow_ref !== null) {
-            item.workflow_ref = row.workflow_ref;
+    const record = feedback;
+    const status = record.status;
+    const counters = record.counters;
+    const rawItems = record.items;
+    if ((status !== "completed" && status !== "failed") ||
+        typeof counters !== "object" ||
+        counters === null ||
+        Array.isArray(counters) ||
+        !Array.isArray(rawItems)) {
+        return null;
+    }
+    const counterRecord = counters;
+    const parsedItems = rawItems.flatMap((item) => {
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+            return [];
         }
-        if (row.task_id !== null) {
-            item.task_id = row.task_id;
+        const itemRecord = item;
+        if (typeof itemRecord.task_id !== "string" ||
+            typeof itemRecord.title !== "string" ||
+            (itemRecord.status !== "done" && itemRecord.status !== "failed")) {
+            return [];
         }
-        item.usage_models = readProviderUsageModelSummariesForAnchors(db, {
-            ...(row.activity_ref === null ? {} : { activity_ref: row.activity_ref }),
-            ...(row.workflow_ref === null ? {} : { workflow_ref: row.workflow_ref }),
-            ...(row.task_id === null ? {} : { task_id: row.task_id }),
-        }, { sources: [row.source] });
-        return item;
+        return [
+            {
+                task_id: itemRecord.task_id,
+                title: itemRecord.title,
+                status: itemRecord.status,
+                summary: typeof itemRecord.summary === "string" ? itemRecord.summary : "",
+            },
+        ];
     });
+    const rawGeneratedFiles = record.generated_files;
+    const generatedFiles = Array.isArray(rawGeneratedFiles)
+        ? rawGeneratedFiles.flatMap((file) => {
+            if (typeof file !== "object" || file === null || Array.isArray(file)) {
+                return [];
+            }
+            const fileRecord = file;
+            if (typeof fileRecord.path !== "string" || typeof fileRecord.name !== "string") {
+                return [];
+            }
+            return [{ path: fileRecord.path, name: fileRecord.name }];
+        })
+        : undefined;
+    const finalNote = stringValue(record, "final_note");
+    return {
+        status,
+        title: stringValue(record, "title") ?? "Worklist checkpoint",
+        counters: {
+            completed: typeof counterRecord.completed === "number" ? counterRecord.completed : 0,
+            failed: typeof counterRecord.failed === "number" ? counterRecord.failed : 0,
+            remaining: typeof counterRecord.remaining === "number" ? counterRecord.remaining : 0,
+        },
+        items: parsedItems,
+        ...(finalNote === undefined ? {} : { final_note: finalNote }),
+        ...(generatedFiles === undefined || generatedFiles.length === 0
+            ? {}
+            : { generated_files: generatedFiles }),
+        ...(typeof record.primary_task_id === "string"
+            ? { primary_task_id: record.primary_task_id }
+            : {}),
+    };
 }
-function clarificationOwnerLabel(row) {
-    if (row.owner_kind === "task") {
-        return row.task_title ?? "Task";
-    }
-    return "Worklist planning";
-}
-function clarificationSummary(row) {
-    return stringValue(parseJsonObject(row.request_payload_json), "summary");
-}
-function clarificationMeta(row, phase) {
-    const meta = [
-        row.owner_kind === "task" ? "owner: task" : "owner: task_compile",
-        `round: ${row.round_index}`,
-    ];
-    if (phase === "answered") {
-        meta.push(`successor: ${row.successor_status}`);
-    }
-    return meta;
+function firstNonEmptyLine(value) {
+    return value
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
 }
-function assignClarificationAnchors(item, row) {
-    if (row.owner_task_id !== null) {
-        item.task_id = row.owner_task_id;
-    }
-    if (row.task_title !== null && row.task_title.trim() !== "") {
-        item.task_title = row.task_title;
-    }
-    if (row.owner_workflow_ref !== null) {
-        item.workflow_ref = row.owner_workflow_ref;
-    }
-    if (row.created_from_activity_ref !== null) {
-        item.activity_ref = row.created_from_activity_ref;
-    }
+function checkpointTraceCard(feedback, messageId, body) {
+    const visibleItems = feedback.items.slice(0, TRACE_CHECKPOINT_ITEM_LIMIT);
+    const visibleGeneratedFiles = feedback.generated_files?.slice(0, TRACE_GENERATED_FILE_LIMIT);
+    return {
+        tone: feedback.status === "completed" ? "success" : "error",
+        summary: feedback.final_note ?? firstNonEmptyLine(body) ?? feedback.title,
+        checkpoint: {
+            counters: feedback.counters,
+            items: visibleItems,
+            ...(visibleGeneratedFiles === undefined ? {} : { generated_files: visibleGeneratedFiles }),
+            ...(feedback.items.length > visibleItems.length ||
+                (feedback.generated_files?.length ?? 0) > (visibleGeneratedFiles?.length ?? 0)
+                ? { truncated: true }
+                : {}),
+        },
+        links: [chatMessageLink(messageId)],
+    };
 }
-function readClarificationTimelineItems(db) {
+function readCheckpointTimelineItems(db) {
     if (db === undefined) {
         return [];
     }
     const rows = db
         .prepare(`
-        SELECT
-          clarification_rounds.id,
-          clarification_rounds.round_index,
-          clarification_rounds.status,
-          clarification_rounds.request_payload_json,
-          clarification_rounds.submitted_at,
-          clarification_rounds.successor_status,
-          clarification_rounds.created_at,
-          clarification_threads.owner_kind,
-          clarification_threads.owner_workflow_ref,
-          clarification_threads.owner_task_id,
-          clarification_threads.created_from_activity_ref,
-          tasks.title AS task_title
-        FROM clarification_rounds
-        JOIN clarification_threads
-          ON clarification_threads.id = clarification_rounds.clarification_thread_id
-        LEFT JOIN tasks ON tasks.id = clarification_threads.owner_task_id
-        ORDER BY clarification_rounds.created_at DESC, clarification_rounds.id DESC
-        LIMIT ${CLARIFICATION_TIMELINE_LIMIT}
+        SELECT id, body, refs_json, created_at
+        FROM messages
+        WHERE scope_kind = 'main_chat'
+          AND refs_json IS NOT NULL
+          AND json_type(refs_json, '$.worklist_feedback') = 'object'
+        ORDER BY created_at DESC, id DESC
+        LIMIT ${CHECKPOINT_TIMELINE_LIMIT}
       `)
         .all();
     return rows.flatMap((row) => {
-        const ownerLabel = clarificationOwnerLabel(row);
-        const summary = clarificationSummary(row);
-        const requested = {
-            id: `clarification:${row.id}:requested`,
-            kind: "clarification",
-            occurred_at: row.created_at,
-            title: `Clarification requested: ${ownerLabel}`,
-            status: row.status === "writable" ? "needs_human" : "completed",
-            meta: clarificationMeta(row, "requested"),
-        };
-        if (summary !== undefined) {
-            requested.summary = summary;
-        }
-        assignClarificationAnchors(requested, row);
-        if (row.submitted_at === null) {
-            return [requested];
+        const feedback = parseCheckpointFeedback(row.refs_json);
+        if (feedback === null) {
+            return [];
         }
-        const answered = {
-            id: `clarification:${row.id}:answered`,
-            kind: "clarification",
-            occurred_at: row.submitted_at,
-            title: `Clarification answered: ${ownerLabel}`,
-            summary: "Human input submitted.",
-            status: "completed",
-            meta: clarificationMeta(row, "answered"),
-        };
-        assignClarificationAnchors(answered, row);
-        return [requested, answered];
-    });
-}
-function readRecoveryTimelineItems(db) {
-    if (db === undefined) {
-        return [];
-    }
-    const rows = db
-        .prepare(`
-        SELECT
-          id,
-          affected_activities_json,
-          summary,
-          created_at
-        FROM recovery_summaries
-        ORDER BY created_at DESC, id DESC
-        LIMIT ${RECOVERY_TIMELINE_LIMIT}
-      `)
-        .all();
-    return rows.map((row) => {
-        const affectedActivities = parseJsonStringArray(row.affected_activities_json);
         const item = {
-            id: `recovery:${row.id}`,
-            kind: "recovery",
+            id: `checkpoint:${row.id}`,
+            kind: "checkpoint",
             occurred_at: row.created_at,
-            title: "Workspace recovery completed",
-            summary: row.summary,
-            status: "completed",
-            meta: [`affected activities: ${affectedActivities.length}`],
+            title: feedback.title,
+            status: feedback.status === "completed" ? "completed" : "failed",
+            message_id: row.id,
+            trace_card: checkpointTraceCard(feedback, row.id, row.body),
         };
-        if (affectedActivities.length === 1) {
-            item.activity_ref = affectedActivities[0];
+        const summary = feedback.final_note ?? firstNonEmptyLine(row.body);
+        if (summary !== undefined) {
+            item.summary = summary;
         }
-        return item;
+        if (feedback.primary_task_id !== undefined) {
+            item.task_id = feedback.primary_task_id;
+        }
+        return [item];
     });
 }
-function usageSourcesForDurableEventItem(item) {
-    if (item.title === "Docs sync completed" || item.title === "Docs sync failed") {
-        return CONTEXT_SYNC_USAGE_SOURCES;
-    }
-    if (item.title === "Reference summaries refreshed" ||
-        item.title === "Reference summary refresh failed") {
-        return REFERENCE_SUMMARY_USAGE_SOURCES;
-    }
-    return [];
-}
-function attachDurableEventUsage(db, item, consumedProcedureUsageAnchors) {
-    if (db === undefined) {
-        return item;
-    }
-    const sources = usageSourcesForDurableEventItem(item);
-    if (sources.length === 0) {
-        return item;
-    }
-    const anchors = {};
-    if (item.activity_ref !== undefined) {
-        anchors.activity_ref = item.activity_ref;
-    }
-    if (item.workflow_ref !== undefined) {
-        anchors.workflow_ref = item.workflow_ref;
-    }
-    if (item.task_id !== undefined) {
-        anchors.task_id = item.task_id;
-    }
-    if (attachProviderUsageToItem(db, item, anchors, { sources })) {
-        pushConsumedProcedureUsageAnchors(consumedProcedureUsageAnchors, sources, anchors);
-    }
-    return item;
-}
-function shouldDisplayDurableEventItem(item) {
-    if (item.kind === "promotion") {
-        return false;
-    }
-    return item.title !== "Docs sync completed" && item.title !== "Reference summaries refreshed";
-}
 export function readProjectTimelineProjection(input) {
     const now = input.now ?? (() => new Date());
     const runRows = input.db === undefined ? [] : readRunResultTimelineRows(input.db);
-    const consumedProcedureUsageAnchors = [];
-    const durableEventItems = input.db === undefined
-        ? []
-        : readProjectTimelineEventItems(input.db, { limit: DURABLE_EVENT_TIMELINE_LIMIT })
-            .filter(shouldDisplayDurableEventItem)
-            .map((item) => attachDurableEventUsage(input.db, item, consumedProcedureUsageAnchors));
     const items = [
-        ...readTaskTimelineItems(input.db, consumedProcedureUsageAnchors),
-        ...readRunTimelineItems(input.db, runRows),
-        ...readChecksTimelineItems(runRows),
-        ...readProcedureUsageTimelineItems(input.db, consumedProcedureUsageAnchors),
-        ...readClarificationTimelineItems(input.db),
-        ...readRecoveryTimelineItems(input.db),
-        ...durableEventItems,
-        ...readCommitTimelineItems(input.workspaceRoot),
-    ]
-        .filter((item) => item.status !== "skipped")
-        .sort(compareTimelineItemsByTimeDesc);
+        ...readTaskAcceptedTimelineItems(input.db),
+        ...readTaskUpdateTimelineItems(input.db, runRows, input.workspaceRoot),
+        ...readCheckpointTimelineItems(input.db),
+    ].sort(compareTimelineItemsByTimeDesc);
     return {
         generated_at: now().toISOString(),
-        usage_overview: input.db === undefined
-            ? {
-                total_tokens: 0,
-                totals: {
-                    input_tokens: 0,
-                    cached_input_tokens: 0,
-                    output_tokens: 0,
-                    reasoning_output_tokens: 0,
-                    total_tokens: 0,
-                    event_count: 0,
-                },
-                by_source: [],
-                by_model: [],
-                recent_windows: {
-                    today: {
-                        input_tokens: 0,
-                        cached_input_tokens: 0,
-                        output_tokens: 0,
-                        reasoning_output_tokens: 0,
-                        total_tokens: 0,
-                        event_count: 0,
-                    },
-                    last_7_days: {
-                        input_tokens: 0,
-                        cached_input_tokens: 0,
-                        output_tokens: 0,
-                        reasoning_output_tokens: 0,
-                        total_tokens: 0,
-                        event_count: 0,
-                    },
-                    last_30_days: {
-                        input_tokens: 0,
-                        cached_input_tokens: 0,
-                        output_tokens: 0,
-                        reasoning_output_tokens: 0,
-                        total_tokens: 0,
-                        event_count: 0,
-                    },
-                },
-            }
-            : readProviderUsageProjection(input.db, { now }),
+        usage_overview: input.db === undefined ? emptyUsageOverview() : readProviderUsageProjection(input.db, { now }),
         items: items.slice(0, TIMELINE_LIMIT),
     };
 }