modelrig 0.8.0 → 0.9.0

package/dist/screen/screen-cli.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * `modelrig screen …` (SC-1a, spec §9) — extracted from cli.ts to keep it under
+ * the 700-LOC cap (same discipline as mask-policy-cli.ts).
+ *
+ *   modelrig screen check <file|->   dry-run: scan content with the T0 pattern
+ *                                    pack and print COUNTS by type × source.
+ *                                    NEVER prints a matched value (spec §1.4).
+ *   modelrig screen pull <detector>  resolve the LOCAL cache path for an optional
+ *                                    classifier's weights and, with --url, fetch
+ *                                    them there. ModelRig never bundles or
+ *                                    re-hosts weights (A3).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScreenCli = runScreenCli;
+const node_fs_1 = require("node:fs");
+const node_fs_2 = require("node:fs");
+const node_path_1 = require("node:path");
+const screen_1 = require("./screen");
+const policy_1 = require("./policy");
+const probe_1 = require("./probe");
+const probe_corpora_1 = require("./fixtures/probe-corpora");
+const KNOWN_SOURCES = new Set([
+    "template",
+    "variable",
+    "search",
+    "tool_result",
+    "proxy_user",
+    "judge_meta",
+    "unknown",
+]);
+/** Read the target — a file path, or `-` for stdin. */
+function readTarget(target) {
+    if (target === "-")
+        return (0, node_fs_2.readFileSync)(0, "utf8"); // fd 0 = stdin
+    return (0, node_fs_2.readFileSync)(target, "utf8");
+}
+/** `modelrig screen check <file|->` — dry-run over one segment, counts only. */
+async function screenCheck(flags) {
+    const target = flags.positional[1];
+    if (target === undefined) {
+        console.error("usage: modelrig screen check <file|->  [--source search|variable|proxy_user|tool_result]");
+        return 1;
+    }
+    const source = (flags.named.get("source") ?? "search");
+    if (!KNOWN_SOURCES.has(source)) {
+        console.error(`unknown --source "${source}" — allowed: ${[...KNOWN_SOURCES].join(", ")}`);
+        return 1;
+    }
+    let text;
+    try {
+        text = readTarget(target);
+    }
+    catch (err) {
+        console.error(`cannot read ${target === "-" ? "stdin" : `"${target}"`}: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    // Dry-run policy: detect mode, T0 pattern pack, default threshold. The content
+    // is scanned as a single untrusted segment; only COUNTS are printed.
+    const seam = (0, screen_1.createScreenSeam)((0, policy_1.resolveScreenPolicy)((0, policy_1.parseScreenPolicy)({ mode: "detect" })));
+    await seam.screenRequest([{ source, tier: "untrusted", text }]);
+    const receipt = seam.receipt();
+    console.log(`screen check — dry run (patterns@v1, counts only; values are never shown)`);
+    console.log(`  risk: ${receipt.risk_bucket}`);
+    if (receipt.findings.length === 0) {
+        console.log("  findings: (none)");
+        return 0;
+    }
+    console.log("  findings (type × source × count):");
+    for (const f of receipt.findings) {
+        console.log(`    ${f.type.padEnd(34)} ${f.source.padEnd(12)} ${f.count}`);
+    }
+    return 0;
+}
+/** `modelrig screen pull <detector> [--url <url>]` — resolve the local cache
+ * path for a classifier's weights and, with --url, fetch them there. A3: weights
+ * are NEVER bundled or re-hosted — the URL is the model's own vendor/HF page. */
+async function screenPull(flags) {
+    const id = flags.positional[1];
+    if (id === undefined || !id.startsWith("classifier:")) {
+        console.error("usage: modelrig screen pull <classifier:name@version> [--url <weights-url>]");
+        return 1;
+    }
+    const dest = (0, policy_1.classifierModelPath)(id);
+    const url = flags.named.get("url");
+    if (url === undefined) {
+        console.log(`screen pull ${id}`);
+        console.log(`  local cache path: ${dest}`);
+        console.log("  ModelRig never bundles or re-hosts weights (A3). Provide the model's own");
+        console.log("  vendor/Hugging Face weights URL with --url to fetch them here, or place the");
+        console.log("  .onnx file at the path above, then install the optional runtime peer");
+        console.log("  (onnxruntime-node) and add the detector to your route's `screen.detectors`.");
+        return 0;
+    }
+    (0, node_fs_2.mkdirSync)((0, node_path_1.dirname)(dest), { recursive: true });
+    try {
+        const res = await fetch(url);
+        if (!res.ok || res.body === null) {
+            console.error(`fetch failed: ${res.status} ${res.statusText}`);
+            return 1;
+        }
+        const bytes = Buffer.from(await res.arrayBuffer());
+        await new Promise((resolveWrite, reject) => {
+            const out = (0, node_fs_1.createWriteStream)(dest);
+            out.on("error", reject);
+            out.on("finish", () => resolveWrite());
+            out.end(bytes);
+        });
+        console.log(`screen pull ${id} → ${dest} (${bytes.length} bytes)`);
+        return 0;
+    }
+    catch (err) {
+        console.error(`fetch failed: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+}
+/**
+ * `modelrig screen probe [--detectors <ids>] [--corpus <ids>]` (SC-3, spec-sc3
+ * §3) — run each configured detector over the license-clean SYNTHETIC corpora and
+ * print the MEASURED TPR / FPR / latency per corpus (counts + rates only, never a
+ * fixture value). The org-benign FP rate ("FP on your traffic") is measured from
+ * the content-capture lane in the console/hosted probe; the local CLI reports the
+ * public-corpus numbers and the "no captures to sample" teaching state, so a
+ * customer's traffic never rides this local surface.
+ */
+async function screenProbe(flags) {
+    const detectorArg = flags.named.get("detectors") ?? flags.named.get("detector");
+    const detectorIds = detectorArg !== undefined ? detectorArg.split(",").map((s) => s.trim()).filter(Boolean) : undefined;
+    const corpusArg = flags.named.get("corpus");
+    let corpora = probe_corpora_1.PROBE_CORPORA;
+    if (corpusArg !== undefined) {
+        const ids = corpusArg.split(",").map((s) => s.trim()).filter(Boolean);
+        const picked = ids.map((id) => (0, probe_corpora_1.corpusById)(id));
+        const missing = ids.filter((_id, i) => picked[i] === undefined);
+        if (missing.length > 0) {
+            console.error(`unknown corpus id(s): ${missing.join(", ")} — available: ${probe_corpora_1.PROBE_CORPORA.map((c) => c.id).join(", ")}`);
+            return 1;
+        }
+        corpora = picked.filter((c) => c !== undefined);
+    }
+    const resolved = (0, policy_1.resolveScreenPolicy)((0, policy_1.parseScreenPolicy)({ mode: "detect", ...(detectorIds !== undefined ? { detectors: detectorIds } : {}) }));
+    console.log("screen probe — measured on license-clean synthetic corpora (counts + rates only; values are never shown)");
+    for (const detector of resolved.detectors) {
+        const meta = resolved.detectorMeta.find((m) => m.id === detector.id);
+        const measured = await (0, probe_1.probeDetector)({
+            detector,
+            detectorVersion: meta?.version ?? "unknown",
+            corpora,
+            // The local CLI never samples a customer's captures (F9/P6); org-benign is
+            // measured by the console/hosted probe against the content-capture lane.
+            benign: [],
+        });
+        console.log(`\n  ${detector.id}  (version ${measured.detectorVersion}, threshold ${measured.threshold})`);
+        for (const c of measured.perCorpus) {
+            const tpr = c.tpr === null ? "n/a" : `${(c.tpr * 100).toFixed(1)}%`;
+            const fpr = c.fpr === null ? "n/a" : `${(c.fpr * 100).toFixed(1)}%`;
+            console.log(`    ${c.corpusId.padEnd(22)} n=${String(c.n).padEnd(4)} TPR ${tpr.padEnd(7)} FP ${fpr.padEnd(7)} ${c.latencyMs}ms  [${c.license}] ${c.digest.slice(0, 14)}…`);
+        }
+        console.log("    FP on your traffic: no captures to sample locally — run the probe from the console to sample the content-capture lane.");
+    }
+    console.log("\nProbed, not declared. Publish a detector-probe receipt from the console to make a number verifiable (never a literal).");
+    return 0;
+}
+/** Dispatch `modelrig screen <subcommand>`. */
+async function runScreenCli(flags) {
+    const sub = flags.positional[0];
+    switch (sub) {
+        case "check":
+            return screenCheck(flags);
+        case "pull":
+            return screenPull(flags);
+        case "probe":
+            return screenProbe(flags);
+        default:
+            console.error("usage: modelrig screen <check|pull|probe> …");
+            return 1;
+    }
+}

package/dist/screen/screen.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Screening — the screen engine + receipt producer (WIRED 2026-08-25, SC-1a).
+ * Spec §4 (actions), §4.3 (fail-closed matrix), §5 (receipt).
+ *
+ * Seam: {@link createScreenSeam} wraps the assembled request on the REQUEST side
+ * (src/run/dispatch.ts — the SAME helper CS-1's mask seam wraps; screening runs
+ * BEFORE masking so mask tokens never confuse a detector) and the AdapterResult
+ * on the RESPONSE side (canary / citation / Unicode output checks).
+ *
+ * Fail-closed (spec §4.3): a REQUIRED deterministic detector that THROWS fails
+ * closed under `enforce` (invariant_violation, no request sent); under `detect`
+ * it warns once, sets `degraded`, and sends. A MISSING OPTIONAL classifier is
+ * handled at resolve time (policy.ts drops it, `degraded: true`) — never a block.
+ *
+ * LEAK INVARIANT (spec §1.4): this module consumes span OFFSETS internally and
+ * emits COUNTS by (detector × type × source). No matched span, dictionary, raw
+ * untrusted content, or detector score reaches a receipt, log, or failure
+ * message. `summarizeScreen` is the SINGLE producer (same discipline as
+ * summarizeScrub / summarizeMask).
+ */
+import type { ContentSegment } from "./provenance";
+import type { ResolvedScreenPolicy, ScreenAction, ScreenFinding, ScreenPolicy, ScreenReceipt } from "./types";
+/** The request-side decision the run loop acts on. `block` ⇒ fail closed
+ * pre-dispatch (spec §4.3); otherwise `keepSegments` is the (possibly stripped)
+ * segment list to assemble and `quarantine` gates tool calls. */
+export interface ScreenRequestOutcome {
+    readonly kind: "ok" | "block";
+    readonly keepSegments: readonly ContentSegment[];
+    readonly quarantine: boolean;
+}
+/** Output-side hygiene result (pure). */
+export interface ScreenResponseResult {
+    readonly text: string;
+    readonly citationsDropped: number;
+    readonly canaryLeaked: boolean;
+}
+/** The accumulated outcome the single producer turns into a {@link
+ * ScreenReceipt}. Counts + enums only — never a value (spec §1.4). */
+export interface ScreenOutcome {
+    readonly policyHash: string;
+    readonly detectors: readonly {
+        readonly id: string;
+        readonly version: string;
+    }[];
+    readonly findings: readonly ScreenFinding[];
+    readonly maxConfidence: number;
+    readonly action: ScreenAction | "none";
+    readonly quarantinedToolCalls?: number;
+    readonly canaryLeaked?: boolean;
+    readonly citationsDropped?: number;
+    readonly degraded?: boolean;
+}
+/**
+ * The stateful per-run screen seam the dispatch helper drives. Runs the resolved
+ * detectors over the untrusted/semi segments, resolves the per-tier action,
+ * accumulates counts-only state, and produces the receipt via the single
+ * producer. A deterministic detector throw is the §4.3 fail-closed pivot: under
+ * `enforce` it surfaces as a `block` outcome (no request sent); under `detect` it
+ * warns once and degrades.
+ */
+export interface ScreenSeam {
+    /** Canary token to seed into the trusted system slot (spec §2.3), or null when
+     * the policy does not enable the canary. Read once at assembly time. */
+    readonly canaryToken: string | null;
+    /** Detect + resolve the request-side action. Async to admit the classifier
+     * tier. Accumulates findings/action into the seam. */
+    screenRequest(segments: readonly ContentSegment[]): Promise<ScreenRequestOutcome>;
+    /** Output-side hygiene: strip Unicode tags, allowlist citations, detect canary
+     * leak. Accumulates the counts and returns the cleaned text. */
+    screenResponse(text: string, injectedUrls: readonly string[]): string;
+    /** Record tool calls dropped because the turn was quarantined on a provider
+     * without `tool_choice_none` parity (A7). */
+    noteQuarantineDrop(count: number): void;
+    /** Build the counts-only {@link ScreenReceipt} from accumulated state. */
+    receipt(): ScreenReceipt;
+}
+export declare function createScreenSeam(resolved: ResolvedScreenPolicy): ScreenSeam;
+/**
+ * The SINGLE producer of {@link ScreenReceipt} (same single-producer discipline
+ * as summarizeScrub / summarizeMask). Its parameter type is already counts-only,
+ * making the leak invariant STRUCTURAL — it cannot receive a matched value, a
+ * span, or a detector's internal score. Derives `risk_bucket` from the max
+ * confidence (which is NOT persisted); omits optional fields when absent so the
+ * jsonb payload on `meta.screen` is minimal and stable.
+ */
+export declare function summarizeScreen(outcome: ScreenOutcome): ScreenReceipt;
+/**
+ * Pure output-side hygiene, decoupled from the seam for direct testing and for
+ * the CLI dry-run (spec §2.3): strip Unicode tag chars, allowlist citation URLs
+ * against the injected sources (INJ-6), detect a canary leak. Never mutates
+ * input; returns the cleaned text plus counts.
+ */
+export declare function screenResponse(outputText: string, policy: ScreenPolicy, injectedUrls: readonly string[], canaryToken?: string | null): ScreenResponseResult;
+/**
+ * Test-only: reset the once-per-process detect-throw warning latch (mirrors
+ * resetMaskWarningsForTest).
+ */
+export declare function resetScreenWarningsForTest(): void;
+//# sourceMappingURL=screen.d.ts.map

package/dist/screen/screen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen.d.ts","sourceRoot":"","sources":["../../src/screen/screen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,KAAK,EACV,oBAAoB,EAEpB,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,aAAa,EACd,MAAM,SAAS,CAAC;AAOjB;;iEAEiE;AACjE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,SAAS,cAAc,EAAE,CAAC;IACjD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAED,yCAAyC;AACzC,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAChC;AAED;sEACsE;AACtE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,SAAS;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACjF,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;IAC5C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC;IACvC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAmCD;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB;4EACwE;IACxE,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC;0DACsD;IACtD,aAAa,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAClF;oEACgE;IAChE,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;IACtE;iDAC6C;IAC7C,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,0EAA0E;IAC1E,OAAO,IAAI,aAAa,CAAC;CAC1B;AAID,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,UAAU,CAkH3E;AAuBD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,aAAa,CAarE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,YAAY,EACpB,YAAY,EAAE,SAAS,MAAM,EAAE,EAC/B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,GAC1B,oBAAoB,CAMtB;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD"}

package/dist/screen/sidecar.d.ts

@@ -0,0 +1,69 @@
+/**
+ * SC-2 — the sidecar `Detector` adapter (spec-sc2 §3; shared with CS-1 D6).
+ *
+ * A `Detector` of the reserved `kind: "sidecar"` that adapts a CUSTOMER-RUN de-id
+ * container (GLiNER Guard / GLiNER2-PII / Presidio) over a deliberately tiny HTTP
+ * contract. ModelRig ships the ADAPTER and the CONTRACT only — never a model,
+ * never re-hosted weights (research §6a.3). The customer stands up their own
+ * service and owns its weights/license.
+ *
+ * THE CONTRACT (content-out only to the customer's own service):
+ *   POST <endpoint>  { text, source, tier }        → the segment to scan
+ *   200  { spans: [{ start, end, type, confidence }] }   → spans ONLY, never
+ *                                                          the matched text back
+ * The receipt id is `sidecar:<digest>` — the customer's local image/config
+ * digest label; ModelRig stores the label, not the model.
+ *
+ * FAIL-CLOSED (spec-sc2 §3, inherits SC-1 §4.3 via the shipped screen seam):
+ * on unreachable / timeout / malformed response the adapter THROWS a typed
+ * {@link SidecarUnavailableError}. The shipped seam (screen.ts) catches a
+ * detector throw and — under `enforce` — fails the run PRE-DISPATCH
+ * (invariant_violation, no request sent), which is exactly the required posture
+ * on a `phi` route where the sidecar is a load requirement (§4); under `detect`
+ * it degrades to the deterministic tier with `degraded: true`. We compose over
+ * that engine — we do NOT fork it.
+ *
+ * LEAK INVARIANT (spec-sc2 §1.4, §8b): the sidecar's REQUEST body, its RESPONSE
+ * body, and the span offsets NEVER reach a receipt / log / telemetry / OTLP span
+ * / failure message. Only per-`type` COUNTS survive (the seam rolls spans into
+ * counts). The thrown error carries the detector id + a failure CLASS only —
+ * never the endpoint's response text or the scanned content.
+ */
+import type { Detector } from "../detect/detector";
+/** Config for {@link createSidecarDetector}. `id` is the customer's local truth
+ * (`sidecar:<image-or-config-digest>`); `endpoint` is the customer-run service;
+ * `types` optionally narrows which span types the adapter keeps. */
+export interface SidecarDetectorConfig {
+    /** Receipt id — normalized to `sidecar:<digest>` if a bare digest is given. */
+    readonly id: string;
+    /** The customer's own de-id endpoint. Content is POSTed here and nowhere else. */
+    readonly endpoint: string;
+    /** Per-call timeout; a slow/hung sidecar fails closed rather than blocking a
+     * run indefinitely. Default 2000 ms. */
+    readonly timeoutMs?: number;
+    /** Optional allowlist of span `type` labels to keep; others are dropped. */
+    readonly types?: readonly string[];
+    /** Injectable fetch for tests (defaults to global fetch). Never reads env. */
+    readonly fetchImpl?: typeof fetch;
+}
+/** Thrown on any sidecar failure (unreachable / timeout / non-2xx / malformed).
+ * Its message is a failure CLASS + the detector id ONLY — never the response
+ * body or the scanned content (leak invariant §1.4). The shipped screen seam
+ * catches it to apply the fail-closed matrix (§4.3). */
+export declare class SidecarUnavailableError extends Error {
+    readonly detectorId: string;
+    /** A coarse machine-readable reason — no content, no body. */
+    readonly reason: "unreachable" | "timeout" | "http_error" | "malformed_response";
+    constructor(detectorId: string, reason: SidecarUnavailableError["reason"]);
+}
+/** Normalize an id to the `sidecar:<digest>` receipt shape. A caller may pass
+ * either the full `sidecar:<digest>` or a bare digest. */
+export declare function sidecarReceiptId(id: string): string;
+/**
+ * Build the sidecar `Detector`. `detect(input)` POSTs `{text, source, tier}` to
+ * the customer endpoint and returns spans; any failure THROWS
+ * {@link SidecarUnavailableError} so the shipped seam applies the fail-closed
+ * matrix. Never logs the request/response body.
+ */
+export declare function createSidecarDetector(config: SidecarDetectorConfig): Detector;
+//# sourceMappingURL=sidecar.d.ts.map

package/dist/screen/sidecar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sidecar.d.ts","sourceRoot":"","sources":["../../src/screen/sidecar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAIV,QAAQ,EAET,MAAM,oBAAoB,CAAC;AAE5B;;oEAEoE;AACpE,MAAM,WAAW,qBAAqB;IACpC,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,kFAAkF;IAClF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;4CACwC;IACxC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CACnC;AAID;;;wDAGwD;AACxD,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,EAAE,aAAa,GAAG,SAAS,GAAG,YAAY,GAAG,oBAAoB,CAAC;gBACrE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,uBAAuB,CAAC,QAAQ,CAAC;CAM1E;AAED;0DAC0D;AAC1D,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAEnD;AAoCD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,QAAQ,CA+C7E"}

package/dist/screen/sidecar.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * SC-2 — the sidecar `Detector` adapter (spec-sc2 §3; shared with CS-1 D6).
+ *
+ * A `Detector` of the reserved `kind: "sidecar"` that adapts a CUSTOMER-RUN de-id
+ * container (GLiNER Guard / GLiNER2-PII / Presidio) over a deliberately tiny HTTP
+ * contract. ModelRig ships the ADAPTER and the CONTRACT only — never a model,
+ * never re-hosted weights (research §6a.3). The customer stands up their own
+ * service and owns its weights/license.
+ *
+ * THE CONTRACT (content-out only to the customer's own service):
+ *   POST <endpoint>  { text, source, tier }        → the segment to scan
+ *   200  { spans: [{ start, end, type, confidence }] }   → spans ONLY, never
+ *                                                          the matched text back
+ * The receipt id is `sidecar:<digest>` — the customer's local image/config
+ * digest label; ModelRig stores the label, not the model.
+ *
+ * FAIL-CLOSED (spec-sc2 §3, inherits SC-1 §4.3 via the shipped screen seam):
+ * on unreachable / timeout / malformed response the adapter THROWS a typed
+ * {@link SidecarUnavailableError}. The shipped seam (screen.ts) catches a
+ * detector throw and — under `enforce` — fails the run PRE-DISPATCH
+ * (invariant_violation, no request sent), which is exactly the required posture
+ * on a `phi` route where the sidecar is a load requirement (§4); under `detect`
+ * it degrades to the deterministic tier with `degraded: true`. We compose over
+ * that engine — we do NOT fork it.
+ *
+ * LEAK INVARIANT (spec-sc2 §1.4, §8b): the sidecar's REQUEST body, its RESPONSE
+ * body, and the span offsets NEVER reach a receipt / log / telemetry / OTLP span
+ * / failure message. Only per-`type` COUNTS survive (the seam rolls spans into
+ * counts). The thrown error carries the detector id + a failure CLASS only —
+ * never the endpoint's response text or the scanned content.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SidecarUnavailableError = void 0;
+exports.sidecarReceiptId = sidecarReceiptId;
+exports.createSidecarDetector = createSidecarDetector;
+const DEFAULT_TIMEOUT_MS = 2000;
+/** Thrown on any sidecar failure (unreachable / timeout / non-2xx / malformed).
+ * Its message is a failure CLASS + the detector id ONLY — never the response
+ * body or the scanned content (leak invariant §1.4). The shipped screen seam
+ * catches it to apply the fail-closed matrix (§4.3). */
+class SidecarUnavailableError extends Error {
+    constructor(detectorId, reason) {
+        super(`sidecar detector "${detectorId}" is unavailable (${reason})`);
+        this.name = "SidecarUnavailableError";
+        this.detectorId = detectorId;
+        this.reason = reason;
+    }
+}
+exports.SidecarUnavailableError = SidecarUnavailableError;
+/** Normalize an id to the `sidecar:<digest>` receipt shape. A caller may pass
+ * either the full `sidecar:<digest>` or a bare digest. */
+function sidecarReceiptId(id) {
+    return id.startsWith("sidecar:") ? id : `sidecar:${id}`;
+}
+function isRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** Read the response body into spans — DEFENSIVELY. Only `{start,end,type,
+ * confidence}` from each element is kept; every other field (and any echoed
+ * text) is discarded. A misshapen body is a malformed-response failure, never a
+ * silent open. */
+function parseSpans(body, allow) {
+    if (!isRecord(body) || !Array.isArray(body.spans))
+        return [];
+    const spans = [];
+    for (const raw of body.spans) {
+        if (!isRecord(raw))
+            continue;
+        const { start, end, type, confidence } = raw;
+        if (typeof start !== "number" ||
+            typeof end !== "number" ||
+            typeof type !== "string" ||
+            typeof confidence !== "number" ||
+            start < 0 ||
+            end < start ||
+            confidence < 0 ||
+            confidence > 1 ||
+            type.length > 64) {
+            continue; // drop a malformed span; never trust the sidecar's bytes (T7)
+        }
+        if (allow !== null && !allow.has(type))
+            continue;
+        // ONLY these four fields — never any echoed text the sidecar may have added.
+        spans.push({ start, end, type, confidence });
+    }
+    return spans;
+}
+/**
+ * Build the sidecar `Detector`. `detect(input)` POSTs `{text, source, tier}` to
+ * the customer endpoint and returns spans; any failure THROWS
+ * {@link SidecarUnavailableError} so the shipped seam applies the fail-closed
+ * matrix. Never logs the request/response body.
+ */
+function createSidecarDetector(config) {
+    const id = sidecarReceiptId(config.id);
+    const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const allow = config.types && config.types.length > 0 ? new Set(config.types) : null;
+    const doFetch = config.fetchImpl ?? fetch;
+    return {
+        id,
+        kind: "sidecar",
+        async detect(input) {
+            const payload = {
+                text: input.text,
+                source: input.source,
+                tier: input.tier,
+            };
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            let res;
+            try {
+                res = await doFetch(config.endpoint, {
+                    method: "POST",
+                    headers: { "content-type": "application/json" },
+                    body: JSON.stringify(payload),
+                    signal: controller.signal,
+                });
+            }
+            catch (err) {
+                // An abort is a timeout; anything else is a transport failure. NEVER let
+                // the caught error's message (which could echo the payload) escape —
+                // only the coarse reason travels.
+                const reason = err instanceof Error && err.name === "AbortError" ? "timeout" : "unreachable";
+                throw new SidecarUnavailableError(id, reason);
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (!res.ok)
+                throw new SidecarUnavailableError(id, "http_error");
+            let body;
+            try {
+                body = await res.json();
+            }
+            catch {
+                throw new SidecarUnavailableError(id, "malformed_response");
+            }
+            if (!isRecord(body) || !Array.isArray(body.spans)) {
+                throw new SidecarUnavailableError(id, "malformed_response");
+            }
+            return parseSpans(body, allow);
+        },
+    };
+}

package/dist/screen/types.d.ts

@@ -5,7 +5,7 @@
  * (packages/modelrig/src/detect/detector.ts) — mask (CS-1) and scrub v1 are the other
  * two. Load-bearing invariant: counts by type × source, never a matched value.
  */
-import type { ContentSource, DetectionType, TrustTier } from "../detect/detector";
+import type { ContentSource, Detector, DetectionType, TrustTier } from "../detect/detector";
 /** Per-source policy action when a detector's confidence ≥ threshold (spec §4).
  *  flag       — receipt only, dispatch unchanged
  *  strip      — remove the flagged segment, keep the rest, dispatch
@@ -14,6 +14,21 @@ import type { ContentSource, DetectionType, TrustTier } from "../detect/detector
  *               providers without parity, A7) and mark the step quarantined */
 export type ScreenAction = "flag" | "strip" | "block" | "quarantine";
 export type ScreenMode = "off" | "detect" | "enforce";
+/** SC-2 sidecar config (spec-sc2 §3). When present, the resolver builds a
+ * `sidecar:<digest>` detector that POSTs `{text,source,tier}` to the customer's
+ * own de-id endpoint and reads spans back — never a bundled model, never a
+ * re-hosted weight. The endpoint receives content; the receipt gets counts only.
+ * The `phi` posture gate (§4) reads the presence of this detector. */
+export interface ScreenSidecarConfig {
+    /** The customer's image/config digest — the receipt id is `sidecar:<digest>`. */
+    readonly digest: string;
+    /** The customer-run endpoint. Content is POSTed here and nowhere else. */
+    readonly endpoint: string;
+    /** Per-call timeout in ms (default 2000); a hung sidecar fails closed. */
+    readonly timeout_ms?: number;
+    /** Optional allowlist of span `type` labels the adapter keeps. */
+    readonly types?: readonly string[];
+}
 /** The `screen:` block of a route bundle (spec §4). Absent ⇒ screening off and
  * byte-identical behaviour. */
 export interface ScreenPolicy {
@@ -22,12 +37,16 @@ export interface ScreenPolicy {
      * decide slot placement (untrusted never occupies the system slot, spec §2). */
     readonly sources?: Partial<Record<ContentSource, TrustTier>>;
     /** Detector ids to run (registry keys). T0 patterns always; T1 classifier
-     * only when the optional peer dep + model file are present (A3). */
+     * only when the optional peer dep + model file are present (A3). SC-2 adds the
+     * deterministic Safe Harbor ids (`pii:<slug>@v1` / the `safe-harbor@v1` pack)
+     * and the `sidecar:<digest>` id (configured via {@link sidecar}). */
     readonly detectors?: readonly string[];
     /** Action per tier when risk ≥ threshold. */
     readonly on?: Partial<Record<TrustTier, ScreenAction>>;
     readonly threshold?: number;
     readonly output?: ScreenOutputPolicy;
+    /** SC-2 (spec-sc2 §3) — the customer-run de-id sidecar, when configured. */
+    readonly sidecar?: ScreenSidecarConfig;
 }
 /** Deterministic egress/output hygiene (spec §2.3 controls). */
 export interface ScreenOutputPolicy {
@@ -68,4 +87,26 @@ export interface ScreenReceipt {
      * degraded to T0 (spec §5 fail-closed matrix) — additive. */
     readonly degraded?: boolean;
 }
+/** The identity of a detector as it appears on a receipt — id + version, never
+ * a model file path or weights digest (those are the customer's local truth). */
+export interface DetectorIdentity {
+    readonly id: string;
+    readonly version: string;
+}
+/** A `screen:` policy resolved at ROUTE LOAD (mirrors {@link
+ * import("../mask/types").ResolvedMaskPolicy}): the parsed policy, the BUILT
+ * detector instances (T0 always, T1 iff its optional peer + model file were
+ * present), the identities for the receipt, a stable `policyHash`, and a
+ * `degraded` flag set when a CONFIGURED classifier could not be built at load
+ * (spec §4.3 — degrade to T0, never a silent block). Absent/`mode: off` ⇒ no
+ * resolved policy ⇒ byte-identical (the golden test). */
+export interface ResolvedScreenPolicy {
+    readonly policy: ScreenPolicy;
+    readonly detectors: readonly Detector[];
+    readonly detectorMeta: readonly DetectorIdentity[];
+    readonly policyHash: string;
+    /** A configured optional detector was unavailable at load; screening runs on
+     * T0 alone and every receipt carries `degraded: true` (spec §4.3). */
+    readonly degraded: boolean;
+}
 //# sourceMappingURL=types.d.ts.map

package/dist/screen/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/screen/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAElF;;;;;+EAK+E;AAC/E,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,YAAY,CAAC;AAErE,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEtD;+BAC+B;AAC/B,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B;oFACgF;IAChF,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC,CAAC;IAC7D;wEACoE;IACpE,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;IACvD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,kBAAkB,CAAC;CACtC;AAED,gEAAgE;AAChE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IACtC,QAAQ,CAAC,SAAS,CAAC,EAAE,WAAW,GAAG,KAAK,CAAC;CAC1C;AAED,kFAAkF;AAClF,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;gDACgD;AAChD,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE5D;;WAEW;AACX,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,SAAS;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACjF,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;IAC5C,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC;IACvC,gEAAgE;IAChE,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IACzC,gEAAgE;IAChE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;2CACuC;IACvC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC;iEAC6D;IAC7D,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/screen/types.ts"],"names":[],"mappings":"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"}

package/dist/settings/api-fetcher.d.ts

@@ -11,7 +11,7 @@
  * so the resolver stays fail-open (a settings read must never take a run down).
  */
 import type { RigConfig } from "../config";
-import { type TaskSettingsFetcher, type TaskSettingsResolver } from "./task-settings";
+import { type OrgPostureFetcher, type TaskSettingsFetcher, type TaskSettingsResolver } from "./task-settings";
 export interface ApiTaskSettingsFetcherConfig {
     /** Base URL of the hosted control plane, e.g. https://api.modelrig.ai — the
      * SAME `ingestUrl` the api sink uses (the settings path hangs off the host). */
@@ -25,10 +25,21 @@ export interface ApiTaskSettingsFetcherConfig {
 }
 /**
  * Build the api-mode fetcher. `fetch(task)` GETs `/v1/tasks/:task/settings` and
- * returns the parsed settings, or null on ANY non-200, network error, or
- * malformed body — the resolver reads null as "leave the cache as it is".
+ * returns the parsed result (settings + org id), or null on ANY non-200, network
+ * error, or malformed body — the resolver reads null as "leave the cache as it is".
  */
 export declare function createApiTaskSettingsFetcher(config: ApiTaskSettingsFetcherConfig): TaskSettingsFetcher;
+/**
+ * Build the api-mode ORG-posture fetcher (P15 CP-3). `fetch(orgId)` GETs
+ * `GET /v1/orgs/:org/settings` (any `rig_sk_` key of the caller's own org — no
+ * scope required) and returns the `artifact_posture`, or null on ANY non-200,
+ * network error, or malformed body. The org id comes from the task channel's
+ * echoed `org_id` — one control-plane channel, one credential (T8). Mirrors the
+ * task fetcher's leak discipline: Bearer key in a header, never the URL/body in
+ * an error, never a throw for a network/HTTP failure (the resolver reads null as
+ * "leave the last-known posture" — fail-open; the server ingest gate backstops).
+ */
+export declare function createApiOrgPostureFetcher(config: ApiTaskSettingsFetcherConfig): OrgPostureFetcher;
 /**
  * Construct AND start the api-mode settings resolver from a rig config, or null
  * when the rig is not in api mode (local-only/direct keep env/YAML). Folds the

package/dist/settings/api-fetcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-fetcher.d.ts","sourceRoot":"","sources":["../../src/settings/api-fetcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAa,MAAM,WAAW,CAAC;AACtD,OAAO,EAGL,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EAC1B,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,4BAA4B;IAC3C;oFACgF;IAChF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;2BAEuB;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,0DAA0D;IAC1D,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;CACjC;AAwBD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,4BAA4B,GACnC,mBAAmB,CAsBrB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,EACjB,iBAAiB,EAAE,MAAM,GACxB,oBAAoB,GAAG,IAAI,CAW7B"}
+{"version":3,"file":"api-fetcher.d.ts","sourceRoot":"","sources":["../../src/settings/api-fetcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAa,MAAM,WAAW,CAAC;AACtD,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,mBAAmB,EAExB,KAAK,oBAAoB,EAC1B,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,4BAA4B;IAC3C;oFACgF;IAChF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;2BAEuB;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,0DAA0D;IAC1D,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;CACjC;AAyCD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,4BAA4B,GACnC,mBAAmB,CAsBrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,4BAA4B,GACnC,iBAAiB,CAoBnB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,EACjB,iBAAiB,EAAE,MAAM,GACxB,oBAAoB,GAAG,IAAI,CAW7B"}