@wildorder/nightshift 0.15.0 → 0.17.0

package/dist/prompt-telemetry.js

@@ -0,0 +1,112 @@
+/**
+ * Deterministic, model-free measurement of what a brief actually asked a
+ * provider to read (WS-03, SC-07) — taken at assembly time, before any
+ * provider is involved. Pure and side-effect-free throughout.
+ */
+export const PROMPT_COMPONENT_SIZE_KIND = "prompt-component-size";
+/**
+ * A coarse, deterministic bytes-to-tokens heuristic (~4 UTF-8 bytes per
+ * token of English prose) — an estimate, never mistaken for a
+ * provider-reported count, hence always emitted with `coverage: "estimated"`.
+ */
+function estimateTokensFromBytes(bytes) {
+    return Math.ceil(bytes / 4);
+}
+function sizeOf(label, bytes) {
+    return { label, bytes, estimatedTokens: estimateTokensFromBytes(bytes) };
+}
+export function createBriefBuilder() {
+    const lines = [];
+    const segments = [];
+    return {
+        push(label, ...newLines) {
+            if (newLines.length === 0)
+                return;
+            segments.push({ label, start: lines.length });
+            lines.push(...newLines);
+        },
+        join() {
+            return lines.join("\n");
+        },
+        components() {
+            const bytesByLabel = new Map();
+            segments.forEach((segment, index) => {
+                const end = index + 1 < segments.length ? segments[index + 1].start : lines.length;
+                const slice = lines.slice(segment.start, end);
+                const text = (segment.start === 0 ? "" : "\n") + slice.join("\n");
+                const bytes = Buffer.byteLength(text, "utf8");
+                bytesByLabel.set(segment.label, (bytesByLabel.get(segment.label) ?? 0) + bytes);
+            });
+            return [...bytesByLabel.entries()].map(([label, bytes]) => sizeOf(label, bytes));
+        },
+    };
+}
+/**
+ * Two points per component — exact bytes (`observed`) and the derived
+ * estimated-token figure (`estimated`) — never a compound object on one
+ * point, per WS-03's scalar-per-fact vocabulary.
+ */
+export function promptComponentSizePoints(sizes, dimensions) {
+    return sizes.flatMap((size) => [
+        {
+            kind: PROMPT_COMPONENT_SIZE_KIND,
+            label: size.label,
+            coverage: "observed",
+            value: size.bytes,
+            unit: "bytes",
+            dimensions,
+        },
+        {
+            kind: PROMPT_COMPONENT_SIZE_KIND,
+            label: size.label,
+            coverage: "estimated",
+            value: size.estimatedTokens,
+            unit: "tokens",
+            dimensions,
+        },
+    ]);
+}
+/**
+ * The reclaimed-bytes point for dependency specs demoted to a one-line stub
+ * because the included set exceeded the author's dependency-spec budget
+ * (§2.3) — the bytes a demoted spec would have cost, not bytes the brief
+ * actually spent, so it is measured and emitted separately from
+ * `promptComponentSizePoints`'s totality-checked set rather than folded into
+ * it. `undefined` when nothing was demoted — an unexercised seam emits
+ * nothing, never a fabricated zero.
+ */
+export function demotedDependenciesPoint(demotedIds, reclaimedBytes, dimensions) {
+    if (demotedIds.length === 0)
+        return undefined;
+    return {
+        kind: PROMPT_COMPONENT_SIZE_KIND,
+        label: "demoted-dependencies",
+        coverage: "observed",
+        value: reclaimedBytes,
+        unit: "bytes",
+        detail: demotedIds.join(","),
+        dimensions,
+    };
+}
+/**
+ * The exact UTF-8 bytes a reviewer did not see at one of the three
+ * char-based clip seams — measured from the actual full and shown strings,
+ * never inferred from the char limit or a boolean. `seam` names the call
+ * site (e.g. `"test-critique-diff"`, `"decider-diff"`,
+ * `"whole-program-diff"`) and becomes `clipped-input:<seam>`'s label.
+ */
+export function clippedInputPoint(seam, full, shown, dimensions) {
+    const fullBytes = Buffer.byteLength(full, "utf8");
+    const shownBytes = Buffer.byteLength(shown, "utf8");
+    const droppedBytes = Math.max(0, fullBytes - shownBytes);
+    return {
+        kind: PROMPT_COMPONENT_SIZE_KIND,
+        label: `clipped-input:${seam}`,
+        coverage: "observed",
+        value: droppedBytes,
+        unit: "bytes",
+        ...(droppedBytes > 0 ? { detail: "clipped" } : {}),
+        dimensions,
+    };
+}
+//# sourceMappingURL=prompt-telemetry.js.map

package/dist/prompt-telemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-telemetry.js","sourceRoot":"","sources":["../src/prompt-telemetry.ts"],"names":[],"mappings":"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"}

package/dist/provider-telemetry.d.ts

@@ -0,0 +1,106 @@
+import type { Dimensions, Coverage, EvidenceReference, PointObservationInput } from "./run-analytics.js";
+/**
+ * Provider-neutral normalization of a Claude `--output-format stream-json`
+ * transcript into coverage-labelled facts (WS-03, SC-08). Kept apart from
+ * `agent-runner.ts` so the normalizer is unit-testable against fixtures
+ * without spawning anything; `agent-runner.ts`'s demultiplexer feeds this
+ * module's accumulator the same already-parsed events it routes for
+ * commands/denials, so production never parses the stream twice.
+ *
+ * The one rule every field here answers to: absent or unsupported telemetry
+ * is `{ coverage: "unavailable" }` with no `value` — never a measured zero.
+ */
+export declare const PROVIDER_TELEMETRY_KIND: "provider-telemetry";
+/** A numeric fact with its observability label. `value` is absent whenever `coverage` is `"unavailable"`. */
+export interface Measured {
+    coverage: Coverage;
+    value?: number;
+    unit?: string;
+}
+/** A string-valued fact (model identity, provider label) with its observability label. */
+export interface MeasuredString {
+    coverage: Coverage;
+    value?: string;
+}
+/** One `compact_boundary` event, when the stream exposes one. */
+export interface CompactionOccurrence {
+    tokensBefore: Measured;
+    at: Measured;
+}
+/**
+ * The internal, in-memory normalization of one spawn's provider telemetry.
+ * Never persisted as-is — `providerTelemetryPoints` fans it out into one
+ * scalar `PointObservationInput` per measured fact.
+ */
+export interface NormalizedTelemetry {
+    provider: MeasuredString;
+    model: MeasuredString;
+    configuredModel: MeasuredString;
+    inputTokens: Measured;
+    outputTokens: Measured;
+    cacheReadTokens: Measured;
+    cacheCreationTokens: Measured;
+    reasoningTokens: Measured;
+    contextCapacityTokens: Measured;
+    peakContextOccupancyTokens: Measured;
+    compactions: CompactionOccurrence[];
+    compactionCount: Measured;
+    continuationTurns: Measured;
+    toolCalls: Measured;
+    fileActivity: {
+        reads: Measured;
+        writes: Measured;
+        edits: Measured;
+    };
+    commandOutputBytes: Measured;
+    costUsd?: Measured;
+}
+/**
+ * Parses `--model <value>` and `--model=<value>` out of a derived
+ * invocation's argv — free operator-authored args routinely carry an
+ * explicit model override even though `AgentConfig` has no dedicated model
+ * property (SC-05).
+ */
+export declare function parseConfiguredModel(args: readonly string[]): MeasuredString;
+/**
+ * A coarse provider label derived from the configured command when the
+ * stream itself exposes no model — an inference from the invocation, never
+ * a provider-reported fact, hence `"estimated"`.
+ */
+export declare function providerLabelFromCommand(command: string | undefined): MeasuredString;
+interface TelemetryAccumulatorOptions {
+    /** Precomputed from the derived invocation's argv (SC-05). */
+    configuredModel: MeasuredString;
+    /** Precomputed from the derived invocation's command, for the provider fallback. */
+    commandProviderGuess: MeasuredString;
+}
+export interface TelemetryAccumulator {
+    observeEvent(event: unknown): void;
+    finish(flags: {
+        observed: boolean;
+        corrupted: boolean;
+    }): NormalizedTelemetry;
+}
+/**
+ * A pure, non-throwing, stateful accumulator fed one already-parsed
+ * stream-json event at a time. `agent-runner.ts`'s demultiplexer routes each
+ * event to both its own command/denial routing and this accumulator's
+ * `observeEvent`, so the underlying text is parsed exactly once in
+ * production; `normalizeClaudeTelemetry` below wraps the same accumulator
+ * with its own line-splitting for standalone fixture-driven tests.
+ */
+export declare function createTelemetryAccumulator(options: TelemetryAccumulatorOptions): TelemetryAccumulator;
+/**
+ * Demultiplexes a whole captured stream-json string in one call, purely for
+ * fixture-driven tests — production feeds `createTelemetryAccumulator`
+ * directly from `agent-runner.ts`'s single event-parsing pass so the raw
+ * text is never parsed twice.
+ */
+export declare function normalizeClaudeTelemetry(raw: string, options?: {
+    configuredArgs?: readonly string[];
+    command?: string;
+}): NormalizedTelemetry;
+/** One point per SC-08-enumerated metric, scalar and coverage-labelled, never a fabricated zero for a metric the stream did not expose. */
+export declare function providerTelemetryPoints(telemetry: NormalizedTelemetry, dimensions: Partial<Dimensions>, evidence: EvidenceReference[]): PointObservationInput[];
+export {};
+//# sourceMappingURL=provider-telemetry.d.ts.map

package/dist/provider-telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-telemetry.d.ts","sourceRoot":"","sources":["../src/provider-telemetry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEzG;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,uBAAuB,EAAG,oBAA6B,CAAC;AAErE,6GAA6G;AAC7G,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,0FAA0F;AAC1F,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,iEAAiE;AACjE,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,QAAQ,CAAC;IACvB,EAAE,EAAE,QAAQ,CAAC;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,cAAc,CAAC;IACzB,KAAK,EAAE,cAAc,CAAC;IACtB,eAAe,EAAE,cAAc,CAAC;IAChC,WAAW,EAAE,QAAQ,CAAC;IACtB,YAAY,EAAE,QAAQ,CAAC;IACvB,eAAe,EAAE,QAAQ,CAAC;IAC1B,mBAAmB,EAAE,QAAQ,CAAC;IAC9B,eAAe,EAAE,QAAQ,CAAC;IAC1B,qBAAqB,EAAE,QAAQ,CAAC;IAChC,0BAA0B,EAAE,QAAQ,CAAC;IACrC,WAAW,EAAE,oBAAoB,EAAE,CAAC;IACpC,eAAe,EAAE,QAAQ,CAAC;IAC1B,iBAAiB,EAAE,QAAQ,CAAC;IAC5B,SAAS,EAAE,QAAQ,CAAC;IACpB,YAAY,EAAE;QAAE,KAAK,EAAE,QAAQ,CAAC;QAAC,MAAM,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,QAAQ,CAAA;KAAE,CAAC;IACrE,kBAAkB,EAAE,QAAQ,CAAC;IAC7B,OAAO,CAAC,EAAE,QAAQ,CAAC;CACpB;AAuBD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,cAAc,CAa5E;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,cAAc,CASpF;AAiBD,UAAU,2BAA2B;IACnC,8DAA8D;IAC9D,eAAe,EAAE,cAAc,CAAC;IAChC,oFAAoF;IACpF,oBAAoB,EAAE,cAAc,CAAC;CACtC;AAED,MAAM,WAAW,oBAAoB;IACnC,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IACnC,MAAM,CAAC,KAAK,EAAE;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,mBAAmB,CAAC;CAC/E;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,2BAA2B,GAAG,oBAAoB,CAqOrG;AAMD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE;IAAE,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GACrE,mBAAmB,CA+BrB;AAED,2IAA2I;AAC3I,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,mBAAmB,EAC9B,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,EAC/B,QAAQ,EAAE,iBAAiB,EAAE,GAC5B,qBAAqB,EAAE,CAkEzB"}

package/dist/provider-telemetry.js

@@ -0,0 +1,423 @@
+/**
+ * Provider-neutral normalization of a Claude `--output-format stream-json`
+ * transcript into coverage-labelled facts (WS-03, SC-08). Kept apart from
+ * `agent-runner.ts` so the normalizer is unit-testable against fixtures
+ * without spawning anything; `agent-runner.ts`'s demultiplexer feeds this
+ * module's accumulator the same already-parsed events it routes for
+ * commands/denials, so production never parses the stream twice.
+ *
+ * The one rule every field here answers to: absent or unsupported telemetry
+ * is `{ coverage: "unavailable" }` with no `value` — never a measured zero.
+ */
+export const PROVIDER_TELEMETRY_KIND = "provider-telemetry";
+const UNAVAILABLE = { coverage: "unavailable" };
+const UNAVAILABLE_STRING = { coverage: "unavailable" };
+function observedNumber(value, unit) {
+    return { coverage: "observed", value, unit };
+}
+function estimatedNumber(value, unit) {
+    return { coverage: "estimated", value, unit };
+}
+function incompleteNumber(value, unit) {
+    return { coverage: "incomplete", value, unit };
+}
+/** Downgrades an observed/estimated tally to `incomplete` when the stream lost a mid-stream line; leaves anything already unavailable alone. */
+function maybeIncomplete(measured, corrupted) {
+    if (!corrupted || measured.coverage === "unavailable")
+        return measured;
+    return { ...measured, coverage: "incomplete" };
+}
+/**
+ * Parses `--model <value>` and `--model=<value>` out of a derived
+ * invocation's argv — free operator-authored args routinely carry an
+ * explicit model override even though `AgentConfig` has no dedicated model
+ * property (SC-05).
+ */
+export function parseConfiguredModel(args) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === undefined)
+            continue;
+        const next = args[i + 1];
+        if (arg === "--model" && typeof next === "string") {
+            return { coverage: "observed", value: next };
+        }
+        if (arg.startsWith("--model=")) {
+            return { coverage: "observed", value: arg.slice("--model=".length) };
+        }
+    }
+    return UNAVAILABLE_STRING;
+}
+/**
+ * A coarse provider label derived from the configured command when the
+ * stream itself exposes no model — an inference from the invocation, never
+ * a provider-reported fact, hence `"estimated"`.
+ */
+export function providerLabelFromCommand(command) {
+    if (command === undefined || command.trim() === "")
+        return UNAVAILABLE_STRING;
+    const base = command
+        .replaceAll("\\", "/")
+        .split("/")
+        .pop()
+        ?.replace(/\.(cmd|exe|bat|sh)$/iu, "");
+    if (base === undefined || base.trim() === "")
+        return UNAVAILABLE_STRING;
+    return { coverage: "estimated", value: base };
+}
+/** The text of a `tool_result` block, whether the CLI sent it as a string or as content blocks. */
+function toolResultBytes(block) {
+    if (typeof block.content === "string")
+        return Buffer.byteLength(block.content, "utf8");
+    if (Array.isArray(block.content)) {
+        const texts = block.content
+            .filter((part) => part?.type === "text" && typeof part.text === "string")
+            .map((part) => part.text);
+        if (texts.length === 0)
+            return undefined;
+        return Buffer.byteLength(texts.join("\n"), "utf8");
+    }
+    return undefined;
+}
+const FILE_TOOL_KEYS = { Read: "reads", Write: "writes", Edit: "edits" };
+/**
+ * A pure, non-throwing, stateful accumulator fed one already-parsed
+ * stream-json event at a time. `agent-runner.ts`'s demultiplexer routes each
+ * event to both its own command/denial routing and this accumulator's
+ * `observeEvent`, so the underlying text is parsed exactly once in
+ * production; `normalizeClaudeTelemetry` below wraps the same accumulator
+ * with its own line-splitting for standalone fixture-driven tests.
+ */
+export function createTelemetryAccumulator(options) {
+    let streamModel;
+    let toolCallCount = 0;
+    let reads = 0;
+    let writes = 0;
+    let edits = 0;
+    let commandOutputBytes = 0;
+    let hadOrphanToolResult = false;
+    const toolNameById = new Map();
+    let reasoningTokens;
+    const compactions = [];
+    // Final `result`-event figures, captured once.
+    let sawResultEvent = false;
+    let inputTokens;
+    let outputTokens;
+    let cacheReadTokens;
+    let cacheCreationTokens;
+    let numTurns;
+    let costUsd;
+    let contextCapacityTokens;
+    let peakContextOccupancy;
+    function observeEvent(event) {
+        try {
+            if (event === null || typeof event !== "object")
+                return;
+            const record = event;
+            if (record.type === "system" && record.subtype === "init") {
+                if (typeof record.model === "string")
+                    streamModel = record.model;
+                return;
+            }
+            if (record.type === "system" && record.subtype === "thinking_tokens") {
+                if (typeof record.estimated_tokens === "number")
+                    reasoningTokens = record.estimated_tokens;
+                return;
+            }
+            if (record.type === "system" && record.subtype === "compact_boundary") {
+                const preTokens = typeof record.pre_tokens === "number" ? observedNumber(record.pre_tokens, "tokens") : UNAVAILABLE;
+                let at = UNAVAILABLE;
+                if (typeof record.timestamp === "string") {
+                    const parsed = Date.parse(record.timestamp);
+                    if (!Number.isNaN(parsed))
+                        at = observedNumber(parsed, "ms-since-epoch");
+                }
+                else if (typeof record.turn === "number") {
+                    at = observedNumber(record.turn, "turn");
+                }
+                compactions.push({ tokensBefore: preTokens, at });
+                return;
+            }
+            if (record.type === "assistant") {
+                const content = record.message?.content;
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block?.type !== "tool_use")
+                            continue;
+                        toolCallCount += 1;
+                        const name = typeof block.name === "string" ? block.name : undefined;
+                        const id = typeof block.id === "string" ? block.id : undefined;
+                        if (name !== undefined && id !== undefined)
+                            toolNameById.set(id, name);
+                        if (name !== undefined && name in FILE_TOOL_KEYS) {
+                            const key = FILE_TOOL_KEYS[name];
+                            if (key === "reads")
+                                reads += 1;
+                            else if (key === "writes")
+                                writes += 1;
+                            else
+                                edits += 1;
+                        }
+                    }
+                }
+                return;
+            }
+            if (record.type === "user") {
+                const content = record.message?.content;
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block?.type !== "tool_result")
+                            continue;
+                        const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : undefined;
+                        const toolName = toolUseId === undefined ? undefined : toolNameById.get(toolUseId);
+                        if (toolName === undefined) {
+                            hadOrphanToolResult = true;
+                            continue;
+                        }
+                        if (toolName !== "Bash")
+                            continue;
+                        const bytes = toolResultBytes(block);
+                        if (bytes !== undefined)
+                            commandOutputBytes += bytes;
+                    }
+                }
+                return;
+            }
+            if (record.type === "result") {
+                sawResultEvent = true;
+                if (typeof record.num_turns === "number")
+                    numTurns = record.num_turns;
+                if (typeof record.total_cost_usd === "number")
+                    costUsd = record.total_cost_usd;
+                const usage = record.usage;
+                if (usage) {
+                    if (typeof usage.input_tokens === "number")
+                        inputTokens = usage.input_tokens;
+                    if (typeof usage.output_tokens === "number")
+                        outputTokens = usage.output_tokens;
+                    if (typeof usage.cache_read_input_tokens === "number")
+                        cacheReadTokens = usage.cache_read_input_tokens;
+                    if (typeof usage.cache_creation_input_tokens === "number") {
+                        cacheCreationTokens = usage.cache_creation_input_tokens;
+                    }
+                    const iterations = usage.iterations;
+                    if (Array.isArray(iterations)) {
+                        let peak;
+                        let anyIterationPartial = false;
+                        for (const iteration of iterations) {
+                            const fields = [
+                                iteration.input_tokens,
+                                iteration.output_tokens,
+                                iteration.cache_read_input_tokens,
+                                iteration.cache_creation_input_tokens,
+                            ];
+                            // An iteration exposing none of the four occupancy fields (e.g.
+                            // `{}`) contributes no usable measurement at all — folding it
+                            // in via numberOr0 would invent a fabricated 0 that could win
+                            // the max, misreporting "the provider observed zero occupancy"
+                            // for an iteration the provider told us nothing about. Skip it
+                            // rather than let it participate in the max.
+                            if (!fields.some((field) => typeof field === "number")) {
+                                anyIterationPartial = true;
+                                continue;
+                            }
+                            // An iteration with only *some* of the four fields present is
+                            // still counted (using 0 for the fields it does lack), but the
+                            // result can undercount that iteration's true occupancy, so the
+                            // overall peak is downgraded to "incomplete" rather than
+                            // "observed" below.
+                            if (!fields.every((field) => typeof field === "number"))
+                                anyIterationPartial = true;
+                            const occupancy = fields.reduce((sum, field) => sum + numberOr0(field), 0);
+                            if (peak === undefined || occupancy > peak)
+                                peak = occupancy;
+                        }
+                        if (peak !== undefined)
+                            peakContextOccupancy = { value: peak, incomplete: anyIterationPartial };
+                    }
+                }
+                const modelUsage = record.modelUsage;
+                if (modelUsage) {
+                    const key = streamModel !== undefined && modelUsage[streamModel] ? streamModel : Object.keys(modelUsage)[0];
+                    const entry = key === undefined ? undefined : modelUsage[key];
+                    if (entry && typeof entry.contextWindow === "number")
+                        contextCapacityTokens = entry.contextWindow;
+                    if (costUsd === undefined && entry && typeof entry.costUSD === "number")
+                        costUsd = entry.costUSD;
+                }
+            }
+        }
+        catch {
+            // The accumulator is total and non-throwing (SC-13): one malformed
+            // event never poisons every fact collected so far.
+        }
+    }
+    function finish(flags) {
+        // Model/provider precedence (SC-05) does not gate on whether the stream
+        // itself parsed: `streamModel` is only ever set from an observed stream,
+        // so this is a no-op widening for the observed branch and, for a
+        // non-NDJSON or crashed spawn, still honors an explicit `--model` in the
+        // invocation args and a command-derived provider guess rather than
+        // discarding facts the invocation itself already gave us.
+        const model = streamModel !== undefined
+            ? { coverage: "observed", value: streamModel }
+            : options.configuredModel.value !== undefined
+                ? { coverage: "observed", value: options.configuredModel.value }
+                : UNAVAILABLE_STRING;
+        const provider = streamModel !== undefined ? { coverage: "observed", value: "claude" } : options.commandProviderGuess;
+        if (!flags.observed) {
+            return {
+                provider,
+                model,
+                configuredModel: options.configuredModel,
+                inputTokens: UNAVAILABLE,
+                outputTokens: UNAVAILABLE,
+                cacheReadTokens: UNAVAILABLE,
+                cacheCreationTokens: UNAVAILABLE,
+                reasoningTokens: UNAVAILABLE,
+                contextCapacityTokens: UNAVAILABLE,
+                peakContextOccupancyTokens: UNAVAILABLE,
+                compactions: [],
+                compactionCount: UNAVAILABLE,
+                continuationTurns: UNAVAILABLE,
+                toolCalls: UNAVAILABLE,
+                fileActivity: { reads: UNAVAILABLE, writes: UNAVAILABLE, edits: UNAVAILABLE },
+                commandOutputBytes: UNAVAILABLE,
+            };
+        }
+        const commandOutputIncomplete = flags.corrupted && hadOrphanToolResult;
+        return {
+            provider,
+            model,
+            configuredModel: options.configuredModel,
+            inputTokens: sawResultEvent && inputTokens !== undefined ? observedNumber(inputTokens, "tokens") : UNAVAILABLE,
+            outputTokens: sawResultEvent && outputTokens !== undefined ? observedNumber(outputTokens, "tokens") : UNAVAILABLE,
+            cacheReadTokens: sawResultEvent && cacheReadTokens !== undefined ? observedNumber(cacheReadTokens, "tokens") : UNAVAILABLE,
+            cacheCreationTokens: sawResultEvent && cacheCreationTokens !== undefined
+                ? observedNumber(cacheCreationTokens, "tokens")
+                : UNAVAILABLE,
+            reasoningTokens: reasoningTokens !== undefined ? estimatedNumber(reasoningTokens, "tokens") : UNAVAILABLE,
+            contextCapacityTokens: contextCapacityTokens !== undefined ? observedNumber(contextCapacityTokens, "tokens") : UNAVAILABLE,
+            peakContextOccupancyTokens: peakContextOccupancy === undefined
+                ? UNAVAILABLE
+                : peakContextOccupancy.incomplete
+                    ? incompleteNumber(peakContextOccupancy.value, "tokens")
+                    : observedNumber(peakContextOccupancy.value, "tokens"),
+            compactions,
+            compactionCount: compactions.length > 0 ? observedNumber(compactions.length, "count") : UNAVAILABLE,
+            continuationTurns: sawResultEvent && numTurns !== undefined ? observedNumber(numTurns, "count") : UNAVAILABLE,
+            toolCalls: maybeIncomplete(observedNumber(toolCallCount, "count"), flags.corrupted),
+            fileActivity: {
+                reads: maybeIncomplete(observedNumber(reads, "count"), flags.corrupted),
+                writes: maybeIncomplete(observedNumber(writes, "count"), flags.corrupted),
+                edits: maybeIncomplete(observedNumber(edits, "count"), flags.corrupted),
+            },
+            commandOutputBytes: commandOutputIncomplete
+                ? incompleteNumber(commandOutputBytes, "bytes")
+                : observedNumber(commandOutputBytes, "bytes"),
+            ...(costUsd !== undefined ? { costUsd: observedNumber(costUsd, "usd") } : {}),
+        };
+    }
+    return { observeEvent, finish };
+}
+function numberOr0(value) {
+    return typeof value === "number" ? value : 0;
+}
+/**
+ * Demultiplexes a whole captured stream-json string in one call, purely for
+ * fixture-driven tests — production feeds `createTelemetryAccumulator`
+ * directly from `agent-runner.ts`'s single event-parsing pass so the raw
+ * text is never parsed twice.
+ */
+export function normalizeClaudeTelemetry(raw, options = {}) {
+    const accumulator = createTelemetryAccumulator({
+        configuredModel: parseConfiguredModel(options.configuredArgs ?? []),
+        commandProviderGuess: providerLabelFromCommand(options.command),
+    });
+    let firstLineSeen = false;
+    let isNdjson = true;
+    let corrupted = false;
+    for (const rawLine of raw.split("\n")) {
+        const line = rawLine.trim();
+        if (line === "")
+            continue;
+        if (!firstLineSeen) {
+            firstLineSeen = true;
+            try {
+                accumulator.observeEvent(JSON.parse(line));
+            }
+            catch {
+                isNdjson = false;
+            }
+            continue;
+        }
+        if (!isNdjson)
+            break;
+        try {
+            accumulator.observeEvent(JSON.parse(line));
+        }
+        catch {
+            corrupted = true;
+        }
+    }
+    return accumulator.finish({ observed: firstLineSeen && isNdjson, corrupted });
+}
+/** One point per SC-08-enumerated metric, scalar and coverage-labelled, never a fabricated zero for a metric the stream did not expose. */
+export function providerTelemetryPoints(telemetry, dimensions, evidence) {
+    const points = [];
+    const stringPoint = (label, fact, detailOverride) => {
+        points.push({
+            kind: PROVIDER_TELEMETRY_KIND,
+            label,
+            coverage: fact.coverage,
+            ...(detailOverride !== undefined
+                ? { detail: detailOverride }
+                : fact.value !== undefined
+                    ? { detail: fact.value }
+                    : {}),
+            dimensions,
+            evidence,
+        });
+    };
+    const numberPoint = (label, fact) => {
+        points.push({
+            kind: PROVIDER_TELEMETRY_KIND,
+            label,
+            coverage: fact.coverage,
+            ...(fact.value === undefined ? {} : { value: fact.value }),
+            ...(fact.unit === undefined ? {} : { unit: fact.unit }),
+            dimensions,
+            evidence,
+        });
+    };
+    stringPoint("provider", telemetry.provider);
+    const modelMismatch = telemetry.model.value !== undefined &&
+        telemetry.configuredModel.value !== undefined &&
+        telemetry.model.value !== telemetry.configuredModel.value;
+    stringPoint("model", telemetry.model, modelMismatch
+        ? `${telemetry.model.value} (configured invocation specified ${telemetry.configuredModel.value})`
+        : undefined);
+    stringPoint("configured-model", telemetry.configuredModel);
+    numberPoint("input-tokens", telemetry.inputTokens);
+    numberPoint("output-tokens", telemetry.outputTokens);
+    numberPoint("cache-read-tokens", telemetry.cacheReadTokens);
+    numberPoint("cache-creation-tokens", telemetry.cacheCreationTokens);
+    numberPoint("reasoning-tokens", telemetry.reasoningTokens);
+    numberPoint("context-capacity-tokens", telemetry.contextCapacityTokens);
+    numberPoint("peak-context-occupancy-tokens", telemetry.peakContextOccupancyTokens);
+    numberPoint("continuation-turns", telemetry.continuationTurns);
+    numberPoint("tool-calls", telemetry.toolCalls);
+    numberPoint("file-activity-reads", telemetry.fileActivity.reads);
+    numberPoint("file-activity-writes", telemetry.fileActivity.writes);
+    numberPoint("file-activity-edits", telemetry.fileActivity.edits);
+    numberPoint("command-output-bytes", telemetry.commandOutputBytes);
+    numberPoint("compaction-count", telemetry.compactionCount);
+    if (telemetry.costUsd !== undefined)
+        numberPoint("cost-usd", telemetry.costUsd);
+    for (const occurrence of telemetry.compactions) {
+        numberPoint("compaction-tokens-before", occurrence.tokensBefore);
+        numberPoint("compaction-at", occurrence.at);
+    }
+    return points;
+}
+//# sourceMappingURL=provider-telemetry.js.map