@deksden-com/dd-flow-cli 0.9.0-beta.64 → 0.9.0-beta.74

package/dist/services/run-engine-bindings.js

@@ -86,7 +86,7 @@ function isRunEngineBinding(value) {
         && typeof record.run_id === "string"
         && typeof record.project_root === "string"
         && typeof record.bound_at === "string"
-        && ["run_creation", "legacy_recovery"].includes(String(record.source))
+        && ["run_creation", "legacy_recovery", "fork_upgrade"].includes(String(record.source))
         && typeof record.reason === "string"
         && Boolean(engine && typeof engine === "object" && !Array.isArray(engine)
             && typeof engine.package_name === "string"

package/dist/services/run-fork.js

@@ -0,0 +1,124 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { createContext } from "../runtime/context.js";
+import { AppError } from "../shared/errors.js";
+import { canonicalPath } from "../storage/paths.js";
+import { installCurrentEngine, upgradeForkedRunEngine } from "./engines.js";
+import { restoreEvalRunSnapshot } from "./eval-snapshots.js";
+/** Restore a sealed stage boundary into its own home and replace only its
+ * copied engine binding.  The original snapshot and RUN are read-only. */
+export function forkRunFromSnapshot(context, input) {
+    const requestId = requireId(input.requestId, "request-id");
+    const snapshot = canonicalPath(input.snapshot);
+    const output = path.resolve(input.output);
+    if (snapshot === output || snapshot.startsWith(`${output}${path.sep}`) || output.startsWith(`${snapshot}${path.sep}`)) {
+        throw new AppError("fork_path_conflict", "Fork output must not contain or be contained by its source snapshot", 2, { snapshot, output });
+    }
+    const manifestFile = path.join(snapshot, "snapshot.json");
+    const manifest = readJson(manifestFile);
+    if (manifest.schema_id !== "dd-flow/eval-run-snapshot@5" || manifest.purpose !== "stage_entry" || typeof manifest.stage_entry !== "string" || typeof manifest.run_id !== "string") {
+        throw new AppError("fork_checkpoint_invalid", "Fork requires a sealed stage-entry snapshot", 2, { snapshot });
+    }
+    const intent = {
+        schema_id: "dd-flow/run-fork-intent@1",
+        request_id: requestId,
+        snapshot,
+        snapshot_sha256: fileHash(manifestFile),
+        engine_version: requireText(input.engineVersion, "engine-version"),
+        integrity_checksum: input.integrityChecksum ?? null,
+        target_stage: manifest.stage_entry
+    };
+    const intentFile = path.join(output, ".fork-intent.json");
+    const receiptFile = path.join(output, "fork.json");
+    if (fs.existsSync(receiptFile)) {
+        const receipt = readJson(receiptFile);
+        if (hash(receipt.intent) !== hash(intent))
+            throw new AppError("fork_request_conflict", "Fork output already belongs to another request", 1, { output });
+        return receipt;
+    }
+    if (fs.existsSync(output) && fs.readdirSync(output).length > 0) {
+        if (!fs.existsSync(intentFile) || hash(readJson(intentFile).intent) !== hash(intent))
+            throw new AppError("fork_output_not_empty", "Fork output must be empty", 2, { output });
+        const unknown = fs.readdirSync(output).filter(name => ![".fork-intent.json", "project", "dd-flow-home"].includes(name));
+        if (unknown.length)
+            throw new AppError("fork_retry_inspect_required", "Fork output contains data not owned by the interrupted fork", 1, { output, unknown });
+        for (const name of ["project", "dd-flow-home"])
+            fs.rmSync(path.join(output, name), { recursive: true, force: true });
+    }
+    fs.mkdirSync(output, { recursive: true, mode: 0o700 });
+    writeJsonAtomic(intentFile, { schema_id: "dd-flow/run-fork-intent@1", intent });
+    const projectRoot = path.join(output, "project");
+    const home = path.join(output, "dd-flow-home");
+    fs.mkdirSync(projectRoot, { recursive: true, mode: 0o700 });
+    const targetContext = createContext({ ...context.env, DD_FLOW_HOME: home, DD_FLOW_ENGINE_MODE: "1" });
+    const restored = restoreEvalRunSnapshot(targetContext, { snapshot, projectRoot });
+    const restoredContext = createContext({ ...context.env, DD_FLOW_HOME: home, DD_FLOW_ENGINE_MODE: "1" });
+    try {
+        const runHome = String(restored.run_home);
+        const previousBinding = readJson(path.join(runHome, "engine-binding.json"));
+        const lineage = {
+            schema_id: "dd-flow/run-fork-lineage@1",
+            request_id: requestId,
+            source_snapshot: snapshot,
+            source_snapshot_sha256: intent.snapshot_sha256,
+            source_run_id: manifest.run_id,
+            target_stage: manifest.stage_entry,
+            inherited_engine: previousBinding,
+            created_at: restoredContext.now()
+        };
+        writeJsonAtomic(path.join(runHome, "fork-lineage.json"), lineage);
+        // Install the immutable artifact belonging to the currently executing
+        // CLI into the new home. A different exact version must already be
+        // supplied as an installed engine artifact for this fork home.
+        installCurrentEngine(restoredContext, { forRouting: true });
+        const binding = upgradeForkedRunEngine(restoredContext, {
+            projectRoot,
+            runId: String(restored.run_id),
+            engineVersion: intent.engine_version,
+            ...(intent.integrity_checksum ? { integrityChecksum: intent.integrity_checksum } : {}),
+            reason: `Fork ${requestId} from sealed checkpoint ${intent.snapshot_sha256}.`
+        });
+        const receipt = {
+            ok: true,
+            schema_id: "dd-flow/run-fork@1",
+            status: "ready",
+            intent,
+            fork: {
+                project_root: projectRoot,
+                dd_flow_home: home,
+                run_id: restored.run_id,
+                run_home: runHome,
+                workspace_root: restored.workspace_root,
+                target_stage: manifest.stage_entry,
+                engine: binding.engine,
+                lineage_file: path.join(runHome, "fork-lineage.json")
+            },
+            next_command: `dd-flow stage start ${restored.run_id} --stage ${manifest.stage_entry} --project-root ${JSON.stringify(projectRoot)} --json`
+        };
+        writeJsonAtomic(receiptFile, receipt);
+        return receipt;
+    }
+    finally {
+        restoredContext.db.close?.();
+    }
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        throw new AppError("fork_checkpoint_invalid", "Fork metadata is not valid JSON", 2, { file, cause: String(error) });
+    }
+}
+function writeJsonAtomic(file, value) {
+    const temporary = `${file}.tmp-${process.pid}-${crypto.randomUUID()}`;
+    fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temporary, file);
+}
+function hash(value) { return crypto.createHash("sha256").update(JSON.stringify(value)).digest("hex"); }
+function fileHash(file) { return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex"); }
+function requireText(value, name) { const text = value.trim(); if (!text)
+    throw new AppError("usage", `Missing required value: ${name}`, 2); return text; }
+function requireId(value, name) { const text = requireText(value, name); if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(text))
+    throw new AppError("usage", `Invalid ${name}`, 2); return text; }

package/dist/services/run-observations.js

@@ -0,0 +1,112 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ToolObservations, replayToolJournal } from "../harness-runtime/lib/tool-observations.mjs";
+import { harnessKey } from "./harness-config.js";
+/** Evidence has ancestry, not executable ownership. Never open a source home. */
+export function runObservations(context, projectId, runId) {
+    const home = fs.realpathSync(context.ddFlowHome), sources = new Map(), reasons = [];
+    const sessions = context.db.all("SELECT session_id, provider_session_id, harness, transcript_path FROM sessions WHERE project_id = ? AND run_id = ?", [projectId, runId]);
+    const inside = (root, file) => { const p = path.relative(root, file); return p !== "" && p !== ".." && !p.startsWith(`..${path.sep}`) && !path.isAbsolute(p); };
+    const add = (id, nativeId, journal, origin, provenance, harness) => {
+        if (sources.has(id))
+            return;
+        const candidates = sessions.filter(s => (s.provider_session_id ?? s.session_id) === nativeId && (!harness || s.harness === harness));
+        if (candidates.length > 1) {
+            reasons.push("journal_session_ambiguous");
+            return;
+        }
+        const owner = candidates[0];
+        if (!owner)
+            return;
+        const source = { id, provenance, session: { harness_id: owner.harness, session_id: nativeId }, path: null, status: "unavailable" };
+        sources.set(id, source);
+        if (typeof journal !== "string" || !path.isAbsolute(journal) || !inside(origin, journal)) {
+            source.reason = "journal_outside_owned_home";
+            return;
+        }
+        source.path = path.relative(origin, journal);
+        const file = path.resolve(home, source.path);
+        try {
+            if (!inside(home, fs.realpathSync(file))) {
+                source.reason = "journal_outside_owned_home";
+                return;
+            }
+            if (!fs.statSync(file).isFile()) {
+                source.reason = "journal_not_file";
+                return;
+            }
+            source.status = "available";
+        }
+        catch {
+            source.reason = "journal_missing";
+        }
+    };
+    const controllers = (rows, origin, provenance) => {
+        for (const row of rows) {
+            if (row.project_id !== projectId || row.run_id !== runId)
+                continue;
+            try {
+                for (const session of JSON.parse(row.state_json).sessions ?? [])
+                    add(`${row.controller_id}:${session.id}`, session.id, session.journal, origin, provenance, session.profile?.harness ? harnessKey(session.profile.harness) : undefined);
+            }
+            catch {
+                reasons.push("controller_evidence_invalid");
+            }
+        }
+    };
+    if (context.db.all("SELECT 1 FROM sqlite_schema WHERE type = 'table' AND name = 'run_controllers'").length) {
+        controllers(context.db.all("SELECT controller_id, project_id, run_id, state_json FROM run_controllers WHERE project_id = ? AND run_id = ?", [projectId, runId]), home, "current");
+    }
+    const imports = path.join(home, "snapshot-imports");
+    if (fs.existsSync(imports))
+        for (const file of fs.readdirSync(imports).filter(name => name.endsWith(".json")).sort()) {
+            try {
+                const location = path.join(imports, file);
+                if (!inside(home, fs.realpathSync(location))) {
+                    reasons.push("lineage_outside_owned_home");
+                    continue;
+                }
+                const archive = JSON.parse(fs.readFileSync(location, "utf8"));
+                if (archive.schema_id !== "dd-flow/snapshot-runtime-lineage@1" || archive.run_id !== runId)
+                    continue;
+                if (typeof archive.source_runtime !== "string" || !path.isAbsolute(archive.source_runtime)) {
+                    reasons.push("lineage_source_invalid");
+                    continue;
+                }
+                controllers(archive.run_tables?.run_controllers ?? [], archive.source_runtime, "inherited");
+            }
+            catch {
+                reasons.push("lineage_evidence_invalid");
+            }
+        }
+    // Native transcript adapters need no managed controller journal.
+    for (const session of sessions)
+        if (session.transcript_path && ![...sources.values()].some(s => s.session.harness_id === session.harness && s.session.session_id === (session.provider_session_id ?? session.session_id))) {
+            add(`transcript:${session.harness}:${session.provider_session_id ?? session.session_id}`, session.provider_session_id ?? session.session_id, session.transcript_path, home, "current", session.harness);
+        }
+    const reducer = new ToolObservations();
+    for (const reason of reasons)
+        reducer.gaps.add(reason);
+    for (const source of sources.values()) {
+        if (source.status !== "available") {
+            reducer.gaps.add(source.reason ?? "journal_unavailable");
+            continue;
+        }
+        replayToolJournal(path.join(home, source.path), { harness: source.session.harness_id, rootSessionId: source.session.session_id }, reducer);
+    }
+    const expected = [...new Map(sessions.map(s => { const session = { harness_id: s.harness, session_id: s.provider_session_id ?? s.session_id }; return [JSON.stringify(session), session]; })).values()];
+    const expectedIds = new Set(expected.map(s => JSON.stringify(s)));
+    for (const [key, event] of reducer.calls)
+        if (!expectedIds.has(JSON.stringify(event.session))) {
+            reducer.calls.delete(key);
+            reducer.gaps.add("tool_session_not_bound_to_run");
+        }
+    const summary = reducer.summary();
+    const observed = new Set(summary.sessions.map(s => JSON.stringify(s.session)));
+    const missing = expected.filter(s => !observed.has(JSON.stringify(s)));
+    const completeness = missing.length || summary.completeness !== "complete" ? "partial" : "complete";
+    return { schema_id: "dd-flow/run-observations@1", home, sources: [...sources.values()], tools: { ...summary,
+            completeness, status: observed.size === 0 ? "unavailable" : completeness === "complete" ? "measured" : "partial",
+            observed_sessions: expected.length - missing.length, expected_sessions: expected.length, unavailable_sessions: missing.map(s => s.session_id), missing_sessions: missing,
+            reasons: [...new Set([...summary.reasons, ...(missing.length ? ["sessions_without_tool_observations"] : [])])] } };
+}

package/dist/services/runs.js

@@ -587,17 +587,6 @@ export function attachFlowRunStage(context, input) {
 export function withStageSettlement(context, operation) {
     return context.db.writeTransaction(operation);
 }
-/** Capture accepted inputs before asynchronous validation; compare under the
- * settlement writer reservation instead of accepting a stale read snapshot. */
-export function stageInputGuard(context, projectId, runId, readFiles) {
-    const read = () => JSON.stringify({
-        works: context.db.all("SELECT work_id, parent_work_id, task, status, result, payload_json, depends_on_json FROM works WHERE project_id = ? AND run_id = ? ORDER BY work_id", [projectId, runId]),
-        files: readFiles()
-    });
-    const accepted = read();
-    return () => { if (read() !== accepted)
-        throw new AppError("stage_inputs_changed", "Accepted stage inputs changed during validation; settle only newly validated inputs", 1, { run_id: runId, effect: "no_effect" }); };
-}
 export function completeFlowRunStage(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const run = resolveRun(context, project.id, input.runId);
@@ -620,6 +609,7 @@ export function completeFlowRunStage(context, input) {
         ...(input.data ? { data: input.data } : {}),
         ...(input.dataSchemaId ? { data_schema_id: input.dataSchemaId } : {}),
         ...(input.report ? { report: input.report } : {}),
+        ...(input.usage ? { usage: input.usage } : {}),
         ...(input.aliases && input.aliases.length > 0 ? { artifact_aliases: input.aliases } : {}),
         updated_at: now,
         ...(status === "done" || status === "waiting_for_user" || status === "blocked" || status === "failed" || status === "skipped"

package/dist/services/schema-validation.js

@@ -94,7 +94,7 @@ export function validateSchema(options) {
         throw new AppError("usage", "--schema must be a schema name such as mb-upgrade-review-data", 2);
     }
     const filePath = path.resolve(options.file);
-    const data = readJson(filePath, "input file");
+    const data = Object.hasOwn(options, "data") ? options.data : readJson(filePath, "input file");
     const schemaResolution = resolveSchema(options);
     const schema = readJson(schemaResolution.path, "schema");
     // Ajv's default export only carries the draft-07 meta-schema.  New stage

package/dist/services/stage-lifecycle.js

@@ -8,7 +8,7 @@ import { persistProtocolState, requireProtocol, readProtocolRuntimeState } from
 import { attachFlowRunStage, completeFlowRunStage, getFlowRunStatus, startFlowRun } from "./runs.js";
 import { validateSchema } from "./schema-validation.js";
 import { reconcileSessionCoverage, registerFlowSession } from "./sessions.js";
-import { usageForRun } from "./usage.js";
+import { recalculateRunUsage, usageForRun } from "./usage.js";
 import { boundCanonicalPlan } from "./plan-runtime.js";
 import { AppError } from "../shared/errors.js";
 import { planJsonPath, resolveProjectRoot } from "../storage/paths.js";
@@ -19,6 +19,16 @@ import { registerProtocol } from "./protocols.js";
 import { previewNextEntityId } from "./ids.js";
 import { hookSessionIdentity, sessionIdForHookEvent } from "./hooks.js";
 import { assertRunMutationAllowed } from "./run-recovery.js";
+function stageUsageProjection(context, view, stage, startedAt) {
+    if (!startedAt)
+        return { status: "unavailable", input_tokens: null, cached_input_tokens: null, output_tokens: null, total_tokens: null, session_count: 0, observed_at: context.now() };
+    const value = recalculateRunUsage(context, { projectId: view.run.project_id, runId: view.run.id, stage: { name: stage, startedAt, completedAt: context.now() } });
+    const totals = value.totals, coverage = value.coverage;
+    const count = (name) => typeof coverage?.[name] === "number" ? coverage[name] : 0;
+    const measured = count("measured"), other = Object.values(coverage ?? {}).reduce((total, item) => total + (typeof item === "number" ? item : 0), 0) - measured;
+    const tokens = (name) => typeof totals?.[name] === "number" ? totals[name] : null;
+    return { status: measured === 0 ? "unavailable" : other > 0 || ["input_tokens", "cache_read_input_tokens", "output_tokens", "total_tokens"].some(name => tokens(name) === null) ? "partial" : "measured", input_tokens: tokens("input_tokens"), cached_input_tokens: tokens("cache_read_input_tokens"), output_tokens: tokens("output_tokens"), total_tokens: tokens("total_tokens"), session_count: Array.isArray(value.sessions) ? value.sessions.length : 0, observed_at: typeof value.observed_at === "string" ? value.observed_at : context.now() };
+}
 const stagePromptSections = [
     "stage_identity",
     "authoritative_runtime_facts",
@@ -293,6 +303,7 @@ export function finishStage(context, input) {
         const planFinish = input.stage === "plan"
             ? preparePlanFinish(context, projectRoot, view, stageRoot)
             : undefined;
+        const stageUsage = stageUsageProjection(context, view, input.stage, existing.started_at);
         const report = buildStageReport(context, view, input.stage, status, semantic, stageRoot, lint, planFinish);
         const dataPath = path.join(stageRoot, "stage-report.json");
         const reportPath = path.join(stageRoot, "stage-report.md");
@@ -313,7 +324,8 @@ export function finishStage(context, input) {
             stageReport: htmlPath,
             data: dataPath,
             dataSchemaId: String(report.schema_id),
-            report: reportPath
+            report: reportPath,
+            usage: stageUsage
         });
         finishReceipt(receipt, { outcome: "accepted", result: { status, report: dataPath } });
         appendAudit(context, {

package/dist/services/usage.js

@@ -4,6 +4,8 @@ import { parseJsonObject } from "../shared/json.js";
 import { resolveProjectRoot } from "../storage/paths.js";
 import { registerProject, requireProjectByRoot } from "./projects.js";
 import { publicSessionIdentity } from "./session-identity.js";
+import { runObservations } from "./run-observations.js";
+import { ToolObservations, codexToolObservation } from "../harness-runtime/lib/tool-observations.mjs";
 export function ingestZcodeUsage(context, input) {
     return ingestHarnessUsage(context, input, { harness: "zcode-acp", label: "ZCode", idPrefix: "ZUSG", sourceKind: "zcode_session_usage_v1" });
 }
@@ -193,6 +195,8 @@ export function recalculateRunUsage(context, input) {
             throw error;
         }
     }
+    const observations = persistRunProjection ? runObservations(context, input.projectId, input.runId) : null;
+    const legacyTools = toolCallsForLinks(context, links, accountingAt);
     return {
         ok: true,
         schema_id: "dd-flow/run-usage@2",
@@ -207,7 +211,8 @@ export function recalculateRunUsage(context, input) {
             stopped: publicSessionIdentities(context, input.projectId, settledSessions.map((session) => session.session_id)),
             unsettled: publicSessionIdentities(context, input.projectId, unsettledSessions)
         },
-        tool_calls: toolCallsForLinks(context, links, accountingAt),
+        tool_calls: observations?.tools.observed_sessions ? observations.tools : legacyTools,
+        ...(observations ? { observations, legacy_tool_calls: legacyTools } : {}),
         coverage: rows.reduce((coverage, row) => ({ ...coverage, [row.status]: (coverage[row.status] ?? 0) + 1 }), {})
     };
 }
@@ -250,6 +255,7 @@ function publicSessionIdentities(context, projectId, storageIds) {
 }
 function toolCallsForLinks(context, links, observedAt) {
     const result = { status: "unavailable", total: 0, failures: 0, by_tool: {}, observed_sessions: 0, unavailable_sessions: [] };
+    let incomplete = false;
     const sessions = new Map();
     for (const link of links)
         sessions.set(link.session_id, [...(sessions.get(link.session_id) ?? []), link]);
@@ -262,13 +268,15 @@ function toolCallsForLinks(context, links, observedAt) {
             result.unavailable_sessions.push(sessionId);
             continue;
         }
+        if ("completeness" in parsed && parsed.completeness !== "complete")
+            incomplete = true;
         result.observed_sessions += 1;
         result.total += parsed.total;
         result.failures += parsed.failures;
         for (const [name, count] of Object.entries(parsed.by_tool))
             result.by_tool[name] = (result.by_tool[name] ?? 0) + count;
     }
-    result.status = result.observed_sessions === 0 ? "unavailable" : result.unavailable_sessions.length ? "partial" : "measured";
+    result.status = result.observed_sessions === 0 ? "unavailable" : result.unavailable_sessions.length || incomplete ? "partial" : "measured";
     return result;
 }
 function isExternalHarness(harness) { return harness === "droid-cli" || harness === "zcode-acp" || harness === "grok-acp" || harness === "opencode-server" || harness === "antigravity-cli"; }
@@ -311,9 +319,7 @@ function readToolCallsForWindows(transcriptPath, expectedSessionId, windows, obs
         return null;
     try {
         let sessionId;
-        let total = 0;
-        let failures = 0;
-        const byTool = {};
+        const tools = new ToolObservations();
         for (const line of fs.readFileSync(transcriptPath, "utf8").split(/\r?\n/)) {
             if (!line.trim())
                 continue;
@@ -322,6 +328,7 @@ function readToolCallsForWindows(transcriptPath, expectedSessionId, windows, obs
                 event = JSON.parse(line);
             }
             catch {
+                tools.gaps.add("journal_invalid_record");
                 continue;
             }
             const payload = object(event.payload);
@@ -330,20 +337,13 @@ function readToolCallsForWindows(transcriptPath, expectedSessionId, windows, obs
             if (event.type !== "response_item" || !payload)
                 continue;
             const eventAt = stringValue(event.timestamp);
-            if (eventAt && !windows.some((window) => eventInsideWindow(eventAt, window, observedAt)))
+            if (eventAt && windows.length && !windows.some((window) => eventInsideWindow(eventAt, window, observedAt)))
                 continue;
-            const type = stringValue(payload.type);
-            if (type === "function_call" || type === "custom_tool_call") {
-                const name = stringValue(payload.name) ?? "unknown";
-                byTool[name] = (byTool[name] ?? 0) + 1;
-                total += 1;
-            }
-            if ((type === "function_call_output" || type === "custom_tool_call_output") && outputIndicatesFailure(payload))
-                failures += 1;
+            tools.add(codexToolObservation(event, expectedSessionId));
         }
         if (sessionId && sessionId !== expectedSessionId)
             return null;
-        return { total, failures, by_tool: Object.fromEntries(Object.entries(byTool).sort(([left], [right]) => left.localeCompare(right))) };
+        return tools.summary();
     }
     catch {
         return null;
@@ -355,37 +355,6 @@ function eventInsideWindow(eventAt, window, observedAt) {
     const end = Date.parse(window.completed_at ?? observedAt);
     return Number.isFinite(at) && (!Number.isFinite(start) || at >= start) && (!Number.isFinite(end) || at <= end);
 }
-function outputIndicatesFailure(payload) {
-    if (payload.error === true || typeof payload.error === "string")
-        return true;
-    return containsFailure(payload.output);
-}
-function containsFailure(value) {
-    if (Array.isArray(value))
-        return value.some(containsFailure);
-    if (typeof value === "string") {
-        if (/(?:^|\n)exit=(?:[1-9]\d*)\b|Process exited with code [1-9]\d*/.test(value))
-            return true;
-        const trimmed = value.trim();
-        if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-            try {
-                return containsFailure(JSON.parse(trimmed));
-            }
-            catch {
-                return false;
-            }
-        }
-        return false;
-    }
-    const item = object(value);
-    if (!item)
-        return false;
-    if (item.ok === false || item.is_error === true || item.isError === true || item.error === true || typeof item.error === "string")
-        return true;
-    if (typeof item.exit_code === "number" && item.exit_code !== 0)
-        return true;
-    return Object.values(item).some(containsFailure);
-}
 /** RUN accounting belongs to the physical provider Session, not to every Work link. */
 function usageRowsForPhysicalSessions(context, links, observedAt, stage) {
     const sessions = new Map();
@@ -586,62 +555,26 @@ function usageReport(context, input, refresh) {
 }
 function toolCallsForSessions(sessions) {
     const result = { status: "unavailable", total: 0, failures: 0, by_tool: {}, observed_sessions: 0, unavailable_sessions: [] };
+    let incomplete = false;
     for (const session of sessions) {
         const parsed = readToolCalls(session.transcript_path, nativeSessionId(session));
         if (!parsed) {
             result.unavailable_sessions.push(session.session_id);
             continue;
         }
+        if (parsed.completeness !== "complete")
+            incomplete = true;
         result.observed_sessions += 1;
         result.total += parsed.total;
         result.failures += parsed.failures;
         for (const [name, count] of Object.entries(parsed.by_tool))
             result.by_tool[name] = (result.by_tool[name] ?? 0) + count;
     }
-    result.status = result.observed_sessions === 0 ? "unavailable" : result.unavailable_sessions.length === 0 ? "measured" : "partial";
+    result.status = result.observed_sessions === 0 ? "unavailable" : result.unavailable_sessions.length || incomplete ? "partial" : "measured";
     return result;
 }
 function readToolCalls(transcriptPath, expectedSessionId) {
-    if (!transcriptPath || !fs.existsSync(transcriptPath))
-        return null;
-    try {
-        let sessionId;
-        const byTool = {};
-        let total = 0;
-        let failures = 0;
-        for (const line of fs.readFileSync(transcriptPath, "utf8").split(/\r?\n/)) {
-            if (!line.trim())
-                continue;
-            let event;
-            try {
-                event = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            const payload = object(event.payload);
-            if (!payload)
-                continue;
-            if (event.type === "session_meta")
-                sessionId = stringValue(payload.id) ?? sessionId;
-            if (event.type !== "response_item")
-                continue;
-            const type = stringValue(payload.type);
-            if (type === "function_call" || type === "custom_tool_call") {
-                const name = stringValue(payload.name) ?? "unknown";
-                byTool[name] = (byTool[name] ?? 0) + 1;
-                total += 1;
-            }
-            if ((type === "function_call_output" || type === "custom_tool_call_output") && outputIndicatesFailure(payload))
-                failures += 1;
-        }
-        if (sessionId && sessionId !== expectedSessionId)
-            return null;
-        return { total, failures, by_tool: Object.fromEntries(Object.entries(byTool).sort(([left], [right]) => left.localeCompare(right))) };
-    }
-    catch {
-        return null;
-    }
+    return readToolCallsForWindows(transcriptPath, expectedSessionId, [], new Date().toISOString());
 }
 function segmentUsage(context, session, segment) {
     if (!session)