@zanii/blackbox 0.22.0 → 0.23.0

package/dist/compliance/index.js

@@ -32,6 +32,28 @@ const show = (v, ar = false) => {
     }
     return String(v);
 };
+/** spec/compliance.md §3: each fact's Arabic label (the key follows it, so tools still match). */
+export const FACTS_AR = {
+    sessions: "الجلسات",
+    events: "الأحداث",
+    sessions_verified: "الجلسات التي تحققت سلاسلها",
+    sessions_anchored: "الجلسات المثبتة على السجل",
+    redactions: "الحجب",
+    findings_warning: "الملاحظات بمستوى تحذير",
+    bypasses: "تجاوزات البوابة",
+    false_claims: "الادعاءات غير الصحيحة",
+    blocks: "الإيقافات",
+    emergency_stops: "الإيقافات الطارئة",
+    resumes_with_note: "الاستئنافات المسببة",
+    outcomes: "النتائج",
+    data_region: "منطقة البيانات",
+    model_responses: "إجابات النموذج",
+    hallucination_findings: "ملاحظات الهلوسة",
+    grounding_checks: "فحوص الإسناد",
+    judge_checks: "فحوص المُقيِّم",
+    hallucination_controls: "ضوابط الهلوسة",
+    detector_accuracy: "دقة الكواشف",
+};
 export function renderReport(r) {
     const ar = r.lang === "ar";
     const out = [
@@ -47,9 +69,11 @@ export function renderReport(r) {
         const head = ar ? "| الدليل | القيمة |" : "| Evidence | Value |";
         out.push("", `## ${s.title}`, "", s.requirement, "", head, "|---|---|");
         for (const [k, v] of Object.entries(s.evidence))
-            out.push(`| ${k} | ${show(v, ar)} |`);
+            out.push(`| ${ar && FACTS_AR[k] ? `${FACTS_AR[k]} (\`${k}\`)` : k} | ${show(v, ar)} |`);
     }
-    return `${out.join("\n")}\n`;
+    const body = `${out.join("\n")}\n`;
+    // Right to left, as the incident report (spec/fleet.md §2)
+    return ar ? `<div dir="rtl" lang="ar">\n\n${body}\n</div>\n` : body;
 }
 /** spec/compliance.md §1: the facts over sessions' records (the server adds verified / anchored). */
 export function complianceFacts(sessions, dataRegion) {

package/dist/cost/batch.d.ts

@@ -0,0 +1,26 @@
+import type { Bodies } from "../reconcile/record.ts";
+import { type LoadedPrices, type Tokens } from "./index.ts";
+export interface BatchItem {
+    custom_id: string;
+    status: string;
+    model: string | null;
+    joined: boolean;
+    tokens: Tokens;
+    micro_usd: number | null;
+}
+export interface BatchEntry {
+    seq: number;
+    request_seq: number;
+    provider: string | null;
+    source_seq: number | null;
+    results: number;
+    joined: number;
+    micro_usd: number | null;
+    items: BatchItem[];
+}
+export interface BatchReport {
+    v: 1;
+    batches: BatchEntry[];
+}
+/** The session's batch results joined to their requests and priced (spec/cost.md §6). */
+export declare function batchReport(lines: readonly string[], bodies: Bodies, prices: LoadedPrices): BatchReport;

package/dist/cost/batch.js

@@ -0,0 +1,173 @@
+// Batch results joined to their requests (spec/cost.md §6, spec/providers.md §6): each results
+// download read again from its recorded chunks, its lines joined by custom_id to the call that
+// carried the batch's requests, each result priced at the batch rate.
+// Mirrors sdks/python/src/zanii_blackbox/batch.py.
+import { priceCall } from "./index.js";
+const decoder = new TextDecoder();
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const ZERO = { input: 0, output: 0, cache_read: 0, cache_write: 0 };
+function jsonLines(text) {
+    const out = [];
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const o = JSON.parse(line);
+            if (isObj(o))
+                out.push(o);
+        }
+        catch { }
+    }
+    return out;
+}
+/** One result line as {id, status, model, usage}, or null when it isn't one. */
+function resultOf(o) {
+    if (typeof o.custom_id !== "string")
+        return null;
+    if (isObj(o.result)) {
+        // Anthropic: {custom_id, result: {type, message?}}
+        const message = isObj(o.result.message) ? o.result.message : {};
+        const status = typeof o.result.type === "string" ? o.result.type : "errored";
+        return { id: o.custom_id, status, model: message.model, usage: message.usage };
+    }
+    if (!("response" in o) && !("error" in o))
+        return null;
+    // OpenAI: {custom_id, response: {status_code, body}, error}
+    const response = isObj(o.response) ? o.response : {};
+    const code = response.status_code;
+    const ok = typeof code === "number" && code >= 200 && code < 300 && o.error == null;
+    const body = isObj(response.body) ? response.body : {};
+    return {
+        id: o.custom_id,
+        status: ok ? "succeeded" : "errored",
+        model: body.model,
+        usage: body.usage,
+    };
+}
+/** Flattened integer usage, as the gateway records it (spec/api.md §3). */
+function flatten(usage) {
+    const out = {};
+    const walk = (o, prefix) => {
+        for (const [k, v] of Object.entries(o)) {
+            if (typeof v === "number" && Number.isSafeInteger(v))
+                out[prefix + k] = v;
+            else if (isObj(v))
+                walk(v, `${prefix}${k}_`);
+        }
+    };
+    if (isObj(usage))
+        walk(usage, "");
+    return out;
+}
+/** The custom_ids a batch's source call carried: Anthropic's requests[], or OpenAI's JSONL file. */
+function customIds(text) {
+    const ids = new Set();
+    let whole;
+    try {
+        whole = JSON.parse(text);
+    }
+    catch { }
+    if (isObj(whole) && Array.isArray(whole.requests)) {
+        for (const r of whole.requests)
+            if (isObj(r) && typeof r.custom_id === "string")
+                ids.add(r.custom_id);
+        return ids;
+    }
+    for (const o of jsonLines(text))
+        if (typeof o.custom_id === "string")
+            ids.add(o.custom_id);
+    return ids;
+}
+/** The session's batch results joined to their requests and priced (spec/cost.md §6). */
+export function batchReport(lines, bodies, prices) {
+    const events = lines.map((l) => JSON.parse(l));
+    const requests = new Map();
+    const answers = new Map(); // request seq → its llm.response meta
+    const chunks = new Map(); // decoded whole: a character can span chunks
+    for (const e of events) {
+        const owner = e.meta.request_seq;
+        if (e.kind === "llm.request")
+            requests.set(e.seq, e);
+        else if (e.kind === "llm.chunk" && typeof owner === "number") {
+            const list = chunks.get(owner) ?? [];
+            list.push(bodies(e.body_hash) ?? new Uint8Array());
+            chunks.set(owner, list);
+        }
+        else if (e.kind === "llm.response" && typeof owner === "number")
+            answers.set(owner, e.meta);
+    }
+    const pathOf = (seq) => {
+        const p = requests.get(seq)?.meta.path;
+        return typeof p === "string" ? p.split("?")[0] : "";
+    };
+    const postTo = (seq, tail) => requests.get(seq)?.meta.method === "POST" && tail.test(pathOf(seq));
+    /** The latest request before `before` whose answer has `field` = `value` and that passes `ok`. */
+    const answered = (field, value, before, ok) => {
+        let found = null;
+        for (const [seq, meta] of answers)
+            if (seq < before && meta[field] === value && ok(seq))
+                found = seq;
+        return found;
+    };
+    const batches = [];
+    for (const e of events) {
+        const requestSeq = e.meta.request_seq;
+        if (e.kind !== "llm.response" || !isObj(e.meta.batch) || typeof requestSeq !== "number")
+            continue;
+        const path = pathOf(requestSeq);
+        let source = null;
+        const anthropic = /\/messages\/batches\/([^/]+)\/results$/.exec(path);
+        const openai = /\/files\/([^/]+)\/content$/.exec(path);
+        if (anthropic)
+            source = answered("batch_id", anthropic[1], requestSeq, (s) => postTo(s, /\/messages\/batches$/));
+        else if (openai) {
+            const file = openai[1];
+            let input;
+            for (const [seq, meta] of answers)
+                if (seq < requestSeq && (meta.output_file_id === file || meta.error_file_id === file))
+                    input = meta.input_file_id;
+            if (typeof input === "string")
+                source = answered("file_id", input, requestSeq, (s) => postTo(s, /\/files$/));
+        }
+        const sourceRequest = source === null ? undefined : requests.get(source);
+        const sourceBody = sourceRequest ? bodies(sourceRequest.body_hash) : undefined;
+        const ids = sourceBody ? customIds(decoder.decode(sourceBody)) : new Set();
+        const p = requests.get(requestSeq)?.meta.provider;
+        const provider = typeof p === "string" ? p : null;
+        const items = [];
+        let total = 0;
+        for (const line of jsonLines(decoder.decode(Buffer.concat(chunks.get(requestSeq) ?? [])))) {
+            const r = resultOf(line);
+            if (!r)
+                continue;
+            const model = typeof r.model === "string" ? r.model : null;
+            let tokens = ZERO;
+            let micro = 0;
+            if (r.status === "succeeded") {
+                const priced = priceCall({ model, usage: flatten(r.usage), provider, batch: { requests: 1 } }, prices.table);
+                tokens = priced.tokens;
+                micro = priced.micro_usd;
+            }
+            total = total === null || micro === null ? null : total + micro;
+            items.push({
+                custom_id: r.id,
+                status: r.status,
+                model,
+                joined: ids.has(r.id),
+                tokens,
+                micro_usd: micro,
+            });
+        }
+        batches.push({
+            seq: e.seq,
+            request_seq: requestSeq,
+            provider,
+            source_seq: source,
+            results: items.length,
+            joined: items.filter((i) => i.joined).length,
+            micro_usd: total,
+            items,
+        });
+    }
+    return { v: 1, batches };
+}

package/dist/cost/index.d.ts

@@ -30,6 +30,8 @@ export interface ModelPrice {
     service_tiers?: Record<string, ClassPrices>;
     /** `deprecated` feeds the MODEL_DEPRECATED finding; `beta` is informational. */
     status?: "deprecated" | "beta";
+    /** The percent of the price a batch result pays (spec/cost.md §1); absent: no known batch rate. */
+    batch_percent?: number;
 }
 export interface PriceTable {
     version: string;
@@ -81,6 +83,14 @@ export interface CallCost {
     source?: "reported";
     /** The answer carried no usage (`usage_missing`): unpriced, never counted as free. */
     no_usage?: true;
+    /** A batch result (spec/cost.md §2): its result count, and the batch percent it was priced at. */
+    batch?: {
+        requests: number;
+        percent?: number;
+    };
+    /** spec/cost.md §2: an MCP client's answer to a server's `sampling/createMessage`, or a usage
+     *  report in a realtime session (spec/providers.md §7). */
+    via?: "mcp_sampling" | "realtime";
 }
 export interface CostReport {
     v: 1;
@@ -145,6 +155,10 @@ export declare function priceCall(call: {
     provider?: string | null;
     serviceTier?: string | null;
     reportedMicroUsd?: number | null;
+    /** A batch result (spec/cost.md §2): priced at the model's batch_percent, or not at all. */
+    batch?: {
+        requests: number;
+    };
 }, table: PriceTable): Omit<CallCost, "seq" | "model"> & {
     key: string | null;
 };
@@ -154,5 +168,12 @@ export declare function upliftPercent(table: PriceTable, provider: string | null
 /** fils at the CBUAE peg (3.6725 AED / USD), rounded half up. */
 export declare function toAedFils(microUsd: number): number;
 export declare function formatAed(fils: number): string;
+/** A results download's `meta.batch.models` (spec/providers.md §6), the well-formed entries; null
+ *  when the response isn't one. */
+export declare function batchModels(batch: unknown): Array<{
+    model: string;
+    requests: number;
+    usage: Record<string, unknown>;
+}> | null;
 /** The session's cost report from its recorded lines. */
 export declare function sessionCost(lines: readonly string[], prices: LoadedPrices): CostReport;

package/dist/cost/index.js

@@ -1,6 +1,7 @@
 // The cost engine (spec/cost.md): integer micro-USD from a versioned price table, AED display.
 // Mirrors sdks/python/src/zanii_blackbox/cost.py.
 import { createHash } from "node:crypto";
+import { envelopesOf } from "../reconcile/record.js";
 const CLASSES = ["input", "output", "cache_read", "cache_write"];
 const EXTRA = [
     "cache_write_1h",
@@ -47,6 +48,9 @@ export function loadPrices(bytes) {
                     whole(model, `service_tiers.${name}.${c}`, t[c]);
         if (p.status !== undefined && p.status !== "deprecated" && p.status !== "beta")
             throw new Error(`price table: ${model}.status must be deprecated or beta`);
+        if (p.batch_percent !== undefined &&
+            !(Number.isSafeInteger(p.batch_percent) && p.batch_percent >= 1 && p.batch_percent <= 100))
+            throw new Error(`price table: ${model}.batch_percent must be an integer 1-100`);
     }
     if (table.uplifts !== undefined) {
         if (!Array.isArray(table.uplifts))
@@ -85,7 +89,8 @@ provider) {
     return plain !== model ? lookup(plain, table) : null;
 }
 const GEO = /^(?:us|eu|apac|au|ca|jp|global|us-gov)\./;
-const VENDOR = /^(?:anthropic|amazon|meta|mistral|cohere|ai21|deepseek|openai|qwen|writer|google)\./;
+// `google/`: Vertex's OpenAI-compatible route (spec/cost.md §1)
+const VENDOR = /^(?:(?:anthropic|amazon|meta|mistral|cohere|ai21|deepseek|openai|qwen|writer|google)\.|google\/)/;
 function lookup(model, table) {
     const exact = table.models[model];
     if (exact)
@@ -96,6 +101,12 @@ function lookup(model, table) {
             best = key;
     return best === null ? null : { key: best, price: table.models[best] };
 }
+const SONIC = [
+    "input_speechTokens",
+    "input_textTokens",
+    "output_speechTokens",
+    "output_textTokens",
+];
 /** Token classes from a recorded, flattened `meta.usage` (spec/cost.md §2). */
 export function tokensOf(usage) {
     const n = (k) => {
@@ -105,14 +116,16 @@ export function tokensOf(usage) {
     if ("promptTokenCount" in usage) {
         // Gemini (spec/providers.md §5): the prompt count includes the cached part; thoughts are output.
         const cached = n("cachedContentTokenCount");
+        // Gemini Live names its output `responseTokenCount` (spec/providers.md §7)
         const audioIn = n("promptTokensDetails_AUDIO");
-        const audioOut = n("candidatesTokensDetails_AUDIO");
+        const audioOut = n("candidatesTokensDetails_AUDIO") + n("responseTokensDetails_AUDIO");
         const imageIn = n("promptTokensDetails_IMAGE");
-        const imageOut = n("candidatesTokensDetails_IMAGE");
+        const imageOut = n("candidatesTokensDetails_IMAGE") + n("responseTokensDetails_IMAGE");
         return extras({
             input: Math.max(0, n("promptTokenCount") - cached - audioIn - imageIn) +
                 n("toolUsePromptTokenCount"),
-            output: Math.max(0, n("candidatesTokenCount") - audioOut - imageOut) + n("thoughtsTokenCount"),
+            output: Math.max(0, n("candidatesTokenCount") + n("responseTokenCount") - audioOut - imageOut) +
+                n("thoughtsTokenCount"),
             cache_read: cached,
             cache_write: 0,
         }, {
@@ -122,6 +135,14 @@ export function tokensOf(usage) {
             output_image: imageOut,
         });
     }
+    if (SONIC.some((k) => k in usage))
+        // Nova Sonic's usageEvent delta (spec/providers.md §8): speech is priced as audio
+        return extras({
+            input: n("input_textTokens"),
+            output: n("output_textTokens"),
+            cache_read: 0,
+            cache_write: 0,
+        }, { input_audio: n("input_speechTokens"), output_audio: n("output_speechTokens") });
     if ("inputTokens" in usage)
         // Bedrock Converse (spec/providers.md §5)
         return {
@@ -146,16 +167,22 @@ export function tokensOf(usage) {
     // Anthropic's cache names are its own: they win over the Responses shape, since Anthropic also
     // sends output_tokens_details (thinking_tokens) since Claude Sonnet 5
     const anthropicCache = "cache_read_input_tokens" in usage || "cache_creation_input_tokens" in usage;
-    // OpenAI's transcriptions write input_token_details (singular); its images, image_tokens
+    // OpenAI's transcriptions and Realtime write input_token_details (singular); its images,
+    // image_tokens. Realtime's audio and image counts include their cached part (spec/providers.md §7).
     if (!anthropicCache &&
         Object.keys(usage).some((k) => k.startsWith("input_tokens_details_") ||
             k.startsWith("output_tokens_details_") ||
-            k.startsWith("input_token_details_"))) {
-        const cached = n("input_tokens_details_cached_tokens");
+            k.startsWith("input_token_details_") ||
+            k.startsWith("output_token_details_"))) {
+        const cached = n("input_tokens_details_cached_tokens") + n("input_token_details_cached_tokens");
         const written = n("input_tokens_details_cache_write_tokens");
-        const audioIn = n("input_tokens_details_audio_tokens") + n("input_token_details_audio_tokens");
-        const audioOut = n("output_tokens_details_audio_tokens");
-        const imageIn = n("input_tokens_details_image_tokens");
+        const audioIn = n("input_tokens_details_audio_tokens") +
+            Math.max(0, n("input_token_details_audio_tokens") -
+                n("input_token_details_cached_tokens_details_audio_tokens"));
+        const audioOut = n("output_tokens_details_audio_tokens") + n("output_token_details_audio_tokens");
+        const imageIn = n("input_tokens_details_image_tokens") +
+            Math.max(0, n("input_token_details_image_tokens") -
+                n("input_token_details_cached_tokens_details_image_tokens"));
         const imageOut = n("output_tokens_details_image_tokens");
         return extras({
             input: Math.max(0, n("input_tokens") - cached - written - audioIn - imageIn),
@@ -249,7 +276,17 @@ export function priceCall(call, table) {
     const match = call.model === null ? null : priceFor(call.model, table, call.provider);
     if (match) {
         const { price, tier } = effectivePrice(match.price, tokens, call.serviceTier);
-        const base = callMicroUsd(tokens, price, requests);
+        const percent = match.price.batch_percent;
+        if (call.batch && percent === undefined)
+            return {
+                key: match.key,
+                tokens,
+                micro_usd: null,
+                ...(requests ? { requests } : {}),
+                batch: { requests: call.batch.requests },
+            };
+        const full = callMicroUsd(tokens, price, requests);
+        const base = call.batch ? Math.floor((full * percent + 50) / 100) : full;
         const uplift = upliftPercent(table, call.provider ?? null, call.model, call.usage);
         return {
             key: match.key,
@@ -258,8 +295,19 @@ export function priceCall(call, table) {
             ...(requests ? { requests } : {}),
             ...(tier ? { tier } : {}),
             ...(uplift ? { uplift_percent: uplift } : {}),
+            ...(call.batch
+                ? { batch: { requests: call.batch.requests, percent: percent } }
+                : {}),
         };
     }
+    if (call.batch)
+        return {
+            key: null,
+            tokens,
+            micro_usd: null,
+            ...(requests ? { requests } : {}),
+            batch: { requests: call.batch.requests },
+        };
     if (typeof call.reportedMicroUsd === "number")
         return {
             key: null,
@@ -294,6 +342,22 @@ export function formatAed(fils) {
     const abs = Math.abs(fils);
     return `${sign}AED ${Math.floor(abs / 100)}.${String(abs % 100).padStart(2, "0")}`;
 }
+/** A results download's `meta.batch.models` (spec/providers.md §6), the well-formed entries; null
+ *  when the response isn't one. */
+export function batchModels(batch) {
+    if (typeof batch !== "object" || batch === null)
+        return null;
+    const models = batch.models;
+    if (!Array.isArray(models))
+        return null;
+    return models.filter((m) => typeof m === "object" &&
+        m !== null &&
+        typeof m.model === "string" &&
+        Number.isSafeInteger(m.requests) &&
+        typeof m.usage === "object" &&
+        m.usage !== null &&
+        !Array.isArray(m.usage));
+}
 /** The session's cost report from its recorded lines. */
 export function sessionCost(lines, prices) {
     const calls = [];
@@ -304,8 +368,7 @@ export function sessionCost(lines, prices) {
     const providers = new Map(); // request seq → the configured provider id
     let webSearch = 0;
     let pinnedSha; // session.open's meta.prices_sha256 (L3.1.5)
-    for (const line of lines) {
-        const e = JSON.parse(line);
+    for (const e of envelopesOf(lines)) {
         if (e.kind === "session.open")
             pinnedSha = e.meta.prices_sha256;
         if (e.kind === "llm.request") {
@@ -316,10 +379,44 @@ export function sessionCost(lines, prices) {
                 providers.set(e.seq, e.meta.provider);
             continue;
         }
-        if (e.kind !== "llm.response" && e.kind !== "llm.incomplete")
+        // spec/cost.md §2: a client's sampling reply that names its model and usage is a model call too
+        const sampling = e.kind === "tool.sampling" && e.meta.phase === "reply" && typeof e.meta.model === "string";
+        // spec/providers.md §7: a realtime session's usage reports are its model calls
+        const realtime = e.kind === "llm.realtime.server";
+        if (e.kind !== "llm.response" && e.kind !== "llm.incomplete" && !sampling && !realtime)
             continue;
-        if (replayed.has(e.meta.request_seq))
+        if (!sampling && replayed.has(e.meta.request_seq))
             continue;
+        const provider = sampling ? null : (providers.get(e.meta.request_seq) ?? null);
+        const via = sampling
+            ? { via: "mcp_sampling" }
+            : realtime
+                ? { via: "realtime" }
+                : {};
+        const add = (seq, model, priced) => {
+            const { key, ...call } = priced;
+            for (const c of CLASSES)
+                total[c] += call.tokens[c];
+            for (const c of EXTRA)
+                if (call.tokens[c] !== undefined)
+                    total[c] = (total[c] ?? 0) + call.tokens[c];
+            webSearch += call.requests?.web_search ?? 0;
+            // a model with a price but no batch rate is unpriced, not unknown (spec/cost.md §2)
+            if (call.micro_usd === null) {
+                if (key === null)
+                    unknown.add(model ?? "(no model)");
+            }
+            else
+                micro += call.micro_usd;
+            calls.push({ seq, model, ...call, ...via });
+        };
+        // spec/cost.md §2: a batch results download, one call per model, at the batch rate
+        const batch = sampling ? null : batchModels(e.meta.batch);
+        if (batch) {
+            for (const m of batch)
+                add(e.seq, m.model, priceCall({ model: m.model, usage: m.usage, provider, batch: { requests: m.requests } }, prices.table));
+            continue;
+        }
         const usage = e.meta.usage;
         const model = typeof e.meta.model === "string" ? e.meta.model : null;
         if (typeof usage !== "object" || usage === null) {
@@ -334,27 +431,15 @@ export function sessionCost(lines, prices) {
                 });
             continue;
         }
-        const priced = priceCall({
+        add(e.seq, model, priceCall({
             model,
             usage: usage,
-            provider: providers.get(e.meta.request_seq) ?? null,
+            provider,
             serviceTier: typeof e.meta.service_tier === "string" ? e.meta.service_tier : null,
             reportedMicroUsd: Number.isSafeInteger(e.meta.reported_cost_micro_usd)
                 ? e.meta.reported_cost_micro_usd
                 : null,
-        }, prices.table);
-        const { key: _key, ...call } = priced;
-        for (const c of CLASSES)
-            total[c] += call.tokens[c];
-        for (const c of EXTRA)
-            if (call.tokens[c] !== undefined)
-                total[c] = (total[c] ?? 0) + call.tokens[c];
-        webSearch += call.requests?.web_search ?? 0;
-        if (call.micro_usd === null)
-            unknown.add(model ?? "(no model)");
-        else
-            micro += call.micro_usd;
-        calls.push({ seq: e.seq, model, ...call });
+        }, prices.table));
     }
     return {
         v: 1,

package/dist/cv/index.js

@@ -17,7 +17,7 @@ export function buildCv(o) {
         v: 1,
         type: "agentcv",
         did: o.did,
-        owner: o.owner ?? null,
+        ...(o.owner != null ? { owner: o.owner } : {}), // left out when unset, as zanii 0.26 does
         summary: o.summary,
         work: o.work ?? [],
         authority: o.authority ?? [],

package/dist/duty/index.js

@@ -1,6 +1,7 @@
 // Duty-time limits (spec/duty.md): long sessions and full context windows, detected. Pure; mirrors
 // sdks/python/src/zanii_blackbox/duty.py; pinned by spec/vectors/duty.json.
 import { priceFor, promptTokens, sessionCost } from "../cost/index.js";
+import { envelopesOf } from "../reconcile/record.js";
 const KEYS = ["max_minutes", "max_llm_calls", "max_context_pct"];
 /** spec/duty.md §1: the flight plan's limits win, limit by limit, over the server's defaults. */
 function limitsOf(open, defaults) {
@@ -15,7 +16,7 @@ function limitsOf(open, defaults) {
 }
 /** spec/duty.md §2: at most one DUTY_LIMIT per limit, where it was first crossed. */
 export function dutyFindings(lines, prices, defaults = {}) {
-    const events = lines.map((l) => JSON.parse(l));
+    const events = envelopesOf(lines);
     const open = events[0]?.kind === "session.open" ? events[0] : undefined;
     const limits = limitsOf(open, defaults);
     const out = [];