@deksden-com/dd-flow-cli 0.4.2 → 0.5.0

package/dist/services/tooling.js

@@ -0,0 +1,285 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+import { AppError } from "../shared/errors.js";
+import { ensureDir } from "../storage/paths.js";
+const manifestRelativePath = path.join("tools", "worktrunk-manifest.json");
+const managedToolRootName = "wt";
+const manifestSchemaId = "dd-flow/managed-tool-manifest@1";
+export function worktrunkManifest() {
+    const packageRoot = findPackageRoot(path.dirname(fileURLToPath(import.meta.url)));
+    if (!packageRoot)
+        throw new AppError("tool_manifest_missing", "Cannot locate dd-flow package root", 1);
+    const file = path.join(packageRoot, manifestRelativePath);
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        validateManifest(parsed, file);
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof AppError)
+            throw error;
+        throw new AppError("tool_manifest_missing", `Managed Worktrunk manifest is unreadable: ${file}`, 1, {
+            manifest: file,
+            cause: String(error)
+        });
+    }
+}
+export function worktrunkPlatform() {
+    if (process.platform === "darwin" && process.arch === "arm64")
+        return "darwin-arm64";
+    if (process.platform === "darwin" && process.arch === "x64")
+        return "darwin-x64";
+    if (process.platform === "linux" && process.arch === "arm64")
+        return "linux-arm64";
+    if (process.platform === "linux" && process.arch === "x64")
+        return "linux-x64";
+    if (process.platform === "win32" && process.arch === "x64")
+        return "windows-x64";
+    throw new AppError("tool_platform_unsupported", "No pinned Worktrunk artifact supports this platform", 1, {
+        platform: process.platform,
+        architecture: process.arch
+    });
+}
+export function worktrunkCacheRoot(context, platform = worktrunkPlatform()) {
+    return path.join(context.ddFlowHome, "tools", managedToolRootName, worktrunkManifest().version, platform);
+}
+export function worktrunkCacheBinary(context, platform = worktrunkPlatform()) {
+    return path.join(worktrunkCacheRoot(context, platform), process.platform === "win32" ? "wt.exe" : "wt");
+}
+export function inspectManagedWorktrunk(context) {
+    try {
+        const manifest = worktrunkManifest();
+        const platform = worktrunkPlatform();
+        const root = worktrunkCacheRoot(context, platform);
+        if (!fs.existsSync(root)) {
+            return { available: false, bin: null, version: manifest.version, platform, diagnostics: ["managed_tool_not_installed"] };
+        }
+        const verified = verifyCachedWorktrunk(context, manifest, platform);
+        return { available: true, bin: verified.bin, version: manifest.version, platform, diagnostics: [] };
+    }
+    catch (error) {
+        const details = error instanceof AppError ? error.details : undefined;
+        return {
+            available: false,
+            bin: null,
+            version: "unknown",
+            platform: `${process.platform}-${process.arch}`,
+            diagnostics: [error instanceof Error ? error.message : String(error), ...(details ? [JSON.stringify(details)] : [])]
+        };
+    }
+}
+export function ensureManagedWorktrunk(context) {
+    const manifest = worktrunkManifest();
+    const platform = worktrunkPlatform();
+    const cachedRoot = worktrunkCacheRoot(context, platform);
+    if (fs.existsSync(cachedRoot))
+        return verifyCachedWorktrunk(context, manifest, platform);
+    const lockDir = `${cachedRoot}.lock`;
+    acquireLock(lockDir);
+    try {
+        if (fs.existsSync(cachedRoot))
+            return verifyCachedWorktrunk(context, manifest, platform);
+        if (context.env.DD_FLOW_TOOL_OFFLINE === "1") {
+            throw new AppError("tool_unavailable", "Pinned Worktrunk is not cached and tool acquisition is offline", 1, {
+                tool: manifest.tool,
+                version: manifest.version,
+                platform,
+                cache_root: cachedRoot,
+                artifact_url: artifactFor(manifest, platform).url,
+                next_action: "Place the verified official artifact in the managed tool cache and retry."
+            });
+        }
+        installWorktrunkArtifact(manifest, platform, cachedRoot);
+        return verifyCachedWorktrunk(context, manifest, platform);
+    }
+    finally {
+        fs.rmSync(lockDir, { recursive: true, force: true });
+    }
+}
+function installWorktrunkArtifact(manifest, platform, targetRoot) {
+    const artifact = artifactFor(manifest, platform);
+    const parent = path.dirname(targetRoot);
+    ensureDir(parent);
+    const tempRoot = fs.mkdtempSync(path.join(parent, `.wt-${process.pid}-`));
+    const archivePath = path.join(tempRoot, `worktrunk.${artifact.archive}`);
+    const extractedRoot = path.join(tempRoot, "extracted");
+    try {
+        const download = spawnSync("curl", ["--fail", "--location", "--silent", "--show-error", "--max-time", "120", "-o", archivePath, artifact.url], { encoding: "utf8" });
+        if (download.status !== 0) {
+            throw new AppError("tool_unavailable", "Unable to download the pinned Worktrunk artifact", 1, {
+                tool: manifest.tool,
+                version: manifest.version,
+                platform,
+                artifact_url: artifact.url,
+                stdout: sanitize(download.stdout),
+                stderr: sanitize(download.stderr)
+            });
+        }
+        const archiveChecksum = sha256File(archivePath);
+        if (archiveChecksum !== artifact.sha256) {
+            throw new AppError("tool_integrity_failed", "Pinned Worktrunk artifact checksum mismatch", 1, {
+                tool: manifest.tool,
+                version: manifest.version,
+                platform,
+                expected_sha256: artifact.sha256,
+                actual_sha256: archiveChecksum
+            });
+        }
+        ensureDir(extractedRoot);
+        extractArchive(archivePath, extractedRoot, artifact.archive);
+        const extractedBinary = findBinary(extractedRoot);
+        if (!extractedBinary)
+            throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive does not contain wt", 1, { platform });
+        fs.chmodSync(extractedBinary, 0o755);
+        verifyWorktrunkVersion(extractedBinary, manifest.version);
+        const binaryChecksum = sha256File(extractedBinary);
+        const stagedRoot = path.join(tempRoot, "managed");
+        ensureDir(stagedRoot);
+        const stagedBinary = path.join(stagedRoot, process.platform === "win32" ? "wt.exe" : "wt");
+        fs.copyFileSync(extractedBinary, stagedBinary);
+        fs.chmodSync(stagedBinary, 0o755);
+        fs.writeFileSync(path.join(stagedRoot, "metadata.json"), `${JSON.stringify({
+            schema_id: manifestSchemaId,
+            tool: manifest.tool,
+            version: manifest.version,
+            platform,
+            archive_sha256: artifact.sha256,
+            binary_sha256: binaryChecksum
+        }, null, 2)}\n`);
+        if (fs.existsSync(targetRoot))
+            throw new AppError("tool_integrity_failed", "Managed Worktrunk cache appeared during installation", 1, { cache_root: targetRoot });
+        fs.renameSync(stagedRoot, targetRoot);
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function verifyCachedWorktrunk(context, manifest, platform) {
+    const root = worktrunkCacheRoot(context, platform);
+    const bin = path.join(root, process.platform === "win32" ? "wt.exe" : "wt");
+    const metadataFile = path.join(root, "metadata.json");
+    if (!fs.existsSync(bin) || !fs.existsSync(metadataFile)) {
+        throw new AppError("tool_integrity_failed", "Managed Worktrunk cache is incomplete", 1, { cache_root: root });
+    }
+    let metadata;
+    try {
+        metadata = JSON.parse(fs.readFileSync(metadataFile, "utf8"));
+    }
+    catch (error) {
+        throw new AppError("tool_integrity_failed", "Managed Worktrunk cache metadata is invalid", 1, { cache_root: root, cause: String(error) });
+    }
+    const artifact = artifactFor(manifest, platform);
+    const actualBinaryChecksum = sha256File(bin);
+    if (metadata.schema_id !== manifestSchemaId ||
+        metadata.tool !== manifest.tool ||
+        metadata.version !== manifest.version ||
+        metadata.platform !== platform ||
+        metadata.archive_sha256 !== artifact.sha256 ||
+        metadata.binary_sha256 !== actualBinaryChecksum) {
+        throw new AppError("tool_integrity_failed", "Managed Worktrunk cache verification failed", 1, {
+            cache_root: root,
+            expected_version: manifest.version,
+            expected_archive_sha256: artifact.sha256,
+            actual_binary_sha256: actualBinaryChecksum
+        });
+    }
+    verifyWorktrunkVersion(bin, manifest.version);
+    return {
+        bin,
+        version: manifest.version,
+        platform,
+        archive_sha256: artifact.sha256,
+        binary_sha256: actualBinaryChecksum
+    };
+}
+function extractArchive(archive, destination, format) {
+    if (format === "tar.xz") {
+        const listing = spawnSync("tar", ["-tJf", archive], { encoding: "utf8" });
+        if (listing.status !== 0 || listing.stdout.split("\n").some(unsafeArchivePath)) {
+            throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive has an unsafe or unreadable file list", 1);
+        }
+        const extracted = spawnSync("tar", ["-xJf", archive, "-C", destination], { encoding: "utf8" });
+        if (extracted.status !== 0)
+            throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive extraction failed", 1, { stderr: sanitize(extracted.stderr) });
+        return;
+    }
+    const listing = spawnSync("unzip", ["-Z1", archive], { encoding: "utf8" });
+    if (listing.status !== 0 || listing.stdout.split("\n").some(unsafeArchivePath)) {
+        throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive has an unsafe or unreadable file list", 1);
+    }
+    const extracted = spawnSync("unzip", ["-q", archive, "-d", destination], { encoding: "utf8" });
+    if (extracted.status !== 0)
+        throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive extraction failed", 1, { stderr: sanitize(extracted.stderr) });
+}
+function findBinary(root) {
+    const expected = process.platform === "win32" ? "wt.exe" : "wt";
+    const entries = fs.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+        const candidate = path.join(root, entry.name);
+        if (entry.isFile() && entry.name === expected)
+            return candidate;
+        if (entry.isDirectory()) {
+            const nested = findBinary(candidate);
+            if (nested)
+                return nested;
+        }
+    }
+    return null;
+}
+function verifyWorktrunkVersion(bin, expected) {
+    const result = spawnSync(bin, ["--version"], { encoding: "utf8" });
+    const output = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+    if (result.status !== 0 || !output.includes(expected)) {
+        throw new AppError("tool_integrity_failed", "Managed Worktrunk version verification failed", 1, {
+            expected_version: expected,
+            status: result.status,
+            output: sanitize(output)
+        });
+    }
+}
+function artifactFor(manifest, platform) {
+    const artifact = manifest.artifacts[platform];
+    if (!artifact)
+        throw new AppError("tool_platform_unsupported", "Pinned Worktrunk manifest has no artifact for this platform", 1, { platform });
+    return artifact;
+}
+function validateManifest(value, file) {
+    if (!value || value.schema_id !== manifestSchemaId || value.tool !== "wt" || !value.version || !value.artifacts) {
+        throw new AppError("tool_manifest_invalid", `Managed Worktrunk manifest is invalid: ${file}`, 1, { manifest: file });
+    }
+}
+function acquireLock(lockDir) {
+    ensureDir(path.dirname(lockDir));
+    try {
+        fs.mkdirSync(lockDir);
+    }
+    catch {
+        throw new AppError("tool_install_locked", "Another Worktrunk installation is in progress", 1, { lock_dir: lockDir });
+    }
+}
+function sha256File(file) {
+    return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+}
+function unsafeArchivePath(value) {
+    const normalized = value.trim();
+    if (!normalized)
+        return false;
+    return path.isAbsolute(normalized) || normalized.split(/[\\/]/u).includes("..");
+}
+function sanitize(value) {
+    return value.replace(/(token|secret|password)=\S+/gi, "$1=<redacted>").slice(0, 2000);
+}
+function findPackageRoot(start) {
+    let current = path.resolve(start);
+    while (true) {
+        if (fs.existsSync(path.join(current, "package.json")))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}

package/dist/services/usage.js

@@ -12,7 +12,10 @@ export function checkpointSessionUsage(context, session, input) {
         observed_at: observedAt,
         total_tokens: result.counter?.usage.total_tokens ?? null,
         input_tokens: result.counter?.usage.input_tokens ?? null,
-        cached_input_tokens: result.counter?.usage.cached_input_tokens ?? null,
+        cached_input_tokens: result.counter?.usage.cache_read_input_tokens ?? null,
+        cache_read_input_tokens: result.counter?.usage.cache_read_input_tokens ?? null,
+        cache_write_input_tokens: result.counter?.usage.cache_write_input_tokens ?? null,
+        uncached_input_tokens: result.counter?.usage.uncached_input_tokens ?? null,
         output_tokens: result.counter?.usage.output_tokens ?? null,
         reasoning_output_tokens: result.counter?.usage.reasoning_output_tokens ?? null,
         source_kind: "codex_transcript_v1",
@@ -33,12 +36,14 @@ export function checkpointSessionUsage(context, session, input) {
     }
     context.db.run(`INSERT INTO flow_run_usage_snapshots
       (id, project_id, run_id, session_id, checkpoint, stage, stage_attempt, observed_at,
-       total_tokens, input_tokens, cached_input_tokens, output_tokens, reasoning_output_tokens,
+       total_tokens, input_tokens, cached_input_tokens, cache_read_input_tokens, cache_write_input_tokens, uncached_input_tokens,
+       output_tokens, reasoning_output_tokens,
        source_kind, token_event_at, turn_id, turn_attribution, parser_version, extraction_status, diagnostic_code, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
         snapshot.id, snapshot.project_id, snapshot.run_id, snapshot.session_id, snapshot.checkpoint, snapshot.stage,
         snapshot.stage_attempt, snapshot.observed_at, snapshot.total_tokens, snapshot.input_tokens,
-        snapshot.cached_input_tokens, snapshot.output_tokens, snapshot.reasoning_output_tokens, snapshot.source_kind,
+        snapshot.cached_input_tokens, snapshot.cache_read_input_tokens, snapshot.cache_write_input_tokens,
+        snapshot.uncached_input_tokens, snapshot.output_tokens, snapshot.reasoning_output_tokens, snapshot.source_kind,
         snapshot.token_event_at, snapshot.turn_id, snapshot.turn_attribution, snapshot.parser_version,
         snapshot.extraction_status, snapshot.diagnostic_code, observedAt
     ]);
@@ -50,20 +55,26 @@ export function checkpointRunUsage(context, input) {
     return sessions.map((session) => checkpointSessionUsage(context, session, input));
 }
 export function usageForRun(context, input) {
-    const sessions = context.db.all(`SELECT session_id, project_id, run_id, transcript_path, parent_session_id, role, aspect_id, plan_item_id, session_kind
-     FROM flow_sessions WHERE project_id = ? AND run_id = ?`, [input.projectId, input.runId]);
+    const sessions = context.db.all(`SELECT DISTINCT session_id, project_id, ? AS run_id, transcript_path, parent_session_id, role, aspect_id, plan_item_id, session_kind
+     FROM flow_sessions WHERE project_id = ? AND run_id = ?
+     UNION
+     SELECT DISTINCT f.session_id, f.project_id, ? AS run_id, f.transcript_path, f.parent_session_id, f.role, f.aspect_id, f.plan_item_id, f.session_kind
+     FROM flow_session_segments s JOIN flow_sessions f ON f.project_id = s.project_id AND f.session_id = s.session_id
+     WHERE s.project_id = ? AND s.run_id = ?`, [input.runId, input.projectId, input.runId, input.runId, input.projectId, input.runId]);
     const refreshed = sessions.map((session) => checkpointSessionUsage(context, session, { checkpoint: "manual_sync" }));
     const rows = context.db.all(`SELECT s.*, f.parent_session_id, f.role, f.aspect_id, f.plan_item_id, f.session_kind
      FROM flow_run_usage_snapshots s
      LEFT JOIN flow_sessions f ON f.project_id = s.project_id AND f.session_id = s.session_id
      WHERE s.project_id = ? AND s.run_id = ? ORDER BY s.session_id, s.observed_at, s.id`, [input.projectId, input.runId]);
     const deltas = usageDeltas(rows);
+    const segments = context.db.all(`SELECT id, session_id, run_id, protocol_id, started_at, ended_at, cwd, tool_name
+     FROM flow_session_segments WHERE project_id = ? AND run_id = ? ORDER BY started_at, id`, [input.projectId, input.runId]);
     const supported = new Set(["session", "role", "aspect", "plan-item", "stage", "protocol"]);
     const groupBy = supported.has(input.groupBy) ? input.groupBy : "session";
     const groups = new Map();
     for (const delta of deltas) {
         const key = groupKey(delta, groupBy);
-        const group = groups.get(key) ?? { tokens: zeroUsage(), snapshots: 0, statuses: {}, transition_buckets: 0 };
+        const group = groups.get(key) ?? { tokens: emptyUsage(), snapshots: 0, statuses: {}, transition_buckets: 0 };
         group.snapshots += 1;
         group.statuses[delta.extraction_status] = (group.statuses[delta.extraction_status] ?? 0) + 1;
         if (delta.usage)
@@ -81,11 +92,26 @@ export function usageForRun(context, input) {
             session_id: session.session_id, parent_session_id: session.parent_session_id ?? null, role: session.role ?? null,
             aspect_id: session.aspect_id ?? null, plan_item_id: session.plan_item_id ?? null, session_kind: session.session_kind ?? null
         })),
-        groups: [...groups.entries()].map(([key, group]) => ({ key, ...group })),
+        groups: [...groups.entries()].map(([key, group]) => ({ key, ...group, tokens: outputUsageTotals(group.tokens) })),
         deltas,
+        segments: segments.map((segment) => ({
+            segment_id: segment.id,
+            session_id: segment.session_id,
+            run_id: segment.run_id,
+            protocol_id: segment.protocol_id,
+            started_at: segment.started_at,
+            ended_at: segment.ended_at,
+            usage: segmentUsage(context, sessions.find((session) => session.session_id === segment.session_id), segment)
+        })),
         coverage: coverageForRows(rows)
     };
 }
+function segmentUsage(context, session, segment) {
+    if (!session)
+        return { status: "unavailable", diagnostic: "session_record_missing" };
+    const result = readCodexTranscriptWindow(session.transcript_path, session.session_id, segment.started_at, segment.ended_at ?? context.now());
+    return result.counter ? { status: result.status, tokens: result.counter.usage, token_event_at: result.counter.token_event_at } : { status: result.status, diagnostic: result.diagnostic ?? null };
+}
 function readCodexTranscript(transcriptPath, expectedSessionId) {
     if (!transcriptPath)
         return { status: "ephemeral_session", diagnostic: "transcript_path_missing" };
@@ -114,8 +140,8 @@ function readCodexTranscript(transcriptPath, expectedSessionId) {
             if (event.type !== "event_msg" || payload?.type !== "token_count")
                 continue;
             const info = object(payload.info);
-            const total = object(info?.total_token_usage);
-            const parsed = parseUsage(total);
+            const total = object(info?.total_token_usage) ?? object(payload?.usage) ?? object(event.usage);
+            const parsed = parseProviderUsage(total);
             if (parsed)
                 latest = { usage: parsed, token_event_at: stringValue(event.timestamp) ?? null, turn_id: nearestTurn, turn_attribution: nearestTurn ? "inferred_nearest_task_started" : "unavailable" };
         }
@@ -129,6 +155,78 @@ function readCodexTranscript(transcriptPath, expectedSessionId) {
         return { status: "malformed_source", diagnostic: "transcript_read_failed" };
     }
 }
+function readCodexTranscriptWindow(transcriptPath, expectedSessionId, startedAt, endedAt) {
+    const parsed = readTranscriptEvents(transcriptPath, expectedSessionId);
+    if (parsed.status !== "measured")
+        return parsed;
+    const from = Date.parse(startedAt);
+    const to = Date.parse(endedAt);
+    const events = parsed.events ?? [];
+    const inWindow = events.filter((event) => {
+        const at = Date.parse(event.token_event_at ?? "");
+        return !Number.isFinite(at) || (!Number.isFinite(from) || at >= from) && (!Number.isFinite(to) || at <= to);
+    });
+    const last = inWindow[inWindow.length - 1];
+    if (!last)
+        return { status: "not_yet_emitted", diagnostic: "token_count_not_in_segment" };
+    const before = events.filter((event) => Number.isFinite(from) && Number.isFinite(Date.parse(event.token_event_at ?? "")) && Date.parse(event.token_event_at ?? "") < from).at(-1);
+    const usage = before ? subtractParsedUsage(last.usage, before.usage) : last.usage;
+    return { status: "measured", counter: { ...last, usage } };
+}
+function readTranscriptEvents(transcriptPath, expectedSessionId) {
+    if (!transcriptPath)
+        return { status: "ephemeral_session", diagnostic: "transcript_path_missing" };
+    if (!fs.existsSync(transcriptPath))
+        return { status: "transcript_missing", diagnostic: "transcript_path_missing" };
+    try {
+        const lines = fs.readFileSync(transcriptPath, "utf8").split(/\r?\n/);
+        let sessionId;
+        let nearestTurn = null;
+        const events = [];
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const payload = object(event.payload);
+            if (event.type === "session_meta")
+                sessionId = stringValue(payload?.id) ?? sessionId;
+            if (event.type === "event_msg" && payload?.type === "task_started")
+                nearestTurn = stringValue(payload.turn_id) ?? nearestTurn;
+            if (event.type !== "event_msg" || payload?.type !== "token_count")
+                continue;
+            const info = object(payload.info);
+            const total = object(info?.total_token_usage) ?? object(payload?.usage) ?? object(event.usage);
+            const usage = parseProviderUsage(total);
+            if (usage)
+                events.push({ usage, token_event_at: stringValue(event.timestamp) ?? null, turn_id: nearestTurn, turn_attribution: nearestTurn ? "inferred_nearest_task_started" : "unavailable" });
+        }
+        if (sessionId && sessionId !== expectedSessionId)
+            return { status: "session_mismatch", diagnostic: "transcript_session_id_mismatch" };
+        if (events.length === 0)
+            return { status: "not_yet_emitted", diagnostic: "token_count_not_found" };
+        return { status: "measured", events };
+    }
+    catch {
+        return { status: "malformed_source", diagnostic: "transcript_read_failed" };
+    }
+}
+function subtractParsedUsage(current, previous) {
+    return {
+        total_tokens: Math.max(0, current.total_tokens - previous.total_tokens),
+        input_tokens: current.input_tokens === null || previous.input_tokens === null ? null : Math.max(0, current.input_tokens - previous.input_tokens),
+        cache_read_input_tokens: current.cache_read_input_tokens === null || previous.cache_read_input_tokens === null ? null : Math.max(0, current.cache_read_input_tokens - previous.cache_read_input_tokens),
+        cache_write_input_tokens: current.cache_write_input_tokens === null || previous.cache_write_input_tokens === null ? null : Math.max(0, current.cache_write_input_tokens - previous.cache_write_input_tokens),
+        uncached_input_tokens: current.uncached_input_tokens === null || previous.uncached_input_tokens === null ? null : Math.max(0, current.uncached_input_tokens - previous.uncached_input_tokens),
+        output_tokens: current.output_tokens === null || previous.output_tokens === null ? null : Math.max(0, current.output_tokens - previous.output_tokens),
+        reasoning_output_tokens: current.reasoning_output_tokens === null || previous.reasoning_output_tokens === null ? null : Math.max(0, current.reasoning_output_tokens - previous.reasoning_output_tokens)
+    };
+}
 function usageDeltas(rows) {
     const previous = new Map();
     return rows.map((row) => {
@@ -154,7 +252,9 @@ function subtractUsage(current, previous) {
     return {
         total_tokens: (current.total_tokens ?? 0) - (previous.total_tokens ?? 0),
         input_tokens: current.input_tokens === null || previous.input_tokens === null ? null : current.input_tokens - previous.input_tokens,
-        cached_input_tokens: current.cached_input_tokens === null || previous.cached_input_tokens === null ? null : current.cached_input_tokens - previous.cached_input_tokens,
+        cache_read_input_tokens: current.cache_read_input_tokens === null || previous.cache_read_input_tokens === null ? null : current.cache_read_input_tokens - previous.cache_read_input_tokens,
+        cache_write_input_tokens: current.cache_write_input_tokens === null || previous.cache_write_input_tokens === null ? null : current.cache_write_input_tokens - previous.cache_write_input_tokens,
+        uncached_input_tokens: current.uncached_input_tokens === null || previous.uncached_input_tokens === null ? null : current.uncached_input_tokens - previous.uncached_input_tokens,
         output_tokens: current.output_tokens === null || previous.output_tokens === null ? null : current.output_tokens - previous.output_tokens,
         reasoning_output_tokens: current.reasoning_output_tokens === null || previous.reasoning_output_tokens === null ? null : current.reasoning_output_tokens - previous.reasoning_output_tokens
     };
@@ -163,7 +263,9 @@ function counterReset(current, previous) {
     return [
         [current.total_tokens, previous.total_tokens],
         [current.input_tokens, previous.input_tokens],
-        [current.cached_input_tokens, previous.cached_input_tokens],
+        [current.cache_read_input_tokens, previous.cache_read_input_tokens],
+        [current.cache_write_input_tokens, previous.cache_write_input_tokens],
+        [current.uncached_input_tokens, previous.uncached_input_tokens],
         [current.output_tokens, previous.output_tokens],
         [current.reasoning_output_tokens, previous.reasoning_output_tokens]
     ].some(([now, before]) => typeof now === "number" && typeof before === "number" && now < before);
@@ -188,6 +290,7 @@ function coverageForRows(rows) {
 function snapshotForOutput(snapshot) {
     const safe = { ...snapshot };
     delete safe.transcript_path;
+    delete safe.cached_input_tokens;
     return { schema_id: "dd-flow/session-usage-snapshot@1", ...safe };
 }
 function sameUsageSnapshot(previous, current) {
@@ -196,38 +299,88 @@ function sameUsageSnapshot(previous, current) {
         && previous.extraction_status === current.extraction_status
         && previous.total_tokens === current.total_tokens
         && previous.input_tokens === current.input_tokens
-        && previous.cached_input_tokens === current.cached_input_tokens
+        && previous.cache_read_input_tokens === current.cache_read_input_tokens
+        && previous.cache_write_input_tokens === current.cache_write_input_tokens
+        && previous.uncached_input_tokens === current.uncached_input_tokens
         && previous.output_tokens === current.output_tokens
         && previous.reasoning_output_tokens === current.reasoning_output_tokens
         && previous.token_event_at === current.token_event_at
         && previous.turn_id === current.turn_id;
 }
-function parseUsage(value) {
+export function parseProviderUsage(value) {
     if (!value)
         return undefined;
-    const total = numberValue(value.total_tokens);
+    const total = tokenField(value, ["total_tokens"]);
+    if (total === null || total === undefined)
+        return undefined;
+    const input = tokenField(value, ["input_tokens"]);
+    const cacheRead = tokenField(value, ["cache_read_input_tokens", "cached_input_tokens"]);
+    const cacheWrite = tokenField(value, ["cache_write_input_tokens", "cache_creation_input_tokens"]);
+    const explicitUncached = tokenField(value, ["uncached_input_tokens"]);
+    const derivedUncached = explicitUncached !== undefined
+        ? explicitUncached
+        : input !== null && input !== undefined && cacheRead !== null && cacheRead !== undefined && input >= cacheRead
+            ? input - cacheRead
+            : null;
     if (total === undefined)
         return undefined;
     return {
         total_tokens: total,
-        input_tokens: numberValue(value.input_tokens) ?? null,
-        cached_input_tokens: numberValue(value.cached_input_tokens) ?? null,
-        output_tokens: numberValue(value.output_tokens) ?? null,
-        reasoning_output_tokens: numberValue(value.reasoning_output_tokens) ?? null
+        input_tokens: input ?? null,
+        cache_read_input_tokens: cacheRead ?? null,
+        cache_write_input_tokens: cacheWrite ?? null,
+        uncached_input_tokens: derivedUncached,
+        output_tokens: tokenField(value, ["output_tokens"]) ?? null,
+        reasoning_output_tokens: tokenField(value, ["reasoning_output_tokens"]) ?? null
     };
 }
 function addUsage(target, source) {
-    target.total_tokens += source.total_tokens;
-    if (source.input_tokens !== null)
-        target.input_tokens += source.input_tokens;
-    if (source.cached_input_tokens !== null)
-        target.cached_input_tokens += source.cached_input_tokens;
-    if (source.output_tokens !== null)
-        target.output_tokens += source.output_tokens;
-    if (source.reasoning_output_tokens !== null)
-        target.reasoning_output_tokens += source.reasoning_output_tokens;
-}
-function zeroUsage() { return { total_tokens: 0, input_tokens: 0, cached_input_tokens: 0, output_tokens: 0, reasoning_output_tokens: 0 }; }
+    target.total_tokens = addNullable(target.total_tokens, source.total_tokens);
+    target.input_tokens = addNullable(target.input_tokens, source.input_tokens);
+    target.cache_read_input_tokens = addNullable(target.cache_read_input_tokens, source.cache_read_input_tokens);
+    target.cache_write_input_tokens = addNullable(target.cache_write_input_tokens, source.cache_write_input_tokens);
+    target.uncached_input_tokens = addNullable(target.uncached_input_tokens, source.uncached_input_tokens);
+    target.output_tokens = addNullable(target.output_tokens, source.output_tokens);
+    target.reasoning_output_tokens = addNullable(target.reasoning_output_tokens, source.reasoning_output_tokens);
+}
+function emptyUsage() {
+    return {
+        total_tokens: undefined,
+        input_tokens: undefined,
+        cache_read_input_tokens: undefined,
+        cache_write_input_tokens: undefined,
+        uncached_input_tokens: undefined,
+        output_tokens: undefined,
+        reasoning_output_tokens: undefined
+    };
+}
+function outputUsageTotals(value) {
+    return {
+        total_tokens: value.total_tokens ?? null,
+        input_tokens: value.input_tokens ?? null,
+        cache_read_input_tokens: value.cache_read_input_tokens ?? null,
+        cache_write_input_tokens: value.cache_write_input_tokens ?? null,
+        uncached_input_tokens: value.uncached_input_tokens ?? null,
+        output_tokens: value.output_tokens ?? null,
+        reasoning_output_tokens: value.reasoning_output_tokens ?? null
+    };
+}
+function addNullable(current, next) {
+    if (current === undefined)
+        return next;
+    if (current === null || next === null)
+        return null;
+    return current + next;
+}
+function tokenField(value, keys) {
+    for (const key of keys) {
+        if (!Object.prototype.hasOwnProperty.call(value, key))
+            continue;
+        const token = numberValue(value[key]);
+        return token === undefined || token < 0 ? null : token;
+    }
+    return undefined;
+}
 function object(value) { return value && typeof value === "object" && !Array.isArray(value) ? value : undefined; }
 function stringValue(value) { return typeof value === "string" && value ? value : undefined; }
 function numberValue(value) { return typeof value === "number" && Number.isFinite(value) ? value : undefined; }

package/dist/services/version-status.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { parse as parseYaml } from "yaml";
-const canonicalOnlyFlowNames = ["mb-init.md", "mb-upgrade.md", "mb-upgrade-review.md", "mb-distill.md"];
+const canonicalOnlyFlowNames = ["mb-init.md", "mb-upgrade.md", "mb-distill.md"];
 export function resolveStatusProjectRoot(input) {
     if (input.requestedRoot) {
         const absolute = path.resolve(input.requestedRoot);