modelrig 0.11.1 → 0.12.0

package/dist/telemetry/otel-hierarchy.d.ts

@@ -0,0 +1,57 @@
+/**
+ * OTLP-in — the trace HIERARCHY half of the normalizer, extracted from
+ * otel-normalize.ts (ARC-γ: the normalizer sat at 662 LOC, near the 700 cap).
+ * PURE: span identity → run/step identity, and step ordering within a run.
+ * No attribute is read here and no content ever reaches this module.
+ */
+import type { WireStep } from "./ingest-protocol";
+/** ARC-6: the classified operation kept in the attested envelope — the five
+ * classes OTLP-in v1 uses (turn numbering + tool counts), or `span` for
+ * anything else (honest: never guessed into a class). */
+export type OperationClass = "generation" | "tool" | "agent" | "retriever" | "embedding" | "span";
+/** Map the normalizer's raw operation string to its class. */
+export declare function operationClassOf(operation: string): OperationClass;
+/** span name → step_key: trimmed, whitespace-collapsed, length-capped, never
+ * empty (the step PK forbids it). */
+export declare function toStepKey(name: unknown): string;
+/** 32-hex trace id → canonical UUID string (runs.id is uuid; 16 bytes ≡ a UUID).
+ * A trace id that is not 16 bytes gets a deterministic UUID derived from it. */
+export declare function traceIdToRunUuid(traceHex: string): string;
+/** The structural identity of the span a pending step came from (ARC-6). */
+export interface SpanShape {
+    readonly id: string;
+    readonly parent: string | null;
+    /** The normalizer's raw operation (`invoke_agent`, `chat`, …). */
+    readonly operation: string;
+    readonly operationClass: OperationClass;
+}
+/** One normalized span awaiting its attempt number. */
+export interface PendingStep {
+    readonly step: WireStep;
+    readonly stepKey: string;
+    readonly startMs: number;
+    readonly span?: SpanShape;
+}
+/**
+ * Assign attempt_no per (run, step_key): repeated same-named spans become
+ * attempts in start-time (then span-id) order — deterministic within a trace.
+ * v0 limitation: a trace split across batches is not deduped (no seen-store);
+ * one trace = one batch is the common, correct case.
+ */
+export declare function assignAttempts(pending: readonly PendingStep[]): WireStep[];
+/**
+ * ARC-6 turn numbering for ONE trace that is a conversation (it carries
+ * `gen_ai.conversation.id` and has `invoke_agent` spans). Each TOP-LEVEL
+ * `invoke_agent` span (no `invoke_agent` ancestor), in start order, is turn n;
+ * every generation span under it (any depth) becomes step `turn:<n>.<k>` in
+ * start order — ARC-α's step-key convention exactly (`turnStepKey`; a repeated
+ * key would read as a retry). The turn number and, on the agent span, the
+ * count of tool spans in that turn ride the attested envelope (`turn`,
+ * `turn_tool_calls`, `turn_generations`). Spans outside every turn are left
+ * as they were. Returns the rewritten list and the number of turns.
+ */
+export declare function numberTurns(pending: readonly PendingStep[]): {
+    pending: PendingStep[];
+    turns: number;
+};
+//# sourceMappingURL=otel-hierarchy.d.ts.map

package/dist/telemetry/otel-hierarchy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel-hierarchy.d.ts","sourceRoot":"","sources":["../../src/telemetry/otel-hierarchy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD;;yDAEyD;AACzD,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,WAAW,GAAG,WAAW,GAAG,MAAM,CAAC;AAuBlG,8DAA8D;AAC9D,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,CAElE;AAID;qCACqC;AACrC,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAI/C;AAED;gFACgF;AAChF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED,4EAA4E;AAC5E,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,kEAAkE;IAClE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;CACzC;AAED,uDAAuD;AACvD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC;CAC3B;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,QAAQ,EAAE,CAmB1E;AAUD;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG;IAAE,OAAO,EAAE,WAAW,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAgDtG"}

package/dist/telemetry/otel-hierarchy.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * OTLP-in — the trace HIERARCHY half of the normalizer, extracted from
+ * otel-normalize.ts (ARC-γ: the normalizer sat at 662 LOC, near the 700 cap).
+ * PURE: span identity → run/step identity, and step ordering within a run.
+ * No attribute is read here and no content ever reaches this module.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operationClassOf = operationClassOf;
+exports.toStepKey = toStepKey;
+exports.traceIdToRunUuid = traceIdToRunUuid;
+exports.assignAttempts = assignAttempts;
+exports.numberTurns = numberTurns;
+const node_crypto_1 = require("node:crypto");
+const conversation_1 = require("../artifacts/conversation");
+const OPERATION_CLASSES = {
+    // gen_ai.operation.name (semconv) + the normalizer's model-presence fallback
+    chat: "generation",
+    text_completion: "generation",
+    generate_content: "generation",
+    completion: "generation",
+    // openinference.span.kind (lower-cased by the normalizer)
+    llm: "generation",
+    generation: "generation",
+    execute_tool: "tool",
+    tool: "tool",
+    invoke_agent: "agent",
+    create_agent: "agent",
+    agent_step: "agent",
+    agent: "agent",
+    retriever: "retriever",
+    retrieval: "retriever",
+    embeddings: "embedding",
+    embedding: "embedding",
+};
+/** Map the normalizer's raw operation string to its class. */
+function operationClassOf(operation) {
+    return OPERATION_CLASSES[operation] ?? "span";
+}
+const WS_RE = /\s+/g;
+/** span name → step_key: trimmed, whitespace-collapsed, length-capped, never
+ * empty (the step PK forbids it). */
+function toStepKey(name) {
+    const raw = typeof name === "string" ? name.trim().replace(WS_RE, " ") : "";
+    if (raw === "")
+        return "span";
+    return raw.slice(0, 200);
+}
+/** 32-hex trace id → canonical UUID string (runs.id is uuid; 16 bytes ≡ a UUID).
+ * A trace id that is not 16 bytes gets a deterministic UUID derived from it. */
+function traceIdToRunUuid(traceHex) {
+    const hex = traceHex.length === 32 ? traceHex : (0, node_crypto_1.createHash)("sha256").update(traceHex).digest("hex").slice(0, 32);
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+/**
+ * Assign attempt_no per (run, step_key): repeated same-named spans become
+ * attempts in start-time (then span-id) order — deterministic within a trace.
+ * v0 limitation: a trace split across batches is not deduped (no seen-store);
+ * one trace = one batch is the common, correct case.
+ */
+function assignAttempts(pending) {
+    const out = [];
+    const perKey = new Map();
+    for (const p of pending) {
+        const list = perKey.get(p.stepKey) ?? [];
+        list.push({ step: p.step, startMs: p.startMs });
+        perKey.set(p.stepKey, list);
+    }
+    for (const list of perKey.values()) {
+        list.sort((a, b) => a.startMs !== b.startMs
+            ? a.startMs - b.startMs
+            : (a.step.span_id ?? "") < (b.step.span_id ?? "")
+                ? -1
+                : 1);
+        list.forEach(({ step }, i) => out.push({ ...step, attempt_no: i + 1 }));
+    }
+    return out;
+}
+/** Parent-chain walk bound (a malformed trace can carry a cycle). */
+const MAX_DEPTH = 64;
+function byStart(a, b) {
+    if (a.startMs !== b.startMs)
+        return a.startMs - b.startMs;
+    return (a.span?.id ?? "") < (b.span?.id ?? "") ? -1 : 1;
+}
+/**
+ * ARC-6 turn numbering for ONE trace that is a conversation (it carries
+ * `gen_ai.conversation.id` and has `invoke_agent` spans). Each TOP-LEVEL
+ * `invoke_agent` span (no `invoke_agent` ancestor), in start order, is turn n;
+ * every generation span under it (any depth) becomes step `turn:<n>.<k>` in
+ * start order — ARC-α's step-key convention exactly (`turnStepKey`; a repeated
+ * key would read as a retry). The turn number and, on the agent span, the
+ * count of tool spans in that turn ride the attested envelope (`turn`,
+ * `turn_tool_calls`, `turn_generations`). Spans outside every turn are left
+ * as they were. Returns the rewritten list and the number of turns.
+ */
+function numberTurns(pending) {
+    const byId = new Map();
+    for (const p of pending)
+        if (p.span !== undefined)
+            byId.set(p.span.id, p);
+    const isAgent = (p) => p?.span?.operation === "invoke_agent";
+    /** The top-level invoke_agent ancestor of a span (itself when it is one), or null. */
+    const topAgentOf = (p) => {
+        let top = isAgent(p) ? p : null;
+        let cur = p.span?.parent != null ? byId.get(p.span.parent) : undefined;
+        const seen = new Set([p.span?.id ?? ""]);
+        for (let d = 0; cur !== undefined && d < MAX_DEPTH; d++) {
+            const id = cur.span?.id ?? "";
+            if (seen.has(id))
+                break;
+            seen.add(id);
+            if (isAgent(cur))
+                top = cur;
+            cur = cur.span?.parent != null ? byId.get(cur.span.parent) : undefined;
+        }
+        return top;
+    };
+    const agents = pending.filter((p) => isAgent(p) && topAgentOf(p) === p).sort(byStart);
+    if (agents.length === 0)
+        return { pending: [...pending], turns: 0 };
+    const turnOf = new Map(agents.map((a, i) => [a, i + 1]));
+    const generations = new Map();
+    const tools = new Map();
+    const turnBySpan = new Map();
+    for (const p of pending) {
+        const top = topAgentOf(p);
+        const n = top !== null ? turnOf.get(top) : undefined;
+        if (n === undefined)
+            continue;
+        turnBySpan.set(p, n);
+        if (p.span?.operationClass === "generation")
+            generations.set(n, [...(generations.get(n) ?? []), p]);
+        if (p.span?.operationClass === "tool")
+            tools.set(n, (tools.get(n) ?? 0) + 1);
+    }
+    const keyOf = new Map();
+    for (const [n, list] of generations)
+        list.sort(byStart).forEach((p, i) => keyOf.set(p, (0, conversation_1.turnStepKey)(n, i + 1)));
+    const out = pending.map((p) => {
+        const n = turnBySpan.get(p);
+        if (n === undefined)
+            return p;
+        const env = (typeof p.step.attested === "object" && p.step.attested !== null ? p.step.attested : {});
+        const isTop = turnOf.has(p);
+        const attested = {
+            ...env,
+            turn: n,
+            ...(isTop ? { turn_tool_calls: tools.get(n) ?? 0, turn_generations: generations.get(n)?.length ?? 0 } : {}),
+        };
+        const stepKey = keyOf.get(p) ?? p.stepKey;
+        return { ...p, stepKey, step: { ...p.step, step_key: stepKey, attested } };
+    });
+    return { pending: out, turns: agents.length };
+}

package/dist/telemetry/otel-normalize.d.ts

@@ -23,6 +23,7 @@
  * pattern per §5.3 — implemented fresh here, no bodies copied).
  */
 import type { WireRun, WireStep } from "./ingest-protocol";
+import { type OperationClass } from "./otel-hierarchy";
 export interface AttestedUsage {
     /** Non-cached input tokens (cache buckets subtracted, floored 0). */
     readonly input?: number;
@@ -41,8 +42,21 @@ export interface AttestedEnvelope {
     readonly model: string | null;
     /** Resolved provider — honest, ending at "unknown", NEVER guessed. */
     readonly provider: string;
-    /** Classified operation (generation/tool/agent/retriever/embedding/span). */
+    /** The classifier's raw operation (`invoke_agent`, `chat`, `retriever`, …). */
     readonly operation: string;
+    /** ARC-6: the operation's class — generation | tool | agent | retriever |
+     * embedding, or `span` (unclassified). Additive. */
+    readonly operation_class?: OperationClass;
+    /** ARC-6: the parent span id (lowercase hex), or null for a root span.
+     * Kept for turn numbering + per-turn tool counts only — never rendered as a
+     * tree (spec §9). Additive. */
+    readonly parent_span_id?: string | null;
+    /** ARC-6: in a conversation trace, the turn this span belongs to. */
+    readonly turn?: number;
+    /** ARC-6: on a turn's top-level `invoke_agent` span — tool / generation
+     * spans counted in that turn. */
+    readonly turn_tool_calls?: number;
+    readonly turn_generations?: number;
     /** De-double-counted usage; omitted entirely on agent-aggregate spans. */
     readonly usage?: AttestedUsage;
     /** The emitting instrumentation scope (name + optional version). */

package/dist/telemetry/otel-normalize.d.ts.map

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

package/dist/telemetry/otel-normalize.js

@@ -26,7 +26,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeOtlpTraces = normalizeOtlpTraces;
 exports.looksLikeLogsPayload = looksLikeLogsPayload;
-const node_crypto_1 = require("node:crypto");
+const otel_hierarchy_1 = require("./otel-hierarchy");
 // ── value coercion (learnings §1.2, ported fresh) ────────────────────────────
 /** OTLP AnyValue → plain JS. Numeric strings coerce EXCEPT NaN/±Infinity which
  * stay as their string form (invalid JSON must never enter the envelope). int64
@@ -296,22 +296,6 @@ function classify(map) {
         return "chat";
     return "span";
 }
-// ── structure helpers ────────────────────────────────────────────────────────
-const WS_RE = /\s+/g;
-/** span name → step_key: trimmed, whitespace-collapsed, length-capped, never
- * empty (the step PK forbids it). */
-function toStepKey(name) {
-    const raw = typeof name === "string" ? name.trim().replace(WS_RE, " ") : "";
-    if (raw === "")
-        return "span";
-    return raw.slice(0, 200);
-}
-/** 32-hex trace id → canonical UUID string (runs.id is uuid; 16 bytes ≡ a UUID).
- * A trace id that is not 16 bytes gets a deterministic UUID derived from it. */
-function traceIdToRunUuid(traceHex) {
-    const hex = traceHex.length === 32 ? traceHex : (0, node_crypto_1.createHash)("sha256").update(traceHex).digest("hex").slice(0, 32);
-    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
-}
 function bump(drops, reason, by = 1) {
     drops[reason] = (drops[reason] ?? 0) + by;
 }
@@ -374,7 +358,7 @@ function normalizeOtlpTraces(data, nowMs = Date.now()) {
                 }
                 const { map, keys } = attrMap(span.attributes);
                 const timing = resolveTiming(span, nowMs, drops);
-                const runId = traceIdToRunUuid(traceHex);
+                const runId = (0, otel_hierarchy_1.traceIdToRunUuid)(traceHex);
                 // ── envelope (identity/structure/usage ONLY; NO content) ──
                 const operation = classify(map);
                 const isAgentAggregate = AGENT_OPERATIONS.has(operation);
@@ -383,10 +367,14 @@ function normalizeOtlpTraces(data, nowMs = Date.now()) {
                     ? "unknown"
                     : (firstAttr(map, PROVIDER_CHAIN) ?? "unknown");
                 const usage = isAgentAggregate ? undefined : extractUsage(map);
+                const parentHex = toHexId(span.parentSpanId ?? span.parent_span_id, 8);
+                const operationClass = (0, otel_hierarchy_1.operationClassOf)(operation);
                 const envelope = {
                     model,
                     provider,
                     operation,
+                    operation_class: operationClass,
+                    parent_span_id: parentHex,
                     ...(usage !== undefined ? { usage } : {}),
                     scope: { name: scopeName, version: scopeVersion },
                 };
@@ -397,7 +385,7 @@ function normalizeOtlpTraces(data, nowMs = Date.now()) {
                 const failureClass = statusCode === 2 ? "attested_error" : null;
                 const step = {
                     run_id: runId,
-                    step_key: toStepKey(span.name),
+                    step_key: (0, otel_hierarchy_1.toStepKey)(span.name),
                     attempt_no: 1, // assigned per (trace, step_key) below
                     task: null,
                     provenance: "attested",
@@ -413,6 +401,13 @@ function normalizeOtlpTraces(data, nowMs = Date.now()) {
                 const acc = runs.get(runId);
                 const endMs = timing.endedAt !== null ? Date.parse(timing.endedAt) : timing.startMs;
                 const episodeKey = firstAttr(map, EPISODE_CHAIN) ?? null;
+                const conversation = firstAttr(map, ["gen_ai.conversation.id"]) !== undefined;
+                const pendingStep = {
+                    step,
+                    stepKey: step.step_key,
+                    startMs: timing.startMs,
+                    span: { id: spanHex, parent: parentHex, operation, operationClass },
+                };
                 if (acc === undefined) {
                     runs.set(runId, {
                         runId,
@@ -423,7 +418,8 @@ function normalizeOtlpTraces(data, nowMs = Date.now()) {
                         minStartMs: timing.startMs,
                         maxEndMs: endMs,
                         anyError: failureClass !== null,
-                        pending: [{ step, stepKey: step.step_key, startMs: timing.startMs }],
+                        conversation,
+                        pending: [pendingStep],
                     });
                 }
                 else {
@@ -432,13 +428,17 @@ function normalizeOtlpTraces(data, nowMs = Date.now()) {
                     acc.anyError = acc.anyError || failureClass !== null;
                     if (acc.episodeKey === null && episodeKey !== null)
                         acc.episodeKey = episodeKey;
-                    acc.pending.push({ step, stepKey: step.step_key, startMs: timing.startMs });
+                    acc.conversation = acc.conversation || conversation;
+                    acc.pending.push(pendingStep);
                 }
             }
         }
     }
     const runRows = [];
     for (const acc of runs.values()) {
+        // ARC-6: a conversation trace (gen_ai.conversation.id + invoke_agent spans)
+        // numbers its generations into ARC-α turn steps and marks the run.
+        const turned = acc.conversation ? (0, otel_hierarchy_1.numberTurns)(acc.pending) : { pending: acc.pending, turns: 0 };
         runRows.push({
             id: acc.runId,
             pipeline: acc.pipeline,
@@ -449,25 +449,10 @@ function normalizeOtlpTraces(data, nowMs = Date.now()) {
             ended_at: new Date(acc.maxEndMs).toISOString(),
             // The trace has completed (we only see finished spans); status is honest.
             status: acc.anyError ? "failed" : "succeeded",
+            ...(turned.turns > 0 ? { meta: { v: 1, trigger: "conversation" } } : {}),
         });
-        // Assign attempt_no per (run, step_key): repeated same-named spans become
-        // attempts in start-time (then span-id) order — deterministic within a
-        // trace. v0 limitation: a trace split across batches is not deduped (no
-        // seen-store); one trace = one batch is the common, correct case.
-        const perKey = new Map();
-        for (const p of acc.pending) {
-            const list = perKey.get(p.stepKey) ?? [];
-            list.push({ step: p.step, startMs: p.startMs });
-            perKey.set(p.stepKey, list);
-        }
-        for (const list of perKey.values()) {
-            list.sort((a, b) => a.startMs !== b.startMs
-                ? a.startMs - b.startMs
-                : (a.step.span_id ?? "") < (b.step.span_id ?? "")
-                    ? -1
-                    : 1);
-            list.forEach(({ step }, i) => steps.push({ ...step, attempt_no: i + 1 }));
-        }
+        // attempt_no per (run, step_key) — the hierarchy module (otel-hierarchy.ts).
+        steps.push(...(0, otel_hierarchy_1.assignAttempts)(turned.pending));
     }
     return { runs: runRows, steps, drops, spanCount, scopeNames: [...scopeNames] };
 }

package/dist/telemetry/sinks.d.ts

@@ -57,7 +57,10 @@ export declare class SinkSendError extends Error {
      * poison-skip candidate). Derived once, from the status, so the classification
      * lives in exactly one place. */
     readonly retriable: boolean;
-    constructor(message: string, status: number | undefined);
+    /** COV-1c: the server's 422 `reason_code` — a PostgREST/PG error CODE
+     * (`PGRST102`, `23514`) and nothing else, shape-checked; null when absent. */
+    readonly reasonCode: string | null;
+    constructor(message: string, status: number | undefined, reasonCode?: string | null);
 }
 export interface DirectSinkConfig {
     readonly supabaseUrl: string;

package/dist/telemetry/sinks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sinks.d.ts","sourceRoot":"","sources":["../../src/telemetry/sinks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAmBrE;6CAC6C;AAC7C,wBAAgB,6BAA6B,IAAI,IAAI,CAEpD;AAED,MAAM,WAAW,aAAa;IAC5B;;yDAEqD;IACrD,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,KAAK,CAAC;IAChC;;6EAEyE;IACzE,IAAI,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzC;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,wEAAwE;IACxE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;qCAEiC;IACjC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;gBAEhB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS;CAMxD;AAMD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;CACjC;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,aAAa,CA0CxE;AAMD,MAAM,WAAW,aAAa;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;4EACwE;IACxE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;IAChC;;;wDAGoD;IACpD,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,CAAC;IACtD;;oDAEgD;IAChD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAKD,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa,CAsElE;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,eAAe,GAAG,kBAAkB,EAClD,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GACzC,aAAa,CA2Bf"}
+{"version":3,"file":"sinks.d.ts","sourceRoot":"","sources":["../../src/telemetry/sinks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAc,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACzF,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAmBrE;6CAC6C;AAC7C,wBAAgB,6BAA6B,IAAI,IAAI,CAEpD;AAED,MAAM,WAAW,aAAa;IAC5B;;yDAEqD;IACrD,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,KAAK,CAAC;IAChC;;6EAEyE;IACzE,IAAI,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzC;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,wEAAwE;IACxE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;qCAEiC;IACjC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B;kFAC8E;IAC9E,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;gBAEvB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,UAAU,GAAE,MAAM,GAAG,IAAW;CAO1F;AAcD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;CACjC;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,aAAa,CAkDxE;AAMD,MAAM,WAAW,aAAa;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;4EACwE;IACxE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;IAChC;;;wDAGoD;IACpD,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,CAAC;IACtD;;oDAEgD;IAChD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAKD,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa,CA4ElE;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,eAAe,GAAG,kBAAkB,EAClD,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GACzC,aAAa,CA2Bf"}

package/dist/telemetry/sinks.js

@@ -66,55 +66,72 @@ function __resetApiSinkWarningsForTest() {
  * gate), so the body a failed write returns is logged nowhere.
  */
 class SinkSendError extends Error {
-    constructor(message, status) {
+    constructor(message, status, reasonCode = null) {
         super(message);
         this.name = "SinkSendError";
         if (status !== undefined)
             this.status = status;
         this.retriable = status === undefined || status >= 500 || status === 429;
+        this.reasonCode = reasonCode;
     }
 }
 exports.SinkSendError = SinkSendError;
+/** The 422 body's `reason_code`, iff it is code-shaped — never any other body text. */
+async function reasonCodeOf(response) {
+    if (response.status !== 422)
+        return null;
+    const body = (await response.json().catch(() => null));
+    const code = body?.reason_code;
+    return typeof code === "string" && /^(PGRST\d{3}|[0-9A-Z]{5})$/.test(code) ? code : null;
+}
 function createDirectSink(config) {
     const base = config.supabaseUrl.replace(/\/$/, "");
     const fetchFn = config.fetchFn ?? fetch;
     return {
         mode: "direct",
         async send(batch) {
-            for (const write of (0, ingest_protocol_1.stampBatch)(batch, config.tenancy)) {
-                let response;
-                try {
-                    response = await fetchFn(
-                    // S5: the upsert names a real unique constraint. A single-argument
-                    // upsert targets the primary key and 23505s later.
-                    `${base}/rest/v1/${write.table}?on_conflict=${encodeURIComponent(write.onConflict)}`, {
-                        method: "POST",
-                        headers: {
-                            "content-type": "application/json",
-                            apikey: config.serviceRoleKey,
-                            authorization: `Bearer ${config.serviceRoleKey}`,
-                            prefer: write.merge
-                                ? "resolution=merge-duplicates,return=minimal"
-                                : "resolution=ignore-duplicates,return=minimal",
-                        },
-                        body: JSON.stringify(write.rows),
-                    });
-                }
-                catch {
-                    // Network-level throw — no status, so TRANSIENT (the exporter retries
-                    // forever). The raw error can carry the control-plane host, so it is
-                    // NOT echoed (C2); the table + "network error" is the whole message.
-                    throw new SinkSendError(`sink POST ${write.table} → network error`, undefined);
-                }
-                if (!response.ok) {
-                    // Status + table only — never the PostgREST body (it carries the
-                    // control-plane host and, on some failures, header fragments; C2).
-                    // The status is what the exporter classifies on (spec §2.3.1).
-                    throw new SinkSendError(`sink POST ${write.table} → ${response.status}`, response.status);
-                }
-            }
+            await sendWrites((0, ingest_protocol_1.stampBatch)(batch, config.tenancy));
+            // GRADE-RAW S2-1: step-task registration is best-effort and AFTER the
+            // batch landed — a refused registration never fails (or re-sends) it.
+            const registration = (0, ingest_protocol_1.stepTaskRegistration)(batch, config.tenancy);
+            if (registration !== null)
+                await sendWrites([registration]).catch(() => undefined);
         },
     };
+    async function sendWrites(writes) {
+        for (const write of writes) {
+            let response;
+            try {
+                response = await fetchFn(
+                // S5: the upsert names a real unique constraint. A single-argument
+                // upsert targets the primary key and 23505s later.
+                `${base}/rest/v1/${write.table}?on_conflict=${encodeURIComponent(write.onConflict)}`, {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        apikey: config.serviceRoleKey,
+                        authorization: `Bearer ${config.serviceRoleKey}`,
+                        prefer: write.merge
+                            ? "resolution=merge-duplicates,return=minimal"
+                            : "resolution=ignore-duplicates,return=minimal",
+                    },
+                    body: JSON.stringify(write.rows),
+                });
+            }
+            catch {
+                // Network-level throw — no status, so TRANSIENT (the exporter retries
+                // forever). The raw error can carry the control-plane host, so it is
+                // NOT echoed (C2); the table + "network error" is the whole message.
+                throw new SinkSendError(`sink POST ${write.table} → network error`, undefined);
+            }
+            if (!response.ok) {
+                // Status + table only — never the PostgREST body (it carries the
+                // control-plane host and, on some failures, header fragments; C2).
+                // The status is what the exporter classifies on (spec §2.3.1).
+                throw new SinkSendError(`sink POST ${write.table} → ${response.status}`, response.status);
+            }
+        }
+    }
 }
 /** Below this, gzip costs more than it saves. */
 const GZIP_MIN_BYTES = 1024;
@@ -166,7 +183,9 @@ function createApiSink(config) {
                 // someone else's log aggregator. The status is the exporter's transient-
                 // vs-poison signal: the server sends 422 for a deterministic control-plane
                 // rejection, 503 for a transient one (spec §2.2/§2.3.1).
-                throw new SinkSendError(`ingest POST → ${response.status}`, response.status);
+                // COV-1c: a 422 may name the PostgREST/PG code (shape-checked, code only).
+                const reasonCode = await reasonCodeOf(response);
+                throw new SinkSendError(`ingest POST → ${response.status}${reasonCode !== null ? ` (${reasonCode})` : ""}`, response.status, reasonCode);
             }
             // A good send clears the auth-failure latch, so a later key breakage
             // re-alerts instead of staying silent behind a once-per-process guard.

package/dist/telemetry/store-migrations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-migrations.d.ts","sourceRoot":"","sources":["../../src/telemetry/store-migrations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAG3C;sCACsC;AACtC,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,GAAG,IAAI,CAgM9D"}
+{"version":3,"file":"store-migrations.d.ts","sourceRoot":"","sources":["../../src/telemetry/store-migrations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAG3C;sCACsC;AACtC,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,GAAG,IAAI,CAwM9D"}

package/dist/telemetry/store-migrations.js

@@ -206,4 +206,12 @@ function runStoreMigrations(db) {
         }
         db.pragma("user_version = 16");
     }
+    // v17 (ARC-3, mirrors 00089): `grades.kind` gains 'outcome' (table rebuild —
+    // SQLite cannot ALTER a CHECK) and the nullable `value` column. The rebuild
+    // copies each row's ROWID too, so the exporter's `:grades` rowid watermark is
+    // exactly as valid after the rung as before. See migrateGradesToV17.
+    if (db.pragma("user_version", { simple: true }) < 17) {
+        (0, grades_sql_1.migrateGradesToV17)(db);
+        db.pragma("user_version = 17");
+    }
 }

package/dist/telemetry/store.d.ts

@@ -52,6 +52,15 @@ export interface ExportableTelemetryStore extends TelemetryStore {
      * non-null inference_id, or null (E4 chunk A: bake-off rehydration resolves an
      * eval case's source step to the inference that keys its captured input). */
     getStepInferenceId(runId: string, stepKey: string): string | null;
+    /** ARC-1 conversation re-entry: the newest `running` run for (pipeline,
+     * episode_key) in THIS local store, with its recorded step keys (the caller
+     * derives the turn counter from `turn:<n>.<k>` keys), or null. Local only —
+     * cross-process re-entry is out of scope (duplicate runs per episode are
+     * tolerated, 00031). */
+    findOpenRun?(pipeline: string, episodeKey: string): {
+        readonly row: RunRow;
+        readonly stepKeys: readonly string[];
+    } | null;
     listEnvelopes(): EnvelopeRow[];
     /** Local exporter watermark (per source instance), 0 when unset. */
     getExportWatermark(sourceId: string): number;

package/dist/telemetry/store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/telemetry/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EACV,WAAW,EACX,QAAQ,EACR,MAAM,EACN,OAAO,EACP,YAAY,EACZ,cAAc,EACf,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAA2B,KAAK,cAAc,EAAuB,MAAM,UAAU,CAAC;AAU7F;;;;;GAKG;AACH,MAAM,WAAW,wBAAyB,SAAQ,cAAc;IAC9D,qEAAqE;IACrE,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,YAAY,CAAA;KAAE,CAAC,CAAC;IACpG;kEAC8D;IAC9D,WAAW,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAC;IACjC;;wDAEoD;IACpD,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,QAAQ,CAAA;KAAE,CAAC,CAAC;IAC5F;mEAC+D;IAC/D,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,iFAAiF;IACjF,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,kEAAkE;IAClE,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxF,mEAAmE;IACnE,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAC1F;;iFAE6E;IAC7E,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAClE,aAAa,IAAI,WAAW,EAAE,CAAC;IAC/B,oEAAoE;IACpE,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7C,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9D;;;;;OAKG;IACH,kBAAkB,CAAC,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE,CAAC;CAC3E;AAgSD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,wBAAwB,CA6P3E"}
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/telemetry/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EACV,WAAW,EACX,QAAQ,EACR,MAAM,EACN,OAAO,EACP,YAAY,EACZ,cAAc,EACf,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAA2B,KAAK,cAAc,EAAuB,MAAM,UAAU,CAAC;AAU7F;;;;;GAKG;AACH,MAAM,WAAW,wBAAyB,SAAQ,cAAc;IAC9D,qEAAqE;IACrE,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,YAAY,CAAA;KAAE,CAAC,CAAC;IACpG;kEAC8D;IAC9D,WAAW,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAC;IACjC;;wDAEoD;IACpD,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,QAAQ,CAAA;KAAE,CAAC,CAAC;IAC5F;mEAC+D;IAC/D,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,iFAAiF;IACjF,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,kEAAkE;IAClE,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxF,mEAAmE;IACnE,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAC1F;;iFAE6E;IAC7E,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAClE;;;;4BAIwB;IACxB,WAAW,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,GAAG,IAAI,CAAC;IAC1H,aAAa,IAAI,WAAW,EAAE,CAAC;IAC/B,oEAAoE;IACpE,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7C,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9D;;;;;OAKG;IACH,kBAAkB,CAAC,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE,CAAC;CAC3E;AAgSD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,wBAAwB,CAyQ3E"}

package/dist/telemetry/store.js

@@ -403,6 +403,16 @@ function openTelemetryStore(dbPath) {
                 .all(afterRowid, limit);
             return rows.map((r) => ({ rowid: r.__rowid, row: toStepRow(r) }));
         },
+        findOpenRun(pipeline, episodeKey) {
+            const r = db
+                .prepare("SELECT * FROM runs WHERE pipeline = ? AND episode_key = ? AND status = 'running' " +
+                "ORDER BY started_at DESC LIMIT 1")
+                .get(pipeline, episodeKey);
+            if (r === undefined)
+                return null;
+            const keys = db.prepare("SELECT DISTINCT step_key FROM steps WHERE run_id = ?").all(r.id);
+            return { row: toRunRow(r), stepKeys: keys.map((k) => k.step_key) };
+        },
         getStepInferenceId(runId, stepKey) {
             const r = db
                 .prepare("SELECT inference_id FROM steps WHERE run_id = ? AND step_key = ? AND inference_id IS NOT NULL " +