stageflow 0.15.0 → 0.16.0

package/dist/agent/activity.d.ts

@@ -11,6 +11,7 @@
  * those Q&A bodies.
  */
 import type { AskOperatorAnswer, AskOperatorPrompt } from "../tools/askOperator.js";
+import type { StageUsage } from "../types/usage.js";
 export declare const ACTIVITY_TEXT_LIMIT = 2000;
 export declare const ACTIVITY_TEXT_LIMIT_ENV = "STAGEFLOW_ACTIVITY_TEXT_LIMIT";
 export declare const ACTIVITY_VERBOSE_ENV = "STAGEFLOW_ACTIVITY_VERBOSE";
@@ -65,9 +66,11 @@ export type StageLifecycleEvent = {
     event: "resumed";
 } | {
     event: "succeeded";
+    usage?: StageUsage;
 } | {
     event: "failed";
     reason: string;
+    usage?: StageUsage;
 } | {
     event: "skipped";
 }

package/dist/agent/claudeAdapter.js

@@ -43,10 +43,12 @@ import { isAdvancingEnvelope } from "../envelope/check.js";
 import { assertAnswerMatchesPrompt, parseAskOperatorAnswer, summarizeAnswer, } from "../tools/askOperator.js";
 import { buildStageflowMcpServer, EMIT_STAGE_ENVELOPE_TOOL_NAME, STAGEFLOW_MCP_SERVER_NAME, WRITE_STAGE_ARTIFACT_TOOL_NAME, ASK_OPERATOR_TOOL_NAME, } from "./claudeTools.js";
 import { createClaudeActivityMapper } from "./claudeActivity.js";
+import { readActivityVerbose } from "./activity.js";
 import { composeStageUserPrompt } from "./piAdapter.js";
 import { claudeSessionMarkerPath, clearClaudeSessionMarker, readClaudeSessionMarker, writeClaudeSessionMarker, } from "./claudeSession.js";
 import { DEFAULT_STAGE_TIMEOUT_MS, runStageViaOpen, runtimeStageId, } from "./port.js";
 import { StageMcpError } from "../config/resolveStageMcpServers.js";
+import { addModelUsage, emptyStageUsage } from "../types/usage.js";
 /** Built-in tool allowlist, mirroring Pi's sealed-session base set (read/bash/write/edit). */
 const CLAUDE_BUILTIN_TOOLS = ["Read", "Write", "Edit", "Bash"];
 function resolveClaudeModel(stageModel) {
@@ -102,6 +104,65 @@ function failedPassedMcpConnect(resolved, listed) {
     }
     return undefined;
 }
+/** Merge one query() call's per-model totals (this call's own turns only) into the stage-level accumulator. */
+function mergeClaudeModelUsage(usage, modelUsage) {
+    if (!modelUsage)
+        return;
+    for (const [key, entry] of Object.entries(modelUsage)) {
+        addModelUsage(usage, entry.canonicalModel ?? key, {
+            inputTokens: entry.inputTokens,
+            outputTokens: entry.outputTokens,
+            cacheReadInputTokens: entry.cacheReadInputTokens,
+            cacheCreationInputTokens: entry.cacheCreationInputTokens,
+            costUsd: entry.costUSD,
+        });
+    }
+}
+const TRAILING_RESULT_WAIT_MS = 2000;
+/**
+ * emit_stage_envelope's tool_result lands on a "user" message, which the
+ * caller interrupts and breaks on immediately (never-let-it-go-dangling) —
+ * well before the SDK's own "result" message (the one carrying cost/token
+ * totals) would naturally arrive. There can be more than one trailing frame
+ * after the interrupted tool-result (observed: another "user" frame before
+ * "result"), so this drains messages in a loop, bounded by one overall time
+ * budget rather than a single peek. By the docstring above, `interrupt()`
+ * resolving means the CLI subprocess has already exited, so its trailing
+ * frames are normally already queued or arrive within milliseconds — this
+ * claims them without risking a real hang.
+ */
+async function drainTrailingResultUsage(stream, usage) {
+    const debug = readActivityVerbose();
+    const deadline = Date.now() + TRAILING_RESULT_WAIT_MS;
+    try {
+        while (Date.now() < deadline) {
+            const next = await Promise.race([
+                stream.next(),
+                new Promise((resolve) => setTimeout(() => resolve({ done: true, value: undefined }), deadline - Date.now())),
+            ]);
+            if (debug) {
+                console.error(`[claudeAdapter] drainTrailingResultUsage: done=${next.done} type=${!next.done ? next.value?.type : "n/a"}`);
+            }
+            if (next.done)
+                return;
+            const message = next.value;
+            if (message.type === "result") {
+                if (debug) {
+                    console.error(`[claudeAdapter] drainTrailingResultUsage: modelUsage=${JSON.stringify(message.modelUsage)}`);
+                }
+                mergeClaudeModelUsage(usage, message.modelUsage);
+                return;
+            }
+            // not "result" yet (e.g. another "user"/"system" frame) — keep draining within the budget
+        }
+    }
+    catch (err) {
+        if (debug) {
+            console.error(`[claudeAdapter] drainTrailingResultUsage: threw ${err instanceof Error ? err.message : String(err)}`);
+        }
+        // best-effort; a natural stop may already have ended the turn
+    }
+}
 async function* singleUserMessage(text) {
     yield {
         type: "user",
@@ -110,7 +171,7 @@ async function* singleUserMessage(text) {
     };
 }
 /** One `query()` call — either the stage's initial turn or a resume turn. */
-async function runTurn(input, model, markerPath, promptText, resumeSessionId) {
+async function runTurn(input, model, markerPath, promptText, resumeSessionId, usage) {
     const timeoutMs = input.timeoutMs ?? DEFAULT_STAGE_TIMEOUT_MS;
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -187,15 +248,23 @@ async function runTurn(input, model, markerPath, promptText, resumeSessionId) {
             }
             if (message.type === "user" &&
                 (emitCapture.envelope !== undefined || askCapture.prompt !== undefined)) {
+                if (readActivityVerbose()) {
+                    console.error(`[claudeAdapter] interrupting on user tool-result frame`);
+                }
                 try {
                     await stream.interrupt();
                 }
                 catch {
                     // best-effort backstop; a natural stop may have already ended the turn
                 }
+                await drainTrailingResultUsage(stream, usage);
                 break;
             }
             if (message.type === "result") {
+                if (readActivityVerbose()) {
+                    console.error(`[claudeAdapter] main loop saw result: modelUsage=${JSON.stringify(message.modelUsage)}`);
+                }
+                mergeClaudeModelUsage(usage, message.modelUsage);
                 break;
             }
         }
@@ -204,26 +273,27 @@ async function runTurn(input, model, markerPath, promptText, resumeSessionId) {
             if (resolvedSessionId === undefined) {
                 return {
                     kind: "completed",
-                    result: { ok: false, reason: "ask_operator called but no session_id was observed" },
+                    result: { ok: false, reason: "ask_operator called but no session_id was observed", usage },
                 };
             }
             await writeClaudeSessionMarker(markerPath, {
                 sessionId: resolvedSessionId,
                 prompt: askCapture.prompt,
+                usage,
             });
             return { kind: "waiting", sessionId: resolvedSessionId, request: askCapture.prompt };
         }
         await clearClaudeSessionMarker(markerPath);
-        return { kind: "completed", result: resultFromCapture(emitCapture) };
+        return { kind: "completed", result: { ...resultFromCapture(emitCapture), usage } };
     }
     catch (err) {
         if (askCapture.prompt !== undefined && sessionId !== undefined) {
-            await writeClaudeSessionMarker(markerPath, { sessionId, prompt: askCapture.prompt });
+            await writeClaudeSessionMarker(markerPath, { sessionId, prompt: askCapture.prompt, usage });
             return { kind: "waiting", sessionId, request: askCapture.prompt };
         }
         if (emitCapture.envelope && isAdvancingEnvelope(emitCapture.envelope)) {
             await clearClaudeSessionMarker(markerPath);
-            return { kind: "completed", result: { ok: true, envelope: emitCapture.envelope } };
+            return { kind: "completed", result: { ok: true, envelope: emitCapture.envelope, usage } };
         }
         return {
             kind: "completed",
@@ -231,6 +301,7 @@ async function runTurn(input, model, markerPath, promptText, resumeSessionId) {
                 ok: false,
                 reason: err instanceof Error ? err.message : String(err),
                 envelope: emitCapture.envelope,
+                usage,
             },
         };
     }
@@ -254,6 +325,7 @@ export class ClaudeAgentAdapter {
         let bootstrapped = false;
         let waiting;
         let pendingAnswer;
+        const usage = emptyStageUsage();
         const applyOutcome = (outcome) => {
             if (outcome.kind === "waiting") {
                 waiting = { sessionId: outcome.sessionId, prompt: outcome.request };
@@ -275,6 +347,11 @@ export class ClaudeAgentAdapter {
                     if (marker?.prompt !== undefined) {
                         waiting = { sessionId: marker.sessionId, prompt: marker.prompt };
                     }
+                    if (marker?.usage) {
+                        for (const [model, breakdown] of Object.entries(marker.usage.models)) {
+                            addModelUsage(usage, model, breakdown);
+                        }
+                    }
                 }
                 if (waiting) {
                     if (pendingAnswer === undefined) {
@@ -301,14 +378,14 @@ export class ClaudeAgentAdapter {
                         await clearClaudeSessionMarker(markerPath);
                         return { status: "completed", result: { ok: false, reason: pre.reason } };
                     }
-                    const outcome = await runTurn(input, pre.model, markerPath, resumePromptText(parsedAnswer), sessionId);
+                    const outcome = await runTurn(input, pre.model, markerPath, resumePromptText(parsedAnswer), sessionId, usage);
                     return applyOutcome(outcome);
                 }
                 const pre = preflight(input);
                 if (!pre.ok) {
                     return { status: "completed", result: { ok: false, reason: pre.reason } };
                 }
-                const outcome = await runTurn(input, pre.model, markerPath, composeStageUserPrompt(input, EMIT_STAGE_ENVELOPE_TOOL_NAME, undefined, WRITE_STAGE_ARTIFACT_TOOL_NAME), undefined);
+                const outcome = await runTurn(input, pre.model, markerPath, composeStageUserPrompt(input, EMIT_STAGE_ENVELOPE_TOOL_NAME, undefined, WRITE_STAGE_ARTIFACT_TOOL_NAME), undefined, usage);
                 return applyOutcome(outcome);
             },
             deliverAnswer(answer) {

package/dist/agent/claudeSession.d.ts

@@ -1,8 +1,11 @@
 import type { AskOperatorPrompt } from "../tools/askOperator.js";
 import type { StageRunInput } from "./port.js";
+import type { StageUsage } from "../types/usage.js";
 export type ClaudeSessionMarker = {
     sessionId: string;
     prompt?: AskOperatorPrompt;
+    /** Cost/tokens accumulated by turns run so far, so a restart resuming this stage doesn't lose prior spend. */
+    usage?: StageUsage;
 };
 /**
  * Derives a stable, per-attempt path from `input.resumeToken` — the same

package/dist/agent/piAdapter.d.ts

@@ -5,6 +5,7 @@ import "./cursorProvider.js";
 import { type StageActivityObserver } from "./activityObserver.js";
 import type { AgentPort, OpaqueAnswer, StageHandle, StageHandleCloseOptions, StageRunInput, StageRunResult } from "./port.js";
 import type { StageGateKind } from "../types/stage.js";
+import { type StageUsage } from "../types/usage.js";
 /**
  * Stage tool allowlist for sealed Pi sessions.
  * Includes `ask_operator` unless `gateKinds` is an empty list (R6).
@@ -56,6 +57,7 @@ export declare function extractPartialResultText(partialResult: unknown): string
 export type RouteSessionEventToProgressOptions = {
     observer: StageActivityObserver;
     verbose: boolean;
+    usage?: StageUsage;
 };
 /**
  * Adapter-edge routing: stream deltas to the observer, map milestones to

package/dist/agent/piAdapter.js

@@ -47,6 +47,7 @@ import { findProviderSupport } from "./providerSupport.js";
 import { mapSessionEventToActivity, readActivityVerbose } from "./activity.js";
 import { createStageActivityObserver, } from "./activityObserver.js";
 import { DEFAULT_STAGE_TIMEOUT_MS, runtimeStageId, runStageViaOpen } from "./port.js";
+import { addModelUsage, emptyStageUsage } from "../types/usage.js";
 /**
  * Stage tool allowlist for sealed Pi sessions.
  * Includes `ask_operator` unless `gateKinds` is an empty list (R6).
@@ -302,13 +303,29 @@ export function extractPartialResultText(partialResult) {
     }
     return String(partialResult);
 }
+/** Merge one assistant message's usage/cost (as reported by pi-ai) into the stage-level accumulator. */
+function mergePiAssistantUsage(usage, message) {
+    if (!message || typeof message !== "object")
+        return;
+    const msg = message;
+    if (msg.role !== "assistant" || typeof msg.model !== "string" || !msg.usage)
+        return;
+    const u = msg.usage;
+    addModelUsage(usage, msg.model, {
+        inputTokens: u.input,
+        outputTokens: u.output,
+        cacheReadInputTokens: u.cacheRead,
+        cacheCreationInputTokens: u.cacheWrite,
+        costUsd: u.cost?.total ?? 0,
+    });
+}
 /**
  * Adapter-edge routing: stream deltas to the observer, map milestones to
  * StageActivityEvent. Verbose thinking / live tool partials go to observer
  * hooks (stderr streams + coalesced/throttled persist via onActivity).
  */
 export function routeSessionEventToProgress(event, options) {
-    const { observer, verbose } = options;
+    const { observer, verbose, usage } = options;
     if (event.type === "message_update") {
         const ame = event.assistantMessageEvent;
         if (ame && typeof ame === "object") {
@@ -334,6 +351,9 @@ export function routeSessionEventToProgress(event, options) {
     }
     if (event.type === "message_end" || event.type === "agent_end") {
         observer.onStreamBoundary();
+        if (usage && event.type === "message_end") {
+            mergePiAssistantUsage(usage, event.message);
+        }
     }
     if (event.type === "agent_start" ||
         event.type === "turn_start" ||
@@ -350,13 +370,14 @@ export function routeSessionEventToProgress(event, options) {
  * Map Pi session events to StageActivityEvent at the adapter edge, then
  * forward to the activity observer (stderr + onActivity).
  */
-function attachStageProgress(session, onActivity) {
+function attachStageProgress(session, onActivity, usage) {
     const observer = createStageActivityObserver({ onActivity, writeStderr: true });
     const verbose = readActivityVerbose();
     const unsubscribe = session.subscribe((event) => {
         routeSessionEventToProgress(event, {
             observer,
             verbose,
+            usage,
         });
     });
     return () => {
@@ -752,6 +773,7 @@ async function prepareStageSessionWiring(input, sessionManager, existingAskWaitC
     const { roots } = input;
     const provider = findProviderSupport(input.stage.model);
     const capture = {};
+    const usage = emptyStageUsage();
     const askWaitChannel = existingAskWaitChannel ?? new AskOperatorWaitChannel();
     const emitDef = createEmitStageEnvelopeTool(capture, input.stage.payload_schema, input.forkEmitContext, input.cloneEmitContext, {
         checks: input.stage.pre_emit_checks,
@@ -864,6 +886,7 @@ async function prepareStageSessionWiring(input, sessionManager, existingAskWaitC
             providerEmitHint: provider?.emitToolHint?.(emitDef.name),
             restoreProvider,
             capture,
+            usage,
             askWaitChannel,
             connecting: attached.connecting,
             cancelConnecting: attached.cancel,
@@ -1090,7 +1113,7 @@ export class PiAgentAdapter {
                 return;
             }
             session = bound;
-            unsubscribeProgress = attachStageProgress(session, input.onActivity);
+            unsubscribeProgress = attachStageProgress(session, input.onActivity, wiring.usage);
         })();
         const runWithTimeout = async (work) => {
             await preparePromise;
@@ -1109,16 +1132,17 @@ export class PiAgentAdapter {
                     });
                 });
                 await Promise.race([workPromise, abortPromise]);
-                return resultFromCapture(wiring.capture);
+                return { ...resultFromCapture(wiring.capture), usage: wiring.usage };
             }
             catch (err) {
                 if (wiring.capture.envelope && isAdvancingEnvelope(wiring.capture.envelope)) {
-                    return { ok: true, envelope: wiring.capture.envelope };
+                    return { ok: true, envelope: wiring.capture.envelope, usage: wiring.usage };
                 }
                 return {
                     ok: false,
                     reason: err instanceof Error ? err.message : String(err),
                     envelope: wiring.capture.envelope,
+                    usage: wiring.usage,
                 };
             }
             finally {

package/dist/agent/port.d.ts

@@ -8,6 +8,7 @@ import type { StageActivityEvent } from "./activity.js";
 import type { ResolvedMcpServers } from "../config/resolveStageMcpServers.js";
 import type { StageRoots } from "../runtime/stageRoots.js";
 import type { QaExchange } from "../hitl/qaTrail.js";
+import type { StageUsage } from "../types/usage.js";
 /** Opaque to runtime; adapters interpret. */
 export type StageResumeToken = string;
 export type StageSessionMode = "fresh" | "waiting_resume" | "feedback_resume" | "new_session";
@@ -77,10 +78,12 @@ export declare function runtimeStageId(input: Pick<StageRunInput, "stage" | "sta
 export type StageRunResult = {
     ok: true;
     envelope: StageEnvelope;
+    usage?: StageUsage;
 } | {
     ok: false;
     reason: string;
     envelope?: StageEnvelope;
+    usage?: StageUsage;
 };
 /** Opaque wait-request blob; T2 owns concrete prompt shapes later. */
 export type OpaqueWaitRequest = unknown;

package/dist/cli/runOutput.js

@@ -2,6 +2,21 @@ import { projectRun } from "../projection/projectRun.js";
 function stringify(payload) {
     return JSON.stringify(payload, null, 2);
 }
+function formatUsd(amount) {
+    return `$${amount.toFixed(4)}`;
+}
+/** Best-effort total cost for a run; undefined (not thrown) on any read failure or when no stage reported usage. */
+async function tryReadTotalCostUsd(store, runId) {
+    if (!store)
+        return undefined;
+    try {
+        const detail = await store.readRun(runId);
+        return detail.total_cost_usd;
+    }
+    catch {
+        return undefined;
+    }
+}
 function isBusyCode(code) {
     return code === "busy_capacity" || code === "busy_checkout";
 }
@@ -80,14 +95,19 @@ function baseRunCompletionPayload(result) {
     }
     return payload;
 }
-function formatRunCompletionJson(result) {
-    return stringify(baseRunCompletionPayload(result));
+async function formatRunCompletionJsonWithCost(result, store) {
+    const totalCostUsd = await tryReadTotalCostUsd(store, result.runId);
+    return stringify({
+        ...baseRunCompletionPayload(result),
+        ...(totalCostUsd !== undefined ? { total_cost_usd: totalCostUsd } : {}),
+    });
 }
 async function formatRunCompletionJsonWithStages(result, store) {
     const detail = await store.readRun(result.runId);
     const projection = projectRun(detail);
     return stringify({
         ...baseRunCompletionPayload(result),
+        ...(detail.total_cost_usd !== undefined ? { total_cost_usd: detail.total_cost_usd } : {}),
         stages: projection.stages,
     });
 }
@@ -101,18 +121,21 @@ function writeStartFailureHuman(started, io) {
         io.error(`conflictingCheckout: ${started.conflictingCheckout}`);
     }
 }
-function writeCompletionHuman(result, io) {
+function writeCompletionHuman(result, io, totalCostUsd) {
     switch (result.outcome) {
         case "waiting":
             io.error(`Pipeline waiting. Run folder: ${result.runDir} (${result.runId})`);
-            return;
+            break;
         case "failed":
             io.error(`Pipeline failed: ${result.reason}`);
             io.error(`Run folder: ${result.runDir}`);
-            return;
+            break;
         case "succeeded":
             io.log(`Pipeline succeeded. Run folder: ${result.runDir}`);
-            return;
+            break;
+    }
+    if (totalCostUsd !== undefined) {
+        io.error(`Cost: ${formatUsd(totalCostUsd)}`);
     }
 }
 function exitCodeForRunOutcome(outcome) {
@@ -151,11 +174,12 @@ export async function reportCliRun(event, options) {
             }
         }
         else {
-            options.io.log(formatRunCompletionJson(event.result));
+            options.io.log(await formatRunCompletionJsonWithCost(event.result, options.store));
         }
     }
     else {
-        writeCompletionHuman(event.result, options.io);
+        const totalCostUsd = await tryReadTotalCostUsd(options.store, event.result.runId);
+        writeCompletionHuman(event.result, options.io, totalCostUsd);
     }
     return exitCodeForRunOutcome(event.result.outcome);
 }

package/dist/package-meta.d.ts

@@ -1,2 +1,2 @@
 export declare const PACKAGE_NAME = "stageflow";
-export declare const PACKAGE_VERSION = "0.15.0";
+export declare const PACKAGE_VERSION = "0.16.0";

package/dist/package-meta.js

@@ -1,2 +1,2 @@
 export const PACKAGE_NAME = "stageflow";
-export const PACKAGE_VERSION = "0.15.0";
+export const PACKAGE_VERSION = "0.16.0";

package/dist/runstore/port.d.ts

@@ -4,6 +4,7 @@ import type { StageEnvelope } from "../types/envelope.js";
 import type { FeedbackLoopConfig, ResolvedPipelineDag } from "../types/pipeline.js";
 import type { CompletionCheck } from "../types/completion.js";
 import type { StageGateKind } from "../types/stage.js";
+import type { StageUsage } from "../types/usage.js";
 export type RunStatus = "created" | "running" | "succeeded" | "failed";
 export type RunPipelineDagSnapshot = ResolvedPipelineDag & {
     stage_ids: string[];
@@ -70,6 +71,8 @@ export type StageSnapshot = {
     last_at?: string;
     pending_prompt?: AskOperatorPrompt;
     attempt_count: number;
+    /** Total $ spent on this stage across every attempt; omitted when no attempt reported usage. */
+    cost_usd?: number;
 };
 export type StageExecution = {
     run_id: string;
@@ -80,6 +83,8 @@ export type StageExecution = {
     started_at?: string;
     finished_at?: string;
     envelope: StageEnvelope | null;
+    cost_usd?: number;
+    usage?: StageUsage;
 };
 export type StageExecutionPatch = {
     status?: StageSnapshot["status"];
@@ -87,6 +92,8 @@ export type StageExecutionPatch = {
     started_at?: string;
     finished_at?: string;
     envelope?: StageEnvelope | null;
+    cost_usd?: number;
+    usage?: StageUsage;
 };
 /** The durable disposition of completion verification for one stage attempt. */
 export type VerificationOutcome = "not_run" | "passed" | "failed" | "error";
@@ -220,6 +227,7 @@ export type CompactStage = {
     status: StageSnapshot["status"];
     attempt_count: number;
     definition_id?: string;
+    cost_usd?: number;
 };
 export type RunSummary = {
     run_id: string;
@@ -246,6 +254,8 @@ export type RunSummary = {
     failed_reason?: string;
     /** The active loop, when a run is currently replaying or awaiting a decision. */
     active_feedback_loop?: FeedbackLoopRecord;
+    /** Sum of every stage's cost_usd; omitted when no stage reported usage. */
+    total_cost_usd?: number;
 };
 export type RunDetail = Omit<RunSummary, "stages"> & {
     task_yaml: string;

package/dist/runstore/runProjection.js

@@ -26,8 +26,15 @@ function compactStages(stages) {
         status: s.status,
         attempt_count: s.attempt_count,
         ...(s.definition_id !== undefined ? { definition_id: s.definition_id } : {}),
+        ...(s.cost_usd !== undefined ? { cost_usd: s.cost_usd } : {}),
     }));
 }
+function totalCostUsd(stages) {
+    const costs = stages.map((s) => s.cost_usd).filter((c) => c !== undefined);
+    if (costs.length === 0)
+        return undefined;
+    return costs.reduce((sum, c) => sum + c, 0);
+}
 function waitingSummaryFromPrompt(prompt) {
     if (!prompt)
         return "Waiting for input";
@@ -89,6 +96,7 @@ function resolveListedStatus(stages, meta, dag) {
 export function projectRunSummary(meta, stages, feedback) {
     const dag = meta.pipeline_dag;
     const waiting = waitingFieldsFromStages(stages);
+    const cost = totalCostUsd(stages);
     if (feedback?.active_feedback_loop?.state === "waiting_for_human" &&
         waiting.waiting_stage_id !== undefined &&
         waiting.waiting_kind === undefined) {
@@ -114,6 +122,7 @@ export function projectRunSummary(meta, stages, feedback) {
         ...(feedback?.active_feedback_loop !== undefined
             ? { active_feedback_loop: feedback.active_feedback_loop }
             : {}),
+        ...(cost !== undefined ? { total_cost_usd: cost } : {}),
     };
 }
 export function projectRunDetail(meta, stages, task_yaml, dagSnapshot, feedback) {

package/dist/runstore/sqlite/SqliteRunStore.js

@@ -78,6 +78,18 @@ function ensureStageExecutionVerificationOutcomeColumn(db) {
         db.exec(`ALTER TABLE stage_executions ADD COLUMN verification_outcome TEXT NOT NULL DEFAULT 'not_run'`);
     }
 }
+function ensureStageExecutionCostColumns(db) {
+    const cols = db
+        .prepare(`PRAGMA table_info(stage_executions)`)
+        .all();
+    const names = new Set(cols.map((c) => c.name));
+    if (!names.has("cost_usd")) {
+        db.exec(`ALTER TABLE stage_executions ADD COLUMN cost_usd REAL`);
+    }
+    if (!names.has("usage_json")) {
+        db.exec(`ALTER TABLE stage_executions ADD COLUMN usage_json TEXT`);
+    }
+}
 function backfillVerificationOutcomes(db) {
     db.exec(`
 UPDATE stage_executions
@@ -184,6 +196,8 @@ function executionFromRow(row) {
         envelope: row.envelope_json
             ? JSON.parse(row.envelope_json)
             : null,
+        ...(row.cost_usd != null ? { cost_usd: row.cost_usd } : {}),
+        ...(row.usage_json != null ? { usage: JSON.parse(row.usage_json) } : {}),
     };
 }
 function verificationCheckResultFromRow(row) {
@@ -292,6 +306,7 @@ export class SqliteRunStore {
         ensureRunLocatorColumns(this.db);
         ensureStageExecutionsTable(this.db);
         ensureStageExecutionVerificationOutcomeColumn(this.db);
+        ensureStageExecutionCostColumns(this.db);
         ensureStageEventsAttemptColumn(this.db);
         ensureVerificationCheckResultsTable(this.db);
         ensureFeedbackReplayStagePassEnvelopeColumn(this.db);
@@ -432,7 +447,7 @@ export class SqliteRunStore {
                 verification_outcome: "not_run",
             });
             const row = this.db
-                .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json
+                .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json, cost_usd, usage_json
            FROM stage_executions
            WHERE run_id = ? AND stage_id = ? AND attempt = ?`)
                 .get(runId, stageId, attempt);
@@ -442,7 +457,7 @@ export class SqliteRunStore {
     async listStageExecutions(runId, stageId) {
         await this.ready();
         const rows = this.db
-            .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json
+            .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json, cost_usd, usage_json
          FROM stage_executions
          WHERE run_id = ? AND stage_id = ?
          ORDER BY attempt ASC`)
@@ -452,7 +467,7 @@ export class SqliteRunStore {
     async getLatestStageExecution(runId, stageId) {
         await this.ready();
         const row = this.db
-            .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json
+            .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json, cost_usd, usage_json
          FROM stage_executions
          WHERE run_id = ? AND stage_id = ?
          ORDER BY attempt DESC
@@ -471,7 +486,7 @@ export class SqliteRunStore {
     async getStageExecution(runId, stageId, attempt) {
         await this.ready();
         const row = this.db
-            .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json
+            .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json, cost_usd, usage_json
          FROM stage_executions
          WHERE run_id = ? AND stage_id = ? AND attempt = ?`)
             .get(runId, stageId, attempt);
@@ -509,6 +524,14 @@ export class SqliteRunStore {
             params.envelope_json =
                 patch.envelope != null ? JSON.stringify(patch.envelope) : null;
         }
+        if (patch.cost_usd !== undefined) {
+            sets.push("cost_usd = @cost_usd");
+            params.cost_usd = patch.cost_usd;
+        }
+        if (patch.usage !== undefined) {
+            sets.push("usage_json = @usage_json");
+            params.usage_json = JSON.stringify(patch.usage);
+        }
         if (sets.length === 0)
             return;
         const result = this.db

package/dist/runstore/sqlite/schema.d.ts

@@ -1 +1 @@
-export declare const SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS runs (\n  run_id TEXT PRIMARY KEY,\n  pipeline_id TEXT NOT NULL,\n  task_id TEXT,\n  task_yaml TEXT NOT NULL,\n  status TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  checkout_root TEXT,\n  pipeline_dag_json TEXT,\n  git_sha TEXT,\n  ci_pr_url TEXT,\n  ci_job_url TEXT,\n  pipeline_path TEXT,\n  task_path TEXT,\n  project_root TEXT\n);\n\nCREATE TABLE IF NOT EXISTS stages (\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  status TEXT,\n  summary TEXT,\n  envelope_json TEXT,\n  started_at TEXT,\n  finished_at TEXT,\n  PRIMARY KEY (run_id, stage_id),\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE TABLE IF NOT EXISTS stage_events (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  at TEXT NOT NULL,\n  event TEXT NOT NULL,\n  payload_json TEXT,\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_runs_status_created\n  ON runs (status, created_at DESC);\n\nCREATE INDEX IF NOT EXISTS idx_runs_pipeline_created\n  ON runs (pipeline_id, created_at DESC);\n\nCREATE INDEX IF NOT EXISTS idx_stage_events_run_stage_at\n  ON stage_events (run_id, stage_id, at);\n\nCREATE TABLE IF NOT EXISTS stage_executions (\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  attempt INTEGER NOT NULL,\n  status TEXT NOT NULL,\n  verification_outcome TEXT NOT NULL DEFAULT 'not_run',\n  started_at TEXT,\n  finished_at TEXT,\n  envelope_json TEXT,\n  PRIMARY KEY (run_id, stage_id, attempt),\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_stage_executions_run_stage\n  ON stage_executions (run_id, stage_id, attempt);\n\nCREATE TABLE IF NOT EXISTS verification_check_results (\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  attempt INTEGER NOT NULL,\n  check_id TEXT NOT NULL,\n  check_type TEXT NOT NULL,\n  status TEXT NOT NULL,\n  started_at TEXT,\n  finished_at TEXT,\n  evidence_json TEXT,\n  PRIMARY KEY (run_id, stage_id, attempt, check_id),\n  FOREIGN KEY (run_id, stage_id, attempt)\n    REFERENCES stage_executions(run_id, stage_id, attempt)\n);\n\nCREATE INDEX IF NOT EXISTS idx_verification_check_results_execution\n  ON verification_check_results (run_id, stage_id, attempt, check_id);\n\nCREATE TABLE IF NOT EXISTS feedback_loops (\n  run_id TEXT NOT NULL,\n  loop_id TEXT NOT NULL,\n  source_stage_id TEXT NOT NULL,\n  source_attempt INTEGER NOT NULL,\n  policy_json TEXT NOT NULL,\n  state TEXT NOT NULL,\n  current_replay_id TEXT,\n  current_replay_number INTEGER,\n  deferred_send_back_json TEXT,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  PRIMARY KEY (run_id, loop_id),\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_feedback_loops_run_state\n  ON feedback_loops (run_id, state, created_at);\n\nCREATE TABLE IF NOT EXISTS feedback_replays (\n  run_id TEXT NOT NULL,\n  replay_id TEXT NOT NULL,\n  loop_id TEXT NOT NULL,\n  source_stage_id TEXT NOT NULL,\n  source_attempt INTEGER NOT NULL,\n  target_stage_id TEXT NOT NULL,\n  replay_number INTEGER NOT NULL,\n  max_replays INTEGER NOT NULL,\n  replay_session TEXT NOT NULL,\n  route_stage_ids_json TEXT NOT NULL,\n  feedback_envelope_json TEXT NOT NULL,\n  status TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  PRIMARY KEY (run_id, replay_id),\n  FOREIGN KEY (run_id, loop_id) REFERENCES feedback_loops(run_id, loop_id)\n);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_feedback_replays_loop_number\n  ON feedback_replays (run_id, loop_id, replay_number);\nCREATE INDEX IF NOT EXISTS idx_feedback_replays_run_loop\n  ON feedback_replays (run_id, loop_id, created_at);\n\nCREATE TABLE IF NOT EXISTS feedback_replay_stage_passes (\n  run_id TEXT NOT NULL,\n  replay_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  stage_attempt INTEGER NOT NULL,\n  session_origin_attempt INTEGER,\n  session_mode TEXT NOT NULL,\n  status TEXT NOT NULL,\n  started_at TEXT,\n  finished_at TEXT,\n  emitted_envelope_json TEXT,\n  PRIMARY KEY (run_id, replay_id, stage_id),\n  FOREIGN KEY (run_id, replay_id) REFERENCES feedback_replays(run_id, replay_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_feedback_replay_stage_passes_replay\n  ON feedback_replay_stage_passes (run_id, replay_id, stage_id);\n\nCREATE TABLE IF NOT EXISTS fork_generations (\n  run_id TEXT NOT NULL,\n  generation_id TEXT NOT NULL,\n  replay_id TEXT,\n  fork_parent_stage_id TEXT NOT NULL,\n  generation_number INTEGER NOT NULL,\n  clone_stage_ids_json TEXT NOT NULL,\n  status TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  PRIMARY KEY (run_id, generation_id),\n  FOREIGN KEY (run_id, replay_id) REFERENCES feedback_replays(run_id, replay_id)\n);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_fork_generations_parent_number\n  ON fork_generations (run_id, fork_parent_stage_id, generation_number);\nCREATE INDEX IF NOT EXISTS idx_fork_generations_run_replay\n  ON fork_generations (run_id, replay_id, created_at);\n";
+export declare const SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS runs (\n  run_id TEXT PRIMARY KEY,\n  pipeline_id TEXT NOT NULL,\n  task_id TEXT,\n  task_yaml TEXT NOT NULL,\n  status TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  checkout_root TEXT,\n  pipeline_dag_json TEXT,\n  git_sha TEXT,\n  ci_pr_url TEXT,\n  ci_job_url TEXT,\n  pipeline_path TEXT,\n  task_path TEXT,\n  project_root TEXT\n);\n\nCREATE TABLE IF NOT EXISTS stages (\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  status TEXT,\n  summary TEXT,\n  envelope_json TEXT,\n  started_at TEXT,\n  finished_at TEXT,\n  PRIMARY KEY (run_id, stage_id),\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE TABLE IF NOT EXISTS stage_events (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  at TEXT NOT NULL,\n  event TEXT NOT NULL,\n  payload_json TEXT,\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_runs_status_created\n  ON runs (status, created_at DESC);\n\nCREATE INDEX IF NOT EXISTS idx_runs_pipeline_created\n  ON runs (pipeline_id, created_at DESC);\n\nCREATE INDEX IF NOT EXISTS idx_stage_events_run_stage_at\n  ON stage_events (run_id, stage_id, at);\n\nCREATE TABLE IF NOT EXISTS stage_executions (\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  attempt INTEGER NOT NULL,\n  status TEXT NOT NULL,\n  verification_outcome TEXT NOT NULL DEFAULT 'not_run',\n  started_at TEXT,\n  finished_at TEXT,\n  envelope_json TEXT,\n  cost_usd REAL,\n  usage_json TEXT,\n  PRIMARY KEY (run_id, stage_id, attempt),\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_stage_executions_run_stage\n  ON stage_executions (run_id, stage_id, attempt);\n\nCREATE TABLE IF NOT EXISTS verification_check_results (\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  attempt INTEGER NOT NULL,\n  check_id TEXT NOT NULL,\n  check_type TEXT NOT NULL,\n  status TEXT NOT NULL,\n  started_at TEXT,\n  finished_at TEXT,\n  evidence_json TEXT,\n  PRIMARY KEY (run_id, stage_id, attempt, check_id),\n  FOREIGN KEY (run_id, stage_id, attempt)\n    REFERENCES stage_executions(run_id, stage_id, attempt)\n);\n\nCREATE INDEX IF NOT EXISTS idx_verification_check_results_execution\n  ON verification_check_results (run_id, stage_id, attempt, check_id);\n\nCREATE TABLE IF NOT EXISTS feedback_loops (\n  run_id TEXT NOT NULL,\n  loop_id TEXT NOT NULL,\n  source_stage_id TEXT NOT NULL,\n  source_attempt INTEGER NOT NULL,\n  policy_json TEXT NOT NULL,\n  state TEXT NOT NULL,\n  current_replay_id TEXT,\n  current_replay_number INTEGER,\n  deferred_send_back_json TEXT,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  PRIMARY KEY (run_id, loop_id),\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_feedback_loops_run_state\n  ON feedback_loops (run_id, state, created_at);\n\nCREATE TABLE IF NOT EXISTS feedback_replays (\n  run_id TEXT NOT NULL,\n  replay_id TEXT NOT NULL,\n  loop_id TEXT NOT NULL,\n  source_stage_id TEXT NOT NULL,\n  source_attempt INTEGER NOT NULL,\n  target_stage_id TEXT NOT NULL,\n  replay_number INTEGER NOT NULL,\n  max_replays INTEGER NOT NULL,\n  replay_session TEXT NOT NULL,\n  route_stage_ids_json TEXT NOT NULL,\n  feedback_envelope_json TEXT NOT NULL,\n  status TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  PRIMARY KEY (run_id, replay_id),\n  FOREIGN KEY (run_id, loop_id) REFERENCES feedback_loops(run_id, loop_id)\n);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_feedback_replays_loop_number\n  ON feedback_replays (run_id, loop_id, replay_number);\nCREATE INDEX IF NOT EXISTS idx_feedback_replays_run_loop\n  ON feedback_replays (run_id, loop_id, created_at);\n\nCREATE TABLE IF NOT EXISTS feedback_replay_stage_passes (\n  run_id TEXT NOT NULL,\n  replay_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  stage_attempt INTEGER NOT NULL,\n  session_origin_attempt INTEGER,\n  session_mode TEXT NOT NULL,\n  status TEXT NOT NULL,\n  started_at TEXT,\n  finished_at TEXT,\n  emitted_envelope_json TEXT,\n  PRIMARY KEY (run_id, replay_id, stage_id),\n  FOREIGN KEY (run_id, replay_id) REFERENCES feedback_replays(run_id, replay_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_feedback_replay_stage_passes_replay\n  ON feedback_replay_stage_passes (run_id, replay_id, stage_id);\n\nCREATE TABLE IF NOT EXISTS fork_generations (\n  run_id TEXT NOT NULL,\n  generation_id TEXT NOT NULL,\n  replay_id TEXT,\n  fork_parent_stage_id TEXT NOT NULL,\n  generation_number INTEGER NOT NULL,\n  clone_stage_ids_json TEXT NOT NULL,\n  status TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  PRIMARY KEY (run_id, generation_id),\n  FOREIGN KEY (run_id, replay_id) REFERENCES feedback_replays(run_id, replay_id)\n);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_fork_generations_parent_number\n  ON fork_generations (run_id, fork_parent_stage_id, generation_number);\nCREATE INDEX IF NOT EXISTS idx_fork_generations_run_replay\n  ON fork_generations (run_id, replay_id, created_at);\n";

package/dist/runstore/sqlite/schema.js

@@ -57,6 +57,8 @@ CREATE TABLE IF NOT EXISTS stage_executions (
   started_at TEXT,
   finished_at TEXT,
   envelope_json TEXT,
+  cost_usd REAL,
+  usage_json TEXT,
   PRIMARY KEY (run_id, stage_id, attempt),
   FOREIGN KEY (run_id) REFERENCES runs(run_id)
 );