@tangle-network/agent-eval 0.171.0 → 0.172.0

package/dist/{statistical-heldout-UhiexnjU.d.ts → statistical-heldout-Yldkntvy.d.ts}

@@ -1,6 +1,6 @@
-import { R as Scenario, b as GenerationRecord, p as Gate, w as JudgeScore } from "./types-JHMOqZI4.js";
 import { T as EProcessState, r as SignedManifest } from "./pre-registration-DHz6P_6f.js";
 import { a as PairedPromotionDecision, d as PairedBootstrapResult, i as PairedMcNemarEvidence, r as PairedDecisionStatistic, t as PairedDecisionMethod } from "./paired-promotion-decision-CGzg0cI_.js";
+import { R as Scenario, b as GenerationRecord, p as Gate, w as JudgeScore } from "./types-nokrtr7M.js";
 //#region src/campaign/gates/sequential.d.ts
 type SequentialDecision = 'promote' | 'continue' | 'undecided-at-maxN';
 interface SequentialObservation {
@@ -292,4 +292,4 @@ declare function dimensionRegressions(candidate: Map<string, Record<string, Judg
 }): DimensionRegression[];
 //#endregion
 export { sequentialPairedGate as _, detectScale as a, pairHoldout as c, SequentialDecision as d, SequentialObservation as f, sequentialDecide as g, SequentialStreamState as h, PairedHoldout as i, SequentialDecideFn as l, SequentialPairedGateOptions as m, HeldoutSignificance as n, dimensionRegressions as o, SequentialPairedGate as p, HeldoutSignificanceOptions as r, heldoutSignificance as s, DimensionRegression as t, SequentialDecideOptions as u };
-//# sourceMappingURL=statistical-heldout-UhiexnjU.d.ts.map
+//# sourceMappingURL=statistical-heldout-Yldkntvy.d.ts.map

package/dist/{statistical-heldout-UhiexnjU.d.ts.map → statistical-heldout-Yldkntvy.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"statistical-heldout-UhiexnjU.d.ts","names":[],"sources":["../src/campaign/gates/sequential.ts","../src/campaign/gates/statistical-heldout.ts"],"mappings":";;;;KAsCY;UAEK;EACf,UAAU;;EAEV;;EAEA;;;EAGA;;UAGe;;;EAGf;;;;EAIA;;;EAGA;;EAEA;;;;EAIA;;;EAGA;;;EAGA,kBAAkB;;EAElB;;;;;;;EAOA,SAAS;;;;;;KAOC,wBAAwB;EAAkB,UAAU;;UAE/C,qBAAqB,qBAAqB,kBAAkB,WAAW,kBAC9E,KAAK,WAAW;;;;;;;;EAQxB,QAAQ,gBAAgB;;;EAGxB,SAAS;;;;;;;;;;;;;;;;iBAsPK,qBAAqB,qBAAqB,kBAAkB,WAAW,UACrF,SAAS,8BACR,qBAAqB,WAAW;UAsFlB;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;GACd;IAAQ,SAAS;;IAAyB;IAAe;;;EAE1D,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BK,iBAAiB,UAAS,0BAA+B;;;UC/axD;;EAEf;;EAEA;;EAEA;;;;;;;;;;;;;iBAcc,YACd,WAAW,YAAY,eAAe,cACtC,UAAU,YAAY,eAAe,cACrC,aAAa,aACb,SAAS,GAAG,oCACX;UAsDc;EACf,QAAQ;;;;;;;;;;;;EAYR,WAAW;;;;EAIX,iBAAiB;;;;;;;EAOjB,UAAU;;EAEV,mBAAmB;;EAEnB,SAAS;;;;EAIT;;EAEA;;EAEA;;EAEA,gBAAgB;;EAEhB;;;;EAIA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;;EAEA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6Bc,oBACd,QAAQ,eACR,OAAM,6BACL;UAkEc;EACf;;;EAGA,WAAW;;;;EAIX;;EAEA;IAAM;IAAa;;;EAEnB,mBAAmB;;EAEnB,SAAS;;EAET;;;;;EAKA;EACA;EACA;;;;;iBAMc,YAAY;;;;;;;;;;;;;;;;;;;iBAsBZ,qBACd,WAAW,YAAY,eAAe,cACtC,UAAU,YAAY,eAAe,cACrC,aAAa,aACb,8BACA;EACE;EACA;EACA;EACA;;;EAGA;IAED"}
+{"version":3,"file":"statistical-heldout-Yldkntvy.d.ts","names":[],"sources":["../src/campaign/gates/sequential.ts","../src/campaign/gates/statistical-heldout.ts"],"mappings":";;;;KAsCY;UAEK;EACf,UAAU;;EAEV;;EAEA;;;EAGA;;UAGe;;;EAGf;;;;EAIA;;;EAGA;;EAEA;;;;EAIA;;;EAGA;;;EAGA,kBAAkB;;EAElB;;;;;;;EAOA,SAAS;;;;;;KAOC,wBAAwB;EAAkB,UAAU;;UAE/C,qBAAqB,qBAAqB,kBAAkB,WAAW,kBAC9E,KAAK,WAAW;;;;;;;;EAQxB,QAAQ,gBAAgB;;;EAGxB,SAAS;;;;;;;;;;;;;;;;iBAsPK,qBAAqB,qBAAqB,kBAAkB,WAAW,UACrF,SAAS,8BACR,qBAAqB,WAAW;UAsFlB;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;GACd;IAAQ,SAAS;;IAAyB;IAAe;;;EAE1D,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BK,iBAAiB,UAAS,0BAA+B;;;UC/axD;;EAEf;;EAEA;;EAEA;;;;;;;;;;;;;iBAcc,YACd,WAAW,YAAY,eAAe,cACtC,UAAU,YAAY,eAAe,cACrC,aAAa,aACb,SAAS,GAAG,oCACX;UAsDc;EACf,QAAQ;;;;;;;;;;;;EAYR,WAAW;;;;EAIX,iBAAiB;;;;;;;EAOjB,UAAU;;EAEV,mBAAmB;;EAEnB,SAAS;;;;EAIT;;EAEA;;EAEA;;EAEA,gBAAgB;;EAEhB;;;;EAIA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;;EAEA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6Bc,oBACd,QAAQ,eACR,OAAM,6BACL;UAkEc;EACf;;;EAGA,WAAW;;;;EAIX;;EAEA;IAAM;IAAa;;;EAEnB,mBAAmB;;EAEnB,SAAS;;EAET;;;;;EAKA;EACA;EACA;;;;;iBAMc,YAAY;;;;;;;;;;;;;;;;;;;iBAsBZ,qBACd,WAAW,YAAY,eAAe,cACtC,UAAU,YAAY,eAAe,cACrC,aAAa,aACb,8BACA;EACE;EACA;EACA;EACA;;;EAGA;IAED"}

package/dist/{store-tool-spans-D_qMl2__.d.ts → store-tool-spans-BvdUbeOB.d.ts}

@@ -5,8 +5,8 @@ import { u as RunTokenUsage } from "./run-record-DQjRcYwA.js";
 import { A as SearchSpanResult, B as ViewSpansResult, D as DatasetOverview, F as TraceAnalystFilters, H as ViewTraceResult, S as BoundedTraceAnalysisStoreOptions, T as TraceAnalysisStoreContext, f as AnalystUsageReceipt, i as AnalystFinding, j as SearchTraceResult, k as QueryTracesPage, w as TraceAnalysisStore } from "./types-DMoNFDWi.js";
 import { l as RawProviderSink, o as ProviderRedactor } from "./raw-provider-sink-BU29Sh8h.js";
 import { s as TraceStore } from "./store-Cq9oOrI1.js";
-import { i as TraceAnalystLimits, r as TraceAnalysisEngineResult, t as TraceAnalysisEngine } from "./engine-CAmTUk52.js";
-import { t as TraceToolGroupName } from "./tool-groups-RGYfVWpc.js";
+import { i as TraceAnalystLimits, r as TraceAnalysisEngineResult, t as TraceAnalysisEngine } from "./engine-BfRay1qD.js";
+import { t as TraceToolGroupName } from "./tool-groups-DjwlMBvW.js";
 //#region src/trace-analyst/store-boundary.d.ts
 /** Apply the public validation, cancellation, not-found, and size rules to any adapter. */
 declare function createBoundedTraceAnalysisStore(source: TraceAnalysisStore, options?: BoundedTraceAnalysisStoreOptions): TraceAnalysisStore;
@@ -405,4 +405,4 @@ declare class ToolTraceMissingError extends CaptureIntegrityError {
 declare function toolSpansToTraceAnalysisStore(spans: readonly ToolSpan[] | null | undefined, options?: ToolSpansToTraceAnalysisStoreOptions): TraceAnalysisStore;
 //#endregion
 export { REDACTION_VERSION as A, exportRunAsOtlp as B, scoreTraceInsightReadiness as C, AnalyzeTracesResult as D, AnalyzeTracesOptions as E, OtlpFlatLine as F, ExtractedUsage as G, CaptureFetchOptions as H, OTEL_AGENT_EVAL_SCOPE as I, extractUsageFromResponse as J, SseUsageMode as K, OtlpExport as L, RedactionRule as M, redactString as N, analyzeTraces as O, redactValue as P, OtlpResourceSpans as R, planTraceInsightQuestions as S, AnalyzeTracesInput as T, captureFetchToRawSink as U, CaptureFetchContext as V, ExtractUsageFromSseOptions as W, createBoundedTraceAnalysisStore as X, extractUsageFromSse as Y, buildTraceInsightPrompt as _, ToolSpansToTraceAnalysisStoreOptions as a, domainEvidencePattern as b, TraceInsightFinding as c, TraceInsightQualityGate as d, TraceInsightQuestion as f, buildTraceInsightContext as g, TraceInsightTask as h, OtlpFileTraceStoreOptions as i, RedactionReport as j, DEFAULT_REDACTION_RULES as k, TraceInsightPanelRole as l, TraceInsightSuite as m, toolSpansToTraceAnalysisStore as n, otlpTextToTraceAnalysisStore as o, TraceInsightReadiness as p, extractUsage as q, OtlpFileTraceStore as r, TraceInsightContext as s, ToolTraceMissingError as t, TraceInsightPromptInput as u, defaultTraceInsightPanel as v, tokenizeDomainWords as w, inferDomainKeywords as x, describeTraceInsightScope as y, OtlpSpan as z };
-//# sourceMappingURL=store-tool-spans-D_qMl2__.d.ts.map
+//# sourceMappingURL=store-tool-spans-BvdUbeOB.d.ts.map

package/dist/{store-tool-spans-D_qMl2__.d.ts.map → store-tool-spans-BvdUbeOB.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"store-tool-spans-D_qMl2__.d.ts","names":[],"sources":["../src/trace-analyst/store-boundary.ts","../src/trace/extract-usage.ts","../src/trace/capture-fetch.ts","../src/trace/otel.ts","../src/trace/otlp-flat.ts","../src/trace/redact.ts","../src/trace-analyst/analyst.ts","../src/trace-analyst/insights.ts","../src/trace-analyst/store-otlp.ts","../src/trace-analyst/store-tool-spans.ts"],"mappings":"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"}
+{"version":3,"file":"store-tool-spans-BvdUbeOB.d.ts","names":[],"sources":["../src/trace-analyst/store-boundary.ts","../src/trace/extract-usage.ts","../src/trace/capture-fetch.ts","../src/trace/otel.ts","../src/trace/otlp-flat.ts","../src/trace/redact.ts","../src/trace-analyst/analyst.ts","../src/trace-analyst/insights.ts","../src/trace-analyst/store-otlp.ts","../src/trace-analyst/store-tool-spans.ts"],"mappings":"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"}

package/dist/supervisor-run/index.d.ts

@@ -1,5 +1,5 @@
-import { A as unavailable, C as SupervisorRunTreeGap, D as WorkerLogSource, E as WallDistribution, O as isUnavailable, S as SupervisorRunTree, T as Unavailable, _ as SupervisorRunNodeRole, a as OrchestrationMetrics, b as SupervisorRunRollup, c as PerWorkerRow, d as SUPERVISOR_RUN_ROLLUP_SCHEMA, f as SUPERVISOR_RUN_SCHEMA, g as SteerBreakdown, h as SpendMeasurements, i as NO_SOURCE_LIMITS, k as showMeasured, l as RoleSpend, m as SpendMeasurement, n as EconomicsMetrics, o as OutcomeMetrics, p as SourceLimits, r as Measured, s as PatchStats, t as DecisionMetrics, u as RollupCellRow, v as SupervisorRunReader, w as SupervisorRunTreeGapCode, x as SupervisorRunSources, y as SupervisorRunReport } from "../types-DeIUdzNd.js";
 import { y as RolloutSplit } from "../schema-BzWDXhOR.js";
+import { A as unavailable, C as SupervisorRunTreeGap, D as WorkerLogSource, E as WallDistribution, O as isUnavailable, S as SupervisorRunTree, T as Unavailable, _ as SupervisorRunNodeRole, a as OrchestrationMetrics, b as SupervisorRunRollup, c as PerWorkerRow, d as SUPERVISOR_RUN_ROLLUP_SCHEMA, f as SUPERVISOR_RUN_SCHEMA, g as SteerBreakdown, h as SpendMeasurements, i as NO_SOURCE_LIMITS, k as showMeasured, l as RoleSpend, m as SpendMeasurement, n as EconomicsMetrics, o as OutcomeMetrics, p as SourceLimits, r as Measured, s as PatchStats, t as DecisionMetrics, u as RollupCellRow, v as SupervisorRunReader, w as SupervisorRunTreeGapCode, x as SupervisorRunSources, y as SupervisorRunReport } from "../types-CoPUTiXb.js";
 //#region src/supervisor-run/source-facts.d.ts
 interface Tokens {
   input: number;
@@ -8,10 +8,28 @@ interface Tokens {
   cacheWrite: number;
   /** False when the event carried no cache counters at all — not "zero cached". */
   hasCache: boolean;
+  /**
+   * False only when the record carried `cacheBreakdownKnown: false` — Runtime's mark for a
+   * provider that reported a total without splitting cache reads from cache writes. The
+   * counters that ARE present are then a partial split, never a measured "zero cached".
+   */
+  breakdownKnown: boolean;
 }
 interface SpendLike {
   tokens: Tokens;
+  /**
+   * False only when the record carried `tokensKnown: false` — Runtime's mark for work that
+   * HAPPENED with an unreported token count. `tokens` then holds the known subtotal (often
+   * zero), never the measured total. An absent flag means the record is complete.
+   */
+  tokensKnown: boolean;
   usd: number;
+  /**
+   * False only when the record carried `usdKnown: false` — work that HAPPENED at a price the
+   * provider never reported. `usd` then holds a catalog estimate or zero, never a measured
+   * price. An absent flag means the record is complete.
+   */
+  usdKnown: boolean;
 }
 interface SpawnRow {
   /** Zero-based row among parsed journal objects. */
@@ -104,14 +122,29 @@ interface SupervisorTreeFacts {
   readonly workerSpawns: readonly SpawnRow[];
   readonly workerCloses: readonly CloseRow[];
   readonly brain: {
+    /**
+     * Summed over the root's metered rows that reported a token count. A row Runtime marked
+     * `tokensKnown: false` is EXCLUDED and counted in `tokensUnknownCount` instead, because
+     * its `tokens` field holds a known subtotal — folding it in would price unreported work
+     * at zero tokens.
+     */
     tokensIn: number;
     tokensOut: number;
     cacheRead: number;
     cacheWrite: number;
     /** False when no metered event carried cache counters — not "nothing cached". */
     hasCache: boolean;
+    /** False when any folded metered row declared `cacheBreakdownKnown: false`. */
+    cacheBreakdownKnown: boolean;
+    /** Root metered rows that reported a token count, and rows that did not. */
+    tokensKnownCount: number;
+    tokensUnknownCount: number;
+    /** Summed over the root's metered rows that reported a price, on the same rule. */
     usd: number;
-    /** Root-attributed metered events only — exactly the rows summed into this object. */
+    /** Root metered rows that reported a price, and rows Runtime marked `usdKnown: false`. */
+    usdKnownCount: number;
+    usdUnknownCount: number;
+    /** Root-attributed metered events only — every row this object folded or counted. */
     meteredCount: number;
   };
   readonly workerLogs: ReadonlyMap<string, WorkerLogFacts>;

package/dist/supervisor-run/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/supervisor-run/source-facts.ts","../../src/supervisor-run/analyze.ts","../../src/supervisor-run/claude-code-reader.ts","../../src/supervisor-run/integrity-types.ts","../../src/supervisor-run/integrity.ts","../../src/supervisor-run/loops-reader.ts","../../src/supervisor-run/render.ts","../../src/supervisor-run/rollout-nodes.ts","../../src/supervisor-run/runtime-reader.ts"],"mappings":";;;UAwBU;EACR;EACA;EACA;EACA;;EAEA;;UAGQ;EACR,QAAQ;EACR;;UAgFe;;EAEf;EACA;EACA;EACA;;EAEA,MAAM;;EAEN;;EAEA;EACA;;EAEA;EACA;;UAGe;EACf;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA,OAAO;;EAEP;;UAGe;;EAEf;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;EACA,eAAe;EACf,uBAAuB;;UAGR;;EAEf;EACA;;UAGe;;EAEf;;EAEA;EACA;;;;;;UAOe;WACN;WACA,iBAAiB;WACjB,iBAAiB;WACjB,uBAAuB;WACvB,uBAAuB;WACvB;IACP;IACA;IACA;IACA;;IAEA;IACA;;IAEA;;WAEO,YAAY,oBAAoB;;WAEhC,wBAAwB;;WAExB;;;;;;;;;WASA;;WAEA;;;;;;WAMA,0BAA0B,SAAS;;;;;;;WAOnC;;WAEA,gBAAgB;;WAEhB,OAAO;WACP;WACA;;;;;;WAMA;WACA;;;;;;;;;;;;;;;;;;KAmDC;iBAiFI,oBAAoB,KAAK,uBAAuB;;;;;;;iBC5UhD,4BACd,KAAK,sBACL,qBACC;;iBAktBa,WAAW,eAAe;;;;;;iBA+C1B,qBAAqB,kBAAkB,wBAAwB;;;UChvB9D;;WAEN;;;;;WAKA;WACA;WACA;WACA;WACA;WACA;WACA;;;;;;iBAmOW,4BACpB,MAAM,0BACL,QAAQ;;iBAiUK,8BAA8B,MAAM,0BAA0B;;;cCnoBjE;KAED;KAEA;KAKA;UAmCK;WACN;WACA;;UAGM;WACN,MAAM;WACN;WACA,UAAU;WACV;WACA;WACA;WACA,mBAAmB;WACnB;WACA,WAAW,SAAS;;UAGd;WACN,eAAe;WACf;WACA;WACA,MAAM;WACN,iBAAiB;;UAGX;;WAEN;;;;;;;;iBC5BK,8BACd,OAAO,uBAAuB,mBAC9B,UAAS,gCACR;;;;;;;iBCDmB,uBAAuB,aAAa;UAUzC;;WAEN;;WAEA;;WAEA;;WAEA;;;;;;;iBAQW,uBACpB,gBACA,OAAM,qBACL,QAAQ;;iBAmKK,yBACd,gBACA,OAAM,qBACL;;;;;;iBAkCmB,qBACpB,gBAAgB,sBAAsB,sBACtC,OAAM,qBACL,QAAQ;UAgBM,kCAAkC;;WAExC;;WAEA;;;;;;WAMA;;;;;;;;iBASW,yBACpB,gBACA,OAAM,4BACL,QAAQ;;;;;iBA0CW,6BACpB,gBACA,OAAM,4BACL,QAAQ;;;;;;iBAgBW,sBACpB,gBACA,OAAM;EAA8B;IACnC,QAAQ;;;;;;;iBA+BW,sBAAsB,eAAe;;;;;;;iBCzY3C,4BAA4B,GAAG;iBAiC/B,4BAA4B,GAAG;iBA+K/B,+BACd,QAAQ,qBACR;;;UC9Le;;WAEN;;WAEA,QAAQ;;WAER;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;;WAEA;;;;;;;iBAwBK,0BACd,KAAK,sBACL,OAAM,2BACL;;;UCsUc;;;;;;WAMN;;;;;;;;;;;;;;;;iBAsDW,yBACpB,gBACA,OAAM,uBACL,QAAQ;;iBAkEK,2BACd,gBACA,OAAM,uBACL;;iBAKmB,0BAA0B,iBAAiB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/supervisor-run/source-facts.ts","../../src/supervisor-run/analyze.ts","../../src/supervisor-run/claude-code-reader.ts","../../src/supervisor-run/integrity-types.ts","../../src/supervisor-run/integrity.ts","../../src/supervisor-run/loops-reader.ts","../../src/supervisor-run/render.ts","../../src/supervisor-run/rollout-nodes.ts","../../src/supervisor-run/runtime-reader.ts"],"mappings":";;;UAwBU;EACR;EACA;EACA;EACA;;EAEA;;;;;;EAMA;;UAGe;EACf,QAAQ;;;;;;EAMR;EACA;;;;;;EAMA;;UAmFe;;EAEf;EACA;EACA;EACA;;EAEA,MAAM;;EAEN;;EAEA;EACA;;EAEA;EACA;;UAGe;EACf;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA,OAAO;;EAEP;;UAGe;;EAEf;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;EACA,eAAe;EACf,uBAAuB;;UAGR;;EAEf;EACA;;UAGe;;EAEf;;EAEA;EACA;;;;;;UAOe;WACN;WACA,iBAAiB;WACjB,iBAAiB;WACjB,uBAAuB;WACvB,uBAAuB;WACvB;;;;;;;IAOP;IACA;IACA;IACA;;IAEA;;IAEA;;IAEA;IACA;;IAEA;;IAEA;IACA;;IAEA;;WAEO,YAAY,oBAAoB;;WAEhC,wBAAwB;;WAExB;;;;;;;;;WASA;;WAEA;;;;;;WAMA,0BAA0B,SAAS;;;;;;;WAOnC;;WAEA,gBAAgB;;WAEhB,OAAO;WACP;WACA;;;;;;WAMA;WACA;;;;;;;;;;;;;;;;;;KAmDC;iBAiFI,oBAAoB,KAAK,uBAAuB;;;;;;;iBC9WhD,4BACd,KAAK,sBACL,qBACC;;iBAo2Ba,WAAW,eAAe;;;;;;iBA+C1B,qBAAqB,kBAAkB,wBAAwB;;;UCp4B9D;;WAEN;;;;;WAKA;WACA;WACA;WACA;WACA;WACA;WACA;;;;;;iBAmOW,4BACpB,MAAM,0BACL,QAAQ;;iBAiUK,8BAA8B,MAAM,0BAA0B;;;cCnoBjE;KAED;KAEA;KAKA;UAmCK;WACN;WACA;;UAGM;WACN,MAAM;WACN;WACA,UAAU;WACV;WACA;WACA;WACA,mBAAmB;WACnB;WACA,WAAW,SAAS;;UAGd;WACN,eAAe;WACf;WACA;WACA,MAAM;WACN,iBAAiB;;UAGX;;WAEN;;;;;;;;iBC5BK,8BACd,OAAO,uBAAuB,mBAC9B,UAAS,gCACR;;;;;;;iBCDmB,uBAAuB,aAAa;UAUzC;;WAEN;;WAEA;;WAEA;;WAEA;;;;;;;iBAQW,uBACpB,gBACA,OAAM,qBACL,QAAQ;;iBAmKK,yBACd,gBACA,OAAM,qBACL;;;;;;iBAkCmB,qBACpB,gBAAgB,sBAAsB,sBACtC,OAAM,qBACL,QAAQ;UAgBM,kCAAkC;;WAExC;;WAEA;;;;;;WAMA;;;;;;;;iBASW,yBACpB,gBACA,OAAM,4BACL,QAAQ;;;;;iBA0CW,6BACpB,gBACA,OAAM,4BACL,QAAQ;;;;;;iBAgBW,sBACpB,gBACA,OAAM;EAA8B;IACnC,QAAQ;;;;;;;iBA+BW,sBAAsB,eAAe;;;;;;;iBCzY3C,4BAA4B,GAAG;iBAiC/B,4BAA4B,GAAG;iBA+K/B,+BACd,QAAQ,qBACR;;;UC9Le;;WAEN;;WAEA,QAAQ;;WAER;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;;WAEA;;;;;;;iBAwBK,0BACd,KAAK,sBACL,OAAM,2BACL;;;UC6Uc;;;;;;WAMN;;;;;;;;;;;;;;;;iBAsDW,yBACpB,gBACA,OAAM,uBACL,QAAQ;;iBAkEK,2BACd,gBACA,OAAM,uBACL;;iBAKmB,0BAA0B,iBAAiB"}

package/dist/supervisor-run/index.js

@@ -1,6 +1,6 @@
 import { o as summarizeNumberSeries } from "../descriptive-1V17A-qa.js";
 import { c as parseClaudeEntries, n as findOpencodeSessionsByDirectory, r as openOpencodeDb, t as DEFAULT_OPENCODE_DB, u as transcriptFromEntries } from "../opencode-sqlite-eK6HW6dr.js";
-import { a as parseJsonl, c as SUPERVISOR_RUN_INTEGRITY_SCHEMA, i as parseJson, n as supervisorRunRolloutLines, o as parseSupervisorTree, r as asRecord, s as workerSourceKey, t as analyzeSupervisorRunIntegrity } from "../integrity-CyWSSoQS.js";
+import { a as parseJsonl, c as SUPERVISOR_RUN_INTEGRITY_SCHEMA, i as parseJson, n as supervisorRunRolloutLines, o as parseSupervisorTree, r as asRecord, s as workerSourceKey, t as analyzeSupervisorRunIntegrity } from "../integrity-BWywb34E.js";
 import { basename, dirname, join } from "node:path";
 import { appendFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
 //#region src/supervisor-run/types.ts
@@ -35,6 +35,7 @@ const SUPERVISOR_RUN_ROLLUP_SCHEMA = "tangle.supervisor-run-rollup@1";
 * (`loops-reader.ts` is one).
 */
 const NO_CACHE_COUNTERS = "the journal carries no cache-token counters for this role";
+const NO_CACHE_BREAKDOWN = "Runtime recorded cacheBreakdownKnown:false — the provider reported a total without splitting cache reads from writes";
 /**
 * Analyze already-read supervisor-run bytes. Pure and synchronous: same bytes
 * in, same report out (modulo `generatedAt`, which `now` pins in tests).
@@ -232,7 +233,7 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
 		if (c.verdict !== null) settledVerdicts[c.verdict] = (settledVerdicts[c.verdict] ?? 0) + 1;
 	}
 	const verdictLimit = src.limits.workerVerdicts;
-	const acceptedLimit = verdictLimit ?? src.limits.deliverables;
+	const deliverablesLimit = src.limits.deliverables;
 	let accepted = 0;
 	let emptyPass = 0;
 	let evidenceBytes = 0;
@@ -243,7 +244,7 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
 		const spawn = spawnForSource(w);
 		const passed = (spawn === null ? null : closeById.get(spawn.id) ?? null)?.valid ?? f?.passed ?? null;
 		if (passed !== null) sourceVerdicts.push(passed);
-		if (passed === true) if ((w.patchBytes ?? f?.finishedPatchBytes ?? 0) > 0) accepted += 1;
+		if (passed === true) if (deliverablesLimit !== null || (w.patchBytes ?? f?.finishedPatchBytes ?? 0) > 0) accepted += 1;
 		else emptyPass += 1;
 	}
 	const settledCloses = workerCloses.filter((close) => close.kind === "settled");
@@ -255,9 +256,9 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
 	const decision = {
 		settledByStatus: haveJournal ? settledByStatus : gap("settledByStatus", journalMissing),
 		settledVerdicts: verdictLimit !== null ? unavailable(verdictLimit) : haveJournal ? settledVerdicts : unavailable(journalMissing),
-		accepted: acceptedLimit !== null ? gap("accepted", acceptedLimit) : src.workers === null ? unavailable(workersGapReason) : accepted,
+		accepted: verdictLimit !== null ? gap("accepted", verdictLimit) : src.workers === null ? unavailable(workersGapReason) : accepted,
 		rejected: rejectedLimit === null ? rejected : unavailable(rejectedLimit),
-		emptyPass: acceptedLimit !== null ? gap("emptyPass", acceptedLimit) : src.workers === null ? unavailable(workersGapReason) : emptyPass,
+		emptyPass: verdictLimit !== null ? gap("emptyPass", verdictLimit) : deliverablesLimit !== null ? gap("emptyPass", deliverablesLimit) : src.workers === null ? unavailable(workersGapReason) : emptyPass,
 		observeThenRespawn: haveJournal ? observeThenRespawn : unavailable(journalMissing),
 		respawnWithoutEvidence: haveJournal ? respawnWithoutEvidence : unavailable(journalMissing),
 		reviewActions: src.workers === null ? unavailable(workersGapReason) : queuedGapReason === null ? steerQueuedTotal + upLegMessages : unavailable(queuedGapReason),
@@ -265,41 +266,78 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
 	};
 	const rootChildIds = new Set(workerSpawns.filter((spawn) => spawn.parent === rootId).map((spawn) => spawn.id));
 	const rootChildCloses = workerCloses.filter((close) => rootChildIds.has(close.id));
-	const journalWorkerIn = rootChildCloses.reduce((a, c) => a + c.spend.tokens.input, 0);
-	const journalWorkerOut = rootChildCloses.reduce((a, c) => a + c.spend.tokens.output, 0);
-	const journalWorkerUsd = rootChildCloses.reduce((a, c) => a + c.spend.usd, 0);
+	const rootChildSpends = rootChildCloses.filter((close) => close.hasSpend);
+	const workerUsdUnknownNodes = rootChildSpends.filter((close) => !close.spend.usdKnown).map((close) => close.id);
+	const workerTokensUnknownNodes = rootChildSpends.filter((close) => !close.spend.tokensKnown).map((close) => close.id);
+	const workerTokenSpends = rootChildSpends.filter((close) => close.spend.tokensKnown);
+	const journalWorkerIn = workerTokenSpends.reduce((a, c) => a + c.spend.tokens.input, 0);
+	const journalWorkerOut = workerTokenSpends.reduce((a, c) => a + c.spend.tokens.output, 0);
+	const journalWorkerUsd = rootChildSpends.filter((close) => close.spend.usdKnown).reduce((a, c) => a + c.spend.usd, 0);
+	const usdUnknownIds = new Set(workerCloses.filter((close) => close.hasSpend && !close.spend.usdKnown).map((c) => c.id));
 	const workerUsdById = /* @__PURE__ */ new Map();
-	for (const c of workerCloses) workerUsdById.set(c.id, (workerUsdById.get(c.id) ?? 0) + c.spend.usd);
+	for (const c of workerCloses) {
+		if (usdUnknownIds.has(c.id)) continue;
+		workerUsdById.set(c.id, (workerUsdById.get(c.id) ?? 0) + c.spend.usd);
+	}
 	const labelById = new Map(workerSpawns.map((spawn) => [spawn.id, spawn.label]));
+	const usdUnknownLabels = new Set([...usdUnknownIds].map((id) => labelById.get(id)).filter((l) => l !== void 0));
 	const workerUsdByLabel = /* @__PURE__ */ new Map();
 	for (const close of workerCloses) {
 		const label = labelById.get(close.id);
-		if (label === void 0) continue;
+		if (label === void 0 || usdUnknownLabels.has(label)) continue;
 		workerUsdByLabel.set(label, (workerUsdByLabel.get(label) ?? 0) + close.spend.usd);
 	}
+	const brainUsdUnknownNodes = tree.brain.usdUnknownCount > 0 && rootId !== null ? [rootId] : [];
+	const brainTokensUnknownNodes = tree.brain.tokensUnknownCount > 0 && rootId !== null ? [rootId] : [];
+	const usdKnownRecords = tree.brain.usdKnownCount + rootChildSpends.filter((close) => close.spend.usdKnown).length;
+	const usdUnknownRecords = tree.brain.usdUnknownCount + workerUsdUnknownNodes.length;
+	const usdUnknownNodes = [...brainUsdUnknownNodes, ...workerUsdUnknownNodes];
+	const NAMED_NODE_LIMIT = 5;
+	const nameNodes = (nodes) => {
+		if (nodes.length === 0) return "";
+		const shown = nodes.slice(0, NAMED_NODE_LIMIT);
+		const rest = nodes.length - shown.length;
+		return ` (${shown.join(", ")}${rest === 0 ? "" : ` +${rest} more`})`;
+	};
+	const unpriced = (unknown, total, nodes) => `Runtime recorded usdKnown:false on ${unknown} of ${total} spend record(s)${nameNodes(nodes)}`;
+	const unreportedTokens = (unknown, total, nodes) => `Runtime recorded tokensKnown:false on ${unknown} of ${total} spend record(s)${nameNodes(nodes)}`;
+	const usdPartial = usdKnownRecords > 0 && usdUnknownRecords > 0;
+	const usdAllUnknown = usdKnownRecords === 0 && usdUnknownRecords > 0;
+	const brainTokensUnreported = tree.brain.tokensUnknownCount === 0 ? null : unreportedTokens(tree.brain.tokensUnknownCount, tree.brain.meteredCount, brainTokensUnknownNodes);
+	const brainUsdUnreported = tree.brain.usdKnownCount > 0 || tree.brain.usdUnknownCount === 0 ? null : unpriced(tree.brain.usdUnknownCount, tree.brain.meteredCount, brainUsdUnknownNodes);
+	const workerUsdUnreported = workerUsdUnknownNodes.length === 0 || workerUsdUnknownNodes.length < rootChildSpends.length ? null : unpriced(workerUsdUnknownNodes.length, rootChildSpends.length, workerUsdUnknownNodes);
 	const sq = src.harnessWorkerTokens;
 	const harnessGapReason = src.harnessMissingReason ?? "harness session store unavailable and journal settled spend is 0";
 	const workerTokenLimit = src.limits.workerTokens;
-	const workerIn = workerTokenLimit !== null ? gap("workers.tokensIn", workerTokenLimit) : sq !== null ? journalWorkerIn + sq.input : haveJournal ? journalWorkerIn : gap("workers.tokensIn", harnessGapReason);
-	const workerOut = workerTokenLimit !== null ? unavailable(workerTokenLimit) : sq !== null ? journalWorkerOut + sq.output : haveJournal ? journalWorkerOut : unavailable(harnessGapReason);
+	const workerTokensUnreported = workerTokensUnknownNodes.length === 0 ? null : unreportedTokens(workerTokensUnknownNodes.length, rootChildSpends.length, workerTokensUnknownNodes);
+	const workerIn = workerTokenLimit !== null ? gap("workers.tokensIn", workerTokenLimit) : workerTokensUnreported !== null ? gap("workers.tokensIn", workerTokensUnreported) : sq !== null ? journalWorkerIn + sq.input : haveJournal ? journalWorkerIn : gap("workers.tokensIn", harnessGapReason);
+	const workerOut = workerTokenLimit !== null ? unavailable(workerTokenLimit) : workerTokensUnreported !== null ? unavailable(workerTokensUnreported) : sq !== null ? journalWorkerOut + sq.output : haveJournal ? journalWorkerOut : unavailable(harnessGapReason);
 	const stateResult = asRecord(state?.result);
 	const stateUsd = typeof stateResult.spentUsd === "number" ? stateResult.spentUsd : null;
 	const resultSpentTotal = asRecord(result?.spentTotal);
 	const resultCloseUsd = typeof resultSpentTotal.usd === "number" && Number.isFinite(resultSpentTotal.usd) ? resultSpentTotal.usd : null;
 	const closeUsd = stateUsd ?? resultCloseUsd;
 	const usdLimit = src.limits.spendUsd;
-	const totalUsd = usdLimit !== null ? gap("totalUsd", usdLimit) : stateUsd !== null ? round(stateUsd, 6) : haveJournal ? round(tree.brain.usd + journalWorkerUsd, 6) : gap("totalUsd", journalMissing);
-	const journalSpendRecords = tree.brain.meteredCount + rootChildCloses.filter((close) => close.hasSpend).length;
-	const journalDerivedAvailable = usdLimit === null && haveJournal;
-	const closeRecordAvailable = usdLimit === null && closeUsd !== null;
+	const closeUsdUnreported = stateUsd === null && resultCloseUsd !== null && resultSpentTotal.usdKnown === false;
+	const usdUnreportedReason = unpriced(usdUnknownRecords, usdKnownRecords + usdUnknownRecords, usdUnknownNodes);
+	const totalUsd = usdLimit !== null ? gap("totalUsd", usdLimit) : stateUsd !== null ? round(stateUsd, 6) : !haveJournal ? gap("totalUsd", journalMissing) : usdUnknownRecords > 0 ? gap("totalUsd", usdUnreportedReason) : round(tree.brain.usd + journalWorkerUsd, 6);
+	const journalSpendRecords = usdKnownRecords;
+	const journalDerivedAvailable = usdLimit === null && haveJournal && !usdAllUnknown;
+	const closeRecordAvailable = usdLimit === null && closeUsd !== null && !closeUsdUnreported;
 	const spend = {
 		journalDerived: {
-			usd: journalDerivedAvailable ? round(tree.brain.usd + journalWorkerUsd, 6) : unavailable(usdLimit ?? journalMissing),
-			records: journalDerivedAvailable ? journalSpendRecords : 0
+			usd: journalDerivedAvailable ? round(tree.brain.usd + journalWorkerUsd, 6) : unavailable(usdLimit ?? (haveJournal ? usdUnreportedReason : journalMissing)),
+			records: journalDerivedAvailable ? journalSpendRecords : 0,
+			unknownRecords: usdLimit === null && haveJournal ? usdUnknownRecords : 0,
+			partial: journalDerivedAvailable && usdPartial,
+			unknownNodes: usdLimit === null && haveJournal ? usdUnknownNodes : []
 		},
 		closeRecord: {
-			usd: closeRecordAvailable ? round(closeUsd, 6) : unavailable(usdLimit ?? "no close record: neither state.json result.spentUsd nor result.json spentTotal.usd is present"),
-			records: closeRecordAvailable ? 1 : 0
+			usd: closeRecordAvailable ? round(closeUsd, 6) : unavailable(usdLimit ?? (closeUsdUnreported ? "close record incomplete: result.json spentTotal.usdKnown is false" : "no close record: neither state.json result.spentUsd nor result.json spentTotal.usd is present")),
+			records: closeRecordAvailable ? 1 : 0,
+			unknownRecords: closeUsdUnreported ? 1 : 0,
+			partial: false,
+			unknownNodes: closeUsdUnreported && rootId !== null ? [rootId] : []
 		}
 	};
 	const perWorker = (src.workers ?? []).map((w) => {
@@ -322,8 +360,8 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
 			failure: close?.reason ?? null,
 			infra: close?.infra ?? null,
 			wallMs: f?.started != null && f.finishedAt != null ? f.finishedAt - f.started : journalWallMs,
-			tokensIn: w.tokensIn ?? (close?.hasSpend ? close.spend.tokens.input : null),
-			tokensOut: w.tokensOut ?? (close?.hasSpend ? close.spend.tokens.output : null),
+			tokensIn: w.tokensIn ?? (close?.hasSpend === true && close.spend.tokensKnown ? close.spend.tokens.input : null),
+			tokensOut: w.tokensOut ?? (close?.hasSpend === true && close.spend.tokensKnown ? close.spend.tokens.output : null),
 			usd: usdLimit !== null ? null : w.workerId === void 0 ? workerUsdByLabel.get(w.label) ?? null : workerUsdById.get(w.workerId) ?? null,
 			patchBytes: w.patchBytes ?? f?.finishedPatchBytes ?? null,
 			passed,
@@ -335,12 +373,12 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
 	const managerTokenLimit = src.limits.managerTokens;
 	const economics = {
 		brain: {
-			tokensIn: managerTokenLimit !== null ? gap("brain.tokensIn", managerTokenLimit) : haveJournal ? tree.brain.tokensIn : gap("brain.tokensIn", journalMissing),
-			tokensOut: managerTokenLimit !== null ? unavailable(managerTokenLimit) : haveJournal ? tree.brain.tokensOut : unavailable(journalMissing),
-			usd: usdLimit !== null ? unavailable(usdLimit) : haveJournal ? round(tree.brain.usd, 6) : unavailable(journalMissing),
-			cacheRead: managerTokenLimit !== null ? unavailable(managerTokenLimit) : !haveJournal ? unavailable(journalMissing) : tree.brain.hasCache ? tree.brain.cacheRead : unavailable(NO_CACHE_COUNTERS),
-			cacheWrite: managerTokenLimit !== null ? unavailable(managerTokenLimit) : !haveJournal ? unavailable(journalMissing) : tree.brain.hasCache ? tree.brain.cacheWrite : unavailable(NO_CACHE_COUNTERS),
-			source: managerTokenLimit ?? (haveJournal ? `journal metered events (n=${tree.brain.meteredCount})` : journalMissing)
+			tokensIn: managerTokenLimit !== null ? gap("brain.tokensIn", managerTokenLimit) : !haveJournal ? gap("brain.tokensIn", journalMissing) : brainTokensUnreported !== null ? gap("brain.tokensIn", brainTokensUnreported) : tree.brain.tokensIn,
+			tokensOut: managerTokenLimit !== null ? unavailable(managerTokenLimit) : !haveJournal ? unavailable(journalMissing) : brainTokensUnreported !== null ? unavailable(brainTokensUnreported) : tree.brain.tokensOut,
+			usd: usdLimit !== null ? unavailable(usdLimit) : !haveJournal ? unavailable(journalMissing) : brainUsdUnreported !== null ? unavailable(brainUsdUnreported) : round(tree.brain.usd, 6),
+			cacheRead: managerTokenLimit !== null ? unavailable(managerTokenLimit) : !haveJournal ? unavailable(journalMissing) : brainTokensUnreported !== null ? unavailable(brainTokensUnreported) : !tree.brain.hasCache ? unavailable(NO_CACHE_COUNTERS) : tree.brain.cacheBreakdownKnown ? tree.brain.cacheRead : unavailable(NO_CACHE_BREAKDOWN),
+			cacheWrite: managerTokenLimit !== null ? unavailable(managerTokenLimit) : !haveJournal ? unavailable(journalMissing) : brainTokensUnreported !== null ? unavailable(brainTokensUnreported) : !tree.brain.hasCache ? unavailable(NO_CACHE_COUNTERS) : tree.brain.cacheBreakdownKnown ? tree.brain.cacheWrite : unavailable(NO_CACHE_BREAKDOWN),
+			source: managerTokenLimit ?? (haveJournal ? `journal metered events (n=${tree.brain.meteredCount})${tree.brain.usdKnownCount > 0 && tree.brain.usdUnknownCount > 0 ? ` — ${tree.brain.usdUnknownCount} unpriced` : ""}` : journalMissing)
 		},
 		brainTruncations: src.brainLog === null ? gap("brain.brainTruncations", src.brainLogMissingReason ?? (src.supRunDir === null ? "no supervisor run dir under <ws>/.agent/supervisor (or legacy <ws>/.loops/supervisor)" : "brain.jsonl absent — loops predates the brain-call tap, so truncation cannot be ruled out")) : brainCalls.filter((c) => c.finish_reason === "length").length,
 		workers: {
@@ -348,12 +386,12 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
 			tokensOut: workerOut,
 			cacheRead: workerTokenLimit !== null ? unavailable(workerTokenLimit) : sq?.cacheRead !== void 0 ? sq.cacheRead : unavailable(NO_CACHE_COUNTERS),
 			cacheWrite: workerTokenLimit !== null ? unavailable(workerTokenLimit) : sq?.cacheWrite !== void 0 ? sq.cacheWrite : unavailable(NO_CACHE_COUNTERS),
-			usd: usdLimit !== null ? unavailable(usdLimit) : haveJournal ? round(journalWorkerUsd, 6) : unavailable(journalMissing),
-			source: workerTokenLimit !== null ? workerTokenLimit : sq !== null ? `journal settled spend + ${sq.store} sessions (n=${sq.sessions})` : `journal settled spend only — ${src.harnessMissingReason ?? "harness session store unavailable"}`
+			usd: usdLimit !== null ? unavailable(usdLimit) : !haveJournal ? unavailable(journalMissing) : workerUsdUnreported !== null ? unavailable(workerUsdUnreported) : round(journalWorkerUsd, 6),
+			source: `${workerTokenLimit !== null ? workerTokenLimit : sq !== null ? `journal settled spend + ${sq.store} sessions (n=${sq.sessions})` : `journal settled spend only — ${src.harnessMissingReason ?? "harness session store unavailable"}`}${workerUsdUnknownNodes.length > 0 && workerUsdUnknownNodes.length < rootChildSpends.length ? ` — ${workerUsdUnknownNodes.length} unpriced` : ""}`
 		},
 		spend,
 		totalUsd,
-		totalUsdSource: usdLimit !== null ? usdLimit : stateUsd !== null ? `state.json result.spentUsd${rootChildCloses.length > 0 && journalWorkerUsd === 0 ? " — brain-priced only; worker CLI inference is unpriced (see worker token counts)" : ""}` : haveJournal ? "journal metered + settled usd" : journalMissing,
+		totalUsdSource: usdLimit !== null ? usdLimit : stateUsd !== null ? `state.json result.spentUsd${rootChildCloses.length > 0 && journalWorkerUsd === 0 ? " — brain-priced only; worker CLI inference is unpriced (see worker token counts)" : ""}` : !haveJournal ? journalMissing : usdUnknownRecords > 0 ? usdUnreportedReason : "journal metered + settled usd",
 		costPerAcceptedPatchUsd: isUnavailable(totalUsd) ? unavailable(totalUsd.unavailable) : isUnavailable(decision.accepted) ? unavailable(decision.accepted.unavailable) : decision.accepted === 0 ? unavailable("no accepted worker patch (cost has no denominator)") : round(totalUsd / decision.accepted, 6),
 		workerWallMsDistribution: wallDistribution === null ? unavailable(src.workers === null ? workersGapReason : "no worker start/finish pairs captured") : wallDistribution,
 		perWorker: src.workers === null ? unavailable(workersGapReason) : perWorker
@@ -1158,6 +1196,16 @@ function renderSupervisorRollupMarkdown(rollup, title = "Round rollup") {
 * supervisor-run analyzer. Runtime stores profile identity below `identity`
 * and does not emit Eval's role field, so this boundary projects those fields
 * without changing Runtime's journal dialect.
+*
+* The run's terminal status is Runtime's own `result.json` `kind` — `winner`,
+* `no-winner`, or whatever a later arm is called — read verbatim. The reader
+* does not decide which kinds count: a kind it refuses is a run that recorded
+* its outcome and got reported as having none.
+*
+* `usdKnown: false` / `tokensKnown: false` on ONE record is not a limit of this
+* store. The store recorded every other record completely, so the flags travel
+* through to the analyzer per record, which reports the measured nodes and
+* names the unreported ones.
 */
 const JOURNAL_FILE = "spawn-journal.jsonl";
 const RESULT_FILE = "result.json";
@@ -1328,7 +1376,6 @@ function sourceLimits(root, events, workerIds) {
 		const terminal = settledById.get(id);
 		return terminal?.length !== 1 || terminal[0]?.kind !== "settled" || spendRecord(terminal[0]?.spent) === null;
 	});
-	const unknownUsd = [...rootMeters.map((event) => spendRecord(event.spend)), ...closes.filter((event) => event.kind === "settled").map((event) => spendRecord(event.spent))].filter((spend) => spend !== null).some((spend) => spend.usdKnown === false);
 	const missingVerdicts = [...workerIds].filter((id) => {
 		const terminal = settledById.get(id)?.[0];
 		if (terminal?.kind !== "settled") return true;
@@ -1337,13 +1384,13 @@ function sourceLimits(root, events, workerIds) {
 	return {
 		managerTokens: rootMeterReason,
 		workerTokens: incompleteWorkers.length === 0 ? null : `${incompleteWorkers.length}/${workerIds.size} child invocation(s) lack one settled spend record`,
-		spendUsd: rootMeterReason !== null ? rootMeterReason : unknownUsd ? "Runtime recorded usdKnown:false for at least one spend" : incompleteWorkers.length > 0 ? "at least one child invocation lacks a settled spend record" : null,
+		spendUsd: rootMeterReason !== null ? rootMeterReason : incompleteWorkers.length > 0 ? "at least one child invocation lacks a settled spend record" : null,
 		workerVerdicts: missingVerdicts.length === 0 ? null : `${missingVerdicts.length}/${workerIds.size} child invocation(s) lack a structured validity verdict`,
 		deliverables: workerIds.size === 0 ? null : "Runtime FileRunContext does not retain per-child delivered patches"
 	};
 }
 function runtimeState(root, startedAt, result, trajectory, resultPath, trajectoryPath) {
-	const resultKind = result?.kind === "completed" || result?.kind === "interrupted" ? result.kind : null;
+	const resultKind = result === null ? null : nonEmptyString(result.kind);
 	if (resultKind !== null && result !== null) {
 		const resultRoot = nonEmptyString(record(result.tree)?.root);
 		if (resultRoot === null) throw new Error(`${resultPath}: Runtime ${resultKind} result has no tree.root`);
@@ -1352,10 +1399,8 @@ function runtimeState(root, startedAt, result, trajectory, resultPath, trajector
 	if (trajectory !== null && nonEmptyString(trajectory.root) === null) throw new Error(`${trajectoryPath}: Runtime trajectory has no root`);
 	if (typeof trajectory?.root === "string" && trajectory.root !== root) throw new Error(`${trajectoryPath}: root ${JSON.stringify(trajectory.root)} does not match journal root ${JSON.stringify(root)}`);
 	if (trajectory !== null && !Array.isArray(trajectory.nodes)) throw new Error(`${trajectoryPath}: Runtime trajectory nodes must be an array`);
-	let status = null;
-	if (resultKind === "completed") status = "completed";
-	else if (resultKind === "interrupted") status = "interrupted";
-	else if (Array.isArray(trajectory?.nodes)) {
+	let status = resultKind;
+	if (status === null && Array.isArray(trajectory?.nodes)) {
 		const rootNodes = trajectory.nodes.map((node) => record(node)).filter((node) => node?.id === root);
 		if (rootNodes.length > 1) throw new Error(`${trajectoryPath}: Runtime trajectory contains duplicate root nodes`);
 		status = nonEmptyString(rootNodes[0]?.status);