@open-everywhere/core 0.1.0

package/dist/agent/model/call-capture.js

@@ -0,0 +1,374 @@
+// THE MODEL-CALL CAPTURE HOOK (OPE-846) — a byte-exact, PER-RUN-ARMED recorder of the composed
+// request body each model round-trip sends. It exists for ONE consumer: the soak lane's
+// prefix-replay bench (`soak-lane-design-2026-08-19.md` §4/§10), which replays a frozen 100k-token
+// prefix ten times to score behaviour at depth.
+//
+// 🔴 WHY BYTES, NOT EVENTS. eve's durable event stream already records what HAPPENED — the wake
+// envelope, the tool calls, the per-step usage. Rebuilding the model's INPUT from those events is a
+// semantic re-render: the system prompt bytes, the tool-definition JSON, the exact message ordering,
+// the harness's own step-boundary notice and any compaction rewrite are absent or reconstructed. A
+// replay driven by a re-render measures the re-render, not the run. So the bytes are recorded at the
+// moment they are sent, or they do not exist.
+//
+// 🔴 ARMED PER RUN, NEVER ALWAYS-ON. `soak.capture` ships OFF and has no environment path, so arming
+// is a one-line diff plus a deploy — the same bar every behaviour setting in this deployment takes.
+// Disarmed, this module does ONE boolean settings read per model call and writes nothing. That is
+// deliberate and it is a SECURITY property, not a performance one: a capture row holds the whole
+// composed prompt, which carries rendered member messages and tool output verbatim. It is
+// transcript-grade at rest. A store of that sensitivity must not grow silently on ordinary traffic.
+//
+// WHERE IT SITS, AND WHY THAT SEAM. `model/routing.ts` decorates the ModelBackend it was handed, so
+// every model instance the router hands back — routed wrapper, no-op default, fail-soft default —
+// is built from a capture-decorated `backend.model(id)`. The decorator is therefore the LAST thing
+// before the transport, which is the only position that records the bytes the model actually saw:
+// the routed wrapper's `applyRoute`/`applyOptions` rewrite has already run, and so has the step
+// boundary's soft wrap-up notice (`withWrapUpNotice` wraps the router's return, so its edited prompt
+// flows INWARD through the router's dispatch to here).
+//
+// 🔴 THE CROSS-CHECK IS THE POINT OF THE COUNTERS (the OPE-462 class). A hook wired into ONE
+// resolver is invisible on any path that does not use that resolver — and this repo has already
+// shipped exactly that defect once. So the module keeps a second, INDEPENDENT count: `hooks/spend.ts`
+// calls {@link noteCompletedModelStep} from eve's `step.completed` event, which fires for every step
+// eve ran whatever model instance served it. When completed steps outrun captures, a model call
+// reached the provider on a path this decorator never saw, and the turn writes ONE loud audit row
+// (`soak.capture_gap`). A capture set with a gap is not a replay source; it is a bug report.
+//
+// The hard step-boundary backstop is the one honest exception — it answers from a text-only stub and
+// makes NO network call, so it emits a completed step with no bytes to capture. `routing.ts` calls
+// {@link noteUncalledModelStep} on that branch so the excusal is recorded rather than inferred.
+import { createHash } from "node:crypto";
+import { gzipSync } from "node:zlib";
+import { getSettings } from "../settings/settings.js";
+import { appendAudit } from "../audit/audit.js";
+import { resolvePartition, domainKeyOf } from "../memory/partition.js";
+import { currentSessionId } from "../identity/binding.js";
+import { getOperationalStore } from "../operational/provider.js";
+/** The audit action a capture/step-count mismatch writes. `detail` carries all three counts. */
+export const CAPTURE_GAP_ACTION = "soak.capture_gap";
+/**
+ * The schema version stamped on every row. `RoutedCallOptions` is structurally the AI SDK's
+ * pre-1.0 call-options object, so a replay bench must be able to tell which shape it is reading
+ * rather than guessing from the bytes. Bump this whenever the SERIALISED shape changes.
+ */
+export const CAPTURE_SCHEMA_VERSION = 1;
+/**
+ * Ceiling on one stored body, measured on the gzip+base64 text actually written. Well above a
+ * 150k-token prompt (which lands near 200 KB base64), so it binds only on something pathological.
+ * Past it the row is still written — metadata, sha256 and byte counts intact — with an EMPTY body
+ * and `truncated` set, because a metadata row that says "this call was too big to keep" is a fact
+ * a harvester can act on, and a failed insert is not.
+ */
+export const CAPTURE_MAX_BODY_B64_BYTES = 8_000_000;
+/** How many live (session, turn) counter entries one process retains. Same bound and same reasoning
+ *  as `model/step-boundary.ts`'s MAX_TRACKED_TURNS: it bounds turns IN FLIGHT on one instance, and
+ *  an evicted entry only resets a still-running turn's cross-check (fail-open, never a false gap —
+ *  see {@link noteCompletedModelStep}). */
+const MAX_TRACKED_CAPTURE_TURNS = 512;
+const counts = new Map();
+/** The counter key. SESSION-scoped, never bare turn id: eve mints `turn_${sequence}`, so every
+ *  session's first turn is `turn_0` and a bare key would merge a seat's turn with its worker's.
+ *  Same rule (and same wording) as `step-boundary.ts` stepCountKey. */
+function captureCountKey(sessionId, turnId) {
+    return `${sessionId ?? ""}:${turnId ?? ""}`;
+}
+function entry(key) {
+    let c = counts.get(key);
+    if (!c) {
+        c = { attempted: 0, captured: 0, uncalled: 0, completed: 0, reported: false };
+        counts.set(key, c);
+        if (counts.size > MAX_TRACKED_CAPTURE_TURNS) {
+            const oldest = counts.keys().next();
+            if (!oldest.done)
+                counts.delete(oldest.value);
+        }
+    }
+    return c;
+}
+/** Test seam: forget every tracked turn. */
+export function _resetCaptureCountsForTest() {
+    counts.clear();
+}
+/** Read-only view of one turn's counts — for the cross-check test and for diagnostics. */
+export function captureCountsFor(sessionId, turnId) {
+    const c = counts.get(captureCountKey(sessionId, turnId));
+    return c ? { ...c } : undefined;
+}
+/**
+ * Is capture armed for this deployment? One settings read, fail-soft: an unreadable settings object
+ * means DISARMED, never armed. A recorder that fails open would grow a transcript-grade store on a
+ * deployment that never asked for one.
+ */
+export function captureArmed(settings = safeSettings()) {
+    return settings?.soak.capture === true;
+}
+/**
+ * Normalise `soak.captureSurfacePrefix` to a list of prefixes (OPE-864). A bare string is
+ * shorthand for a one-prefix list, so `"slack/T1/"` and `["slack/T1/"]` behave identically. This is
+ * the ONE place that shape decision is made — {@link captureCoversSurface} and every caller that
+ * needs to read the armed scope (e.g. a runbook diagnostic) go through it rather than re-deciding
+ * string-vs-array for themselves.
+ */
+export function capturePrefixList(raw) {
+    if (raw === undefined)
+        return [""];
+    return typeof raw === "string" ? [raw] : raw;
+}
+/**
+ * Does this surface fall inside the armed scope? `soak.captureSurfacePrefix` is the design's "only
+ * on the soak domain" narrowing: a run arms capture for the soak fixtures, not for every
+ * conversation the deployment happens to be holding. A run spanning several platform families (the
+ * soak domain's own slack/notion/linear/github spread) can arm a LIST of prefixes — any match
+ * covers the call. An empty prefix in the list (the shipped `""`, an empty array, or any list
+ * containing `""`) means every surface, which is not the recommended posture, and the setting's own
+ * summary says so.
+ *
+ * {@link noteCompletedModelStep}'s cross-check reads this same function through
+ * {@link captureSiteFrom} — the witness and the gap-check obey the identical armed scope, never a
+ * second copy of the prefix logic that could drift from the recorder's.
+ */
+export function captureCoversSurface(surfaceKey, settings = safeSettings()) {
+    const prefixes = capturePrefixList(settings?.soak.captureSurfacePrefix);
+    return prefixes.length === 0 || prefixes.some((p) => p.length === 0 || surfaceKey.startsWith(p));
+}
+function safeSettings() {
+    try {
+        return getSettings();
+    }
+    catch {
+        return undefined;
+    }
+}
+// ── serialisation ────────────────────────────────────────────────────────────────────────────────
+/**
+ * Serialise one call's options to the exact JSON a replay resends.
+ *
+ * Two things are dropped and both are structural rather than editorial: FUNCTIONS (a tool's
+ * `execute`, an AI SDK callback — not wire content, and not serialisable) and the `abortSignal`
+ * (per-invocation transport state). Everything else — the whole message array, the tool-definition
+ * JSON, provider options, sampling knobs — is kept verbatim. THIS FUNCTION MUST NOT REDACT: a
+ * redacted prefix is a different prompt, and replaying it would measure the redaction.
+ *
+ * 🔴 CYCLE DETECTION IS AN ANCESTOR CHECK, NOT A SEEN-SET, and the difference is a fidelity bug. A
+ * `WeakSet` of everything visited also flags the SECOND appearance of a shared-but-acyclic object —
+ * one schema object referenced by two tool definitions, say — and would replace real wire content
+ * with a marker. `JSON.stringify` calls the replacer with `this` bound to the value's immediate
+ * HOLDER, so unwinding the stack to that holder rebuilds the true ancestor chain, and only a
+ * genuine cycle is marked.
+ */
+export function serialiseCallBody(options) {
+    const ancestors = [];
+    return JSON.stringify(options, function replacer(key, value) {
+        while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this)
+            ancestors.pop();
+        if (key === "abortSignal")
+            return undefined;
+        if (typeof value === "function")
+            return undefined;
+        if (typeof value === "bigint")
+            return value.toString();
+        if (typeof value === "object" && value !== null) {
+            if (ancestors.includes(value))
+                return "[circular]";
+            ancestors.push(value);
+        }
+        return value;
+    });
+}
+/** sha256 of the serialised body, hex. The identity a replay quotes — it is what makes "the same
+ *  prefix" a checkable claim rather than an assertion. */
+export function bodySha256(serialised) {
+    return createHash("sha256").update(serialised, "utf8").digest("hex");
+}
+/** gzip the serialised body and base64 it. Base64 TEXT rather than a `bytea`/`BLOB` column because
+ *  every other column in the operational store is text and the two adapters then need no
+ *  driver-specific byte handling — the same choice `stored_credential.ciphertext` already makes. */
+function gzipBase64(serialised) {
+    return gzipSync(Buffer.from(serialised, "utf8")).toString("base64");
+}
+/**
+ * Resolve the call site from the resolver's ctx and its `step.started` event, or undefined when the
+ * ctx cannot be bound. Never throws — a capture that cannot be scoped is skipped, exactly as
+ * `reportStepBoundary` skips an audit row it cannot scope.
+ */
+export function captureSiteFrom(ctx, event) {
+    try {
+        const p = resolvePartition(ctx);
+        // SPEND grain (domainKeyOf), the same key `usage_events` rows carry, so a harvester can join a
+        // capture to the cost row for the same call without a second grain to reconcile.
+        const surfaceKey = domainKeyOf(p);
+        if (!captureCoversSurface(surfaceKey))
+            return undefined; // outside the armed scope ⇒ no recorder
+        const sessionId = currentSessionId(ctx) ?? "";
+        const turnId = eventTurnId(event) ?? "";
+        return { org: p.org, surfaceKey, sessionId, turnId };
+    }
+    catch {
+        return undefined;
+    }
+}
+function eventTurnId(event) {
+    const turnId = event?.data?.turnId;
+    return typeof turnId === "string" && turnId.length > 0 ? turnId : undefined;
+}
+/**
+ * Wrap `deps` so every model this router builds records its call bodies. Returns `deps` UNCHANGED
+ * when capture is disarmed or the site cannot be resolved — the disarmed path allocates nothing and
+ * adds no indirection to the model call.
+ */
+export function withCapture(deps, site) {
+    if (site === undefined)
+        return deps;
+    return { ...deps, backend: captureBackend(deps.backend, site) };
+}
+function captureBackend(backend, site) {
+    return {
+        model: (id) => captureModel(backend.model(id), site),
+        applyOptions: (route, options, ids) => backend.applyOptions(route, options, ids),
+    };
+}
+/**
+ * The recording shim. Built field-by-field rather than by spreading `inner` (a provider model may
+ * carry methods on a prototype, which a spread drops) — the same construction `withWrapUpNotice`
+ * uses and for the same reason.
+ *
+ * 🔴 THE WRITE IS AWAITED, and that is a deliberate trade. A fire-and-forget write can be discarded
+ * when a serverless invocation freezes, and the calls most likely to be lost are the LAST ones in a
+ * turn — the deepest, most valuable prefixes, and the pre-compaction states nothing else can
+ * recover. Capture is armed only for a soak run, so the added latency is paid by a run whose whole
+ * purpose is to produce these bytes. A write that FAILS still never breaks the model call: the error
+ * is logged (never the body) and the call proceeds.
+ */
+function captureModel(inner, site) {
+    const record = async (options) => {
+        const c = entry(captureCountKey(site.sessionId, site.turnId));
+        c.attempted += 1;
+        try {
+            const serialised = serialiseCallBody(options);
+            const b64 = gzipBase64(serialised);
+            const truncated = b64.length > CAPTURE_MAX_BODY_B64_BYTES;
+            const write = {
+                org: site.org,
+                surfaceKey: site.surfaceKey,
+                sessionId: site.sessionId,
+                turnId: site.turnId,
+                stepIndex: c.attempted - 1,
+                ts: new Date().toISOString(),
+                model: inner.modelId,
+                provider: inner.provider,
+                schemaVersion: CAPTURE_SCHEMA_VERSION,
+                sha256: bodySha256(serialised),
+                bodyBytes: Buffer.byteLength(serialised, "utf8"),
+                bodyGzipB64: truncated ? "" : b64,
+                truncated,
+            };
+            if (truncated) {
+                console.warn(`[open-everywhere:capture] body too large to store (${b64.length} b64 bytes > ${CAPTURE_MAX_BODY_B64_BYTES}) — ` +
+                    `metadata row written with an EMPTY body (session=${site.sessionId} turn=${site.turnId} step=${write.stepIndex}). This capture cannot be replayed.`);
+            }
+            await getOperationalStore().appendModelCallCapture(write);
+            // Counted only once the store has ACCEPTED the row — see TurnCounts.captured.
+            c.captured += 1;
+        }
+        catch (err) {
+            // NEVER log the body or any part of it — only that a write failed and where.
+            console.warn(`[open-everywhere:capture] capture write skipped (session=${site.sessionId} turn=${site.turnId}): ${String(err)}`);
+        }
+    };
+    const shim = {
+        specificationVersion: inner.specificationVersion,
+        provider: inner.provider,
+        modelId: inner.modelId,
+        supportedUrls: inner.supportedUrls,
+        async doGenerate(options) {
+            await record(options);
+            return inner.doGenerate(options);
+        },
+        async doStream(options) {
+            await record(options);
+            return inner.doStream(options);
+        },
+    };
+    return shim;
+}
+// ── the cross-check ──────────────────────────────────────────────────────────────────────────────
+/**
+ * Record that eve completed one model step for this turn — the INDEPENDENT witness. Called from
+ * `hooks/spend.ts`'s `step.completed` arm, which is the deployment's one universal step.completed
+ * adapter, so this counts every step regardless of which model instance served it.
+ *
+ * The comparison, and why it is one-sided:
+ *   • `captured + uncalled < completed` ⇒ a step reached a provider on a path the capture decorator
+ *     never saw. That is the OPE-462 class and it is LOUD — one audit row per turn.
+ *   • `captured > completed` is NOT a gap. Compaction summarises with the routed turn model and
+ *     emits no `step.completed`, so more captures than completed steps is the normal reading.
+ *
+ * No-ops entirely when capture is disarmed. Never throws — a bookkeeping guard must not break a hook.
+ */
+export function noteCompletedModelStep(sessionId, turnId, ctx) {
+    try {
+        if (!captureArmed())
+            return;
+        // 🔴 THE WITNESS MUST OBEY THE SAME SCOPE AS THE RECORDER. With `soak.captureSurfacePrefix` set,
+        // an off-soak turn records nothing — so counting its completed steps here would report a gap on
+        // every unrelated conversation the deployment holds. A step this module cannot scope (no ctx, an
+        // unbindable one, or a surface outside the armed prefix) is not counted at all.
+        if (!ctx || captureSiteFrom(ctx) === undefined)
+            return;
+        const key = captureCountKey(sessionId, turnId);
+        const c = entry(key);
+        c.completed += 1;
+        if (c.reported || c.captured + c.uncalled >= c.completed)
+            return;
+        c.reported = true;
+        reportCaptureGap(sessionId, turnId, c, ctx);
+    }
+    catch {
+        /* the cross-check never breaks the hook that feeds it */
+    }
+}
+/**
+ * Record that a step ran WITHOUT a model call — today only the hard step-boundary backstop, whose
+ * text-only stub answers from process memory and touches no transport. Excusing it explicitly is
+ * what keeps the cross-check honest: inferring the excusal would mean the gap detector quietly
+ * tolerating a whole class of missing captures.
+ */
+export function noteUncalledModelStep(site) {
+    try {
+        if (site === undefined || !captureArmed())
+            return; // no site ⇒ outside the armed scope ⇒ nothing to excuse
+        entry(captureCountKey(site.sessionId, site.turnId)).uncalled += 1;
+    }
+    catch {
+        /* never breaks the resolver */
+    }
+}
+/** One console line and one audit row for a turn whose captures fell behind its completed steps.
+ *  Best-effort at both sinks, exactly like `reportStepBoundary`. */
+function reportCaptureGap(sessionId, turnId, c, ctx) {
+    const detail = { attempted: c.attempted, captured: c.captured, uncalled: c.uncalled, completed: c.completed, sessionId: sessionId ?? "", turnId: turnId ?? "" };
+    try {
+        console.warn(`[open-everywhere:capture] CAPTURE GAP on turn ${detail.turnId} (session ${detail.sessionId}): ` +
+            `${c.completed} model steps completed but only ${c.captured} captured (${c.attempted} attempted, +${c.uncalled} excused). ` +
+            `A model call reached a provider on a path the capture hook does not wrap — this session's captures are NOT a replay source.`);
+    }
+    catch {
+        /* a console that throws must not take the turn with it */
+    }
+    // No ctx, or an unbindable one, means no scope for the row — and a row nobody can attribute is
+    // worse than none. The console line above is then the whole witness, which is the same trade
+    // `reportStepBoundary` makes on the same failure.
+    if (!ctx)
+        return;
+    let where;
+    try {
+        const p = resolvePartition(ctx);
+        where = { org: p.org, platform: p.platform, workspace: p.workspace, surface: p.surface };
+    }
+    catch {
+        return;
+    }
+    void appendAudit({ ...where, action: CAPTURE_GAP_ACTION, detail }).catch(() => {
+        /* appendAudit is best-effort by contract; this catch only guards an unhandled rejection */
+    });
+}
+//# sourceMappingURL=call-capture.js.map

package/dist/agent/model/call-capture.js.map

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

package/dist/agent/model/default-model.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Publish the app's resolved primary-role model id as core's default.
+ *
+ * Idempotent and last-write-wins, like `registerSettings`/`registerModelPricing` beside it. It is
+ * NOT fail-loud when never called: a core-only process (a unit test importing one module, the
+ * plugin extractor run standalone) legitimately has no app config, and the literal below is the
+ * right answer there.
+ */
+export declare function registerDefaultAgentModelId(id: string): void;
+/** Test seam: drop the registered default (a fresh test shouldn't inherit another's). */
+export declare function _resetDefaultAgentModelIdForTest(): void;
+export declare function defaultAgentModelId(): string;
+//# sourceMappingURL=default-model.d.ts.map

package/dist/agent/model/default-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-model.d.ts","sourceRoot":"","sources":["../../../agent/model/default-model.ts"],"names":[],"mappings":"AAsCA;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAE5D;AAED,yFAAyF;AACzF,wBAAgB,gCAAgC,IAAI,IAAI,CAEvD;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAO5C"}

package/dist/agent/model/default-model.js

@@ -0,0 +1,58 @@
+// The DEPLOY-WIDE default turn model id — one expression, three call sites (OPE-45).
+//
+// Precedence, unchanged from the original inline copy in agent/agent.ts:
+//   OE_FORCE_MODEL  — the build-phase HARD PIN ("one model for now", Tommy 2026-07-17). It also
+//                     overrides every per-domain route at model/routing.ts; here it overrides the
+//                     authored default too, so a pinned deploy is pinned everywhere.
+//   OE_PRIMARY_MODEL — the DEFAULT id knob (Tommy 2026-07-13: a build-phase deploy drops the whole
+//                     org onto a cheap model without touching the committed default). Loses to a
+//                     per-domain route, exactly as before.
+//   the app's REGISTERED default — the primary role of the model stack the app resolved
+//                     (agent/model/models.ts calls registerDefaultAgentModelId). Added by OPE-398:
+//                     once the app can pick a whole role-set by alias, core's own literal is no
+//                     longer the only answer to "what is the default", and a core-internal caller
+//                     that could not see app config would otherwise disagree with every other
+//                     surface the moment a non-shipped stack was selected.
+//   the literal below — core's LIBRARY default, for a fresh clone or a core-only process that
+//                     never imported app config. `npm run lint:model-ids` pins it EQUAL to the
+//                     shipped stack's primary id (agent/model/stacks.ts, SHIPPED_STACK), so the
+//                     two can never drift for the configuration this repo actually ships.
+//
+// APP CONFIG SHOULD NOT CALL THIS DIRECTLY, except to register. The reference app resolves its
+// stack once, in agent/model/models.ts, publishes the primary here, and everything else derives
+// from the role consts that file exports — see it for why (six hand-synced copies of one id).
+//
+// WHY A FUNCTION, NOT A CONST: a module-level constant would freeze the env read at import time,
+// which is wrong for tests that set/restore the knobs (model-routing-test.ts already does this for
+// OE_FORCE_MODEL). Callers that want the compile-time-frozen behaviour just call it once at module
+// scope — but note that a call frozen at module scope in CORE can run BEFORE the app registers, so
+// core-side readers now resolve lazily instead (plugins/extract.ts).
+//
+// Read by: the root agent config (agent/agent.ts, via the role registry), the plugin extractor's
+// generated subagents (agent/plugins/extract.ts), and each hand-authored declared subagent
+// (agent/subagents/<name>/agent.ts). Keeping them on one seam is the point — a fourth divergent
+// copy of this expression is how a build-phase pin silently misses a surface.
+/** The app's resolved default, published by `agent/model/models.ts` at config load. */
+let registeredDefault;
+/**
+ * Publish the app's resolved primary-role model id as core's default.
+ *
+ * Idempotent and last-write-wins, like `registerSettings`/`registerModelPricing` beside it. It is
+ * NOT fail-loud when never called: a core-only process (a unit test importing one module, the
+ * plugin extractor run standalone) legitimately has no app config, and the literal below is the
+ * right answer there.
+ */
+export function registerDefaultAgentModelId(id) {
+    registeredDefault = id;
+}
+/** Test seam: drop the registered default (a fresh test shouldn't inherit another's). */
+export function _resetDefaultAgentModelIdForTest() {
+    registeredDefault = undefined;
+}
+export function defaultAgentModelId() {
+    return (process.env.OE_FORCE_MODEL?.trim() ||
+        process.env.OE_PRIMARY_MODEL?.trim() ||
+        registeredDefault ||
+        "openai/gpt-6-luna");
+}
+//# sourceMappingURL=default-model.js.map

package/dist/agent/model/default-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-model.js","sourceRoot":"","sources":["../../../agent/model/default-model.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,EAAE;AACF,yEAAyE;AACzE,gGAAgG;AAChG,kGAAkG;AAClG,qFAAqF;AACrF,mGAAmG;AACnG,iGAAiG;AACjG,2DAA2D;AAC3D,wFAAwF;AACxF,mGAAmG;AACnG,gGAAgG;AAChG,kGAAkG;AAClG,8FAA8F;AAC9F,2EAA2E;AAC3E,8FAA8F;AAC9F,+FAA+F;AAC/F,gGAAgG;AAChG,0FAA0F;AAC1F,EAAE;AACF,+FAA+F;AAC/F,gGAAgG;AAChG,8FAA8F;AAC9F,EAAE;AACF,iGAAiG;AACjG,mGAAmG;AACnG,mGAAmG;AACnG,mGAAmG;AACnG,qEAAqE;AACrE,EAAE;AACF,iGAAiG;AACjG,2FAA2F;AAC3F,gGAAgG;AAChG,8EAA8E;AAE9E,uFAAuF;AACvF,IAAI,iBAAqC,CAAC;AAE1C;;;;;;;GAOG;AACH,MAAM,UAAU,2BAA2B,CAAC,EAAU;IACpD,iBAAiB,GAAG,EAAE,CAAC;AACzB,CAAC;AAED,yFAAyF;AACzF,MAAM,UAAU,gCAAgC;IAC9C,iBAAiB,GAAG,SAAS,CAAC;AAChC,CAAC;AAED,MAAM,UAAU,mBAAmB;IACjC,OAAO,CACL,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,IAAI,EAAE;QAClC,OAAO,CAAC,GAAG,CAAC,gBAAgB,EAAE,IAAI,EAAE;QACpC,iBAAiB;QACjB,mBAAmB,CACpB,CAAC;AACJ,CAAC"}

package/dist/agent/model/model-stamp.d.ts

@@ -0,0 +1,41 @@
+/** Stamp the model id THIS call resolved to. Fail-soft: outside a session context
+ *  (or any other defineState failure) this is a silent no-op. */
+export declare function stampModelCall(modelId: string): void;
+/** The last-stamped model id for this session, or null (no stamp yet / no session). */
+export declare function readModelStamp(): string | null;
+/** Stamp `modelId` (or clear, with null) and return the PREVIOUS stamp. Fail-soft like
+ *  stampModelCall: outside a session context this no-ops and returns null. */
+export declare function swapModelStamp(modelId: string | null): string | null;
+/**
+ * The REGISTRY spelling of a host model-reference id, or undefined when the id names no model.
+ *
+ * eve formats that id with `formatLanguageModelGatewayId`
+ * (node_modules/eve/dist/src/internal/runtime-model.js), and the two shapes it produces differ:
+ *  - an authored STRING passes through unchanged, so a declared subagent's `model: PRIMARY_MODEL`
+ *    arrives as the registry id already;
+ *  - a model INSTANCE becomes `<provider>/<modelId>`, and the gateway backend's provider is
+ *    `gateway` (packages/adapters/agent/model/gateway.ts), so a routed call arrives as
+ *    `gateway/openai/gpt-6-luna`. Dropping that one prefix recovers the registry id.
+ *
+ * 🔴 THE REMAINDER MUST STILL NAME A VENDOR. `gateway/<model>` with no second slash carries no
+ * vendor to recover, so such an id is returned exactly as the host wrote it rather than shortened
+ * into some other model's spelling — a wrong model id prices a row at another model's rate, which
+ * is the error UNKNOWN_MODEL was introduced to stop. Pure; pinned by scripts/model-routing-test.ts.
+ */
+export declare function registryModelIdFrom(hostModelId: unknown): string | undefined;
+/** Record the host's model reference for the step now starting. Fail-soft like every other writer
+ *  in this file: an id that names no model, or no session context at all, is a silent no-op. */
+export declare function noteHostStepModel(hostModelId: unknown): void;
+/** The host's model reference for this session's last started step, or null (none seen / no
+ *  session). Read by hooks/spend.ts ONLY when this session stamped nothing of its own. */
+export declare function readHostStepModel(): string | null;
+/** Run `fn` with `modelId` stamped, restoring the previous stamp on the way out — success OR
+ *  throw. For utility model calls that run INSIDE a seat's turn step (the approval judge):
+ *  hooks/spend.ts costs the whole step off the LAST stamp at step.completed, so a stamp that
+ *  outlives the utility call mis-attributes the seat's own (much larger) usage to the utility
+ *  model. Live-observed on 2026-08-08: two failed judge calls left `judge`-model stamps and two
+ *  seat turns' deepseek usage was priced as gpt-5.6-luna. The trade this scope accepts: the
+ *  utility call's OWN tokens attribute to the seat's model — small and bounded, vs. the seat's
+ *  step attributing to the judge, which is neither. */
+export declare function withModelStampScope<T>(modelId: string, fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=model-stamp.d.ts.map

package/dist/agent/model/model-stamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-stamp.d.ts","sourceRoot":"","sources":["../../../agent/model/model-stamp.ts"],"names":[],"mappings":"AA8BA;iEACiE;AACjE,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAOpD;AAED,uFAAuF;AACvF,wBAAgB,cAAc,IAAI,MAAM,GAAG,IAAI,CAM9C;AAED;8EAC8E;AAC9E,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAQpE;AAwCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAM5E;AAED;gGACgG;AAChG,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI,CAQ5D;AAED;0FAC0F;AAC1F,wBAAgB,iBAAiB,IAAI,MAAM,GAAG,IAAI,CAMjD;AAED;;;;;;;uDAOuD;AACvD,wBAAsB,mBAAmB,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAO9F"}