agent-nuvira 3.3.3 → 3.3.4

package/dist/runtime/fault-injection.d.ts

@@ -0,0 +1,173 @@
+/**
+ * WS6 (#28) — fault injection.
+ *
+ * WHY THIS IS TEST INFRASTRUCTURE AND NOT A MATRIX ROW. `src/parity/matrix.ts`
+ * says it in one line: fault injection is not a capability a surface can have, so
+ * it has no cells and no parity verdict of its own. What it DOES have is a job —
+ * make a dependency fail ON PURPOSE, deterministically, on every surface, so the
+ * honest answer to a failure can be measured instead of assumed. The whole
+ * truthfulness workstream exists because a failure reported as success is the one
+ * defect an agent cannot recover from, and nothing measures that shape as well as
+ * a fault that is declared in advance and cannot be confused with a real outage.
+ *
+ * TWO HALVES, and keeping them apart is the design:
+ *
+ *   1. THE WIRE (no production code involved). A parity scenario declares
+ *      `fault: { site: 'provider', kind: 'error', times: Infinity }` and the
+ *      harness's own loopback stub answers 500 / malformed JSON / 503. The REAL
+ *      adapter's error mapping runs, the model call still happens (so the
+ *      harness's "the turn must have reached a model" rule holds), and every
+ *      surface must report the same failure. This is where a provider fault is
+ *      proven, because the adapter — not this module — is what a user's real
+ *      outage exercises.
+ *
+ *   2. THE SEAM (this module). `NUVIRA_INJECT_FAULT=provider:error:2` or
+ *      `tool:error:list_dir` makes the running agent fail one of its own
+ *      dependencies, in-process, for a live run, a demo, or a test that wants a
+ *      fault without a stub server. OFF BY DEFAULT AND FREE WHEN OFF: with the
+ *      variable unset, `activeFaultInjector()` returns null and nothing is
+ *      wrapped — `ProviderFactory.createProvider` hands back the very same object
+ *      it always did, so no run that did not ask for a fault is affected.
+ *
+ * THE ONE RULE THAT MAKES IT USEFUL: an injected fault must never look like a
+ * real one. Every message this module produces says, in the text the model and
+ * the operator both read, that the failure was declared and where the declaration
+ * came from. A fault that could be mistaken for a genuine outage would corrupt
+ * exactly the evidence it was injected to gather.
+ *
+ * A TYPO IS NOT A SILENT NO-OP. A declaration that cannot be parsed THROWS. The
+ * alternative — ignoring it and running the turn unfaulted — would let a demo or
+ * a test "prove" failure handling while nothing ever failed, which is the same
+ * class of lie this repo has spent a workstream removing.
+ */
+import type { InferenceProvider } from '../inference/interface.js';
+/** The environment variable that declares a fault. Unset (the default) = no fault. */
+export declare const FAULT_ENV = "NUVIRA_INJECT_FAULT";
+/**
+ * Where a fault is injected.
+ *
+ *  - `provider` — the model call itself (a request that fails, or a response that
+ *                 cannot be parsed).
+ *  - `tool`     — one tool call (`match` names it; absent = the next call).
+ *  - `ipc`      — the child process boundary (the child exits before it works).
+ */
+export type FaultSite = 'provider' | 'tool' | 'ipc';
+/**
+ * What kind of failure to inject.
+ *
+ *  - `error`       — the call fails outright (HTTP 500 / a thrown provider error).
+ *  - `malformed`   — the call "succeeds" with a body nothing can parse.
+ *  - `unavailable` — the backend reports itself temporarily unavailable (503).
+ */
+export type FaultKind = 'error' | 'malformed' | 'unavailable';
+/** A declared fault: what to break, and how many times. */
+export interface FaultPlan {
+    site: FaultSite;
+    kind: FaultKind;
+    /**
+     * How many matching calls to fail. `1` is the default a bare declaration means,
+     * `Infinity` fails every matching call (what a parity row wants: a turn that
+     * recovers from a transient fault and one that reports it are both honest, and a
+     * row that cannot tell which happened measures neither).
+     */
+    times: number;
+    /** The tool name to match (`site: 'tool'`). Absent = every tool call. */
+    match?: string;
+}
+/** One fault that actually fired. */
+export interface FaultFiring {
+    site: FaultSite;
+    kind: FaultKind;
+    /** What was about to run: a provider method, a tool name, or `child`. */
+    subject: string;
+    /** The text every consumer reads. Names the declaration, so it cannot be mistaken for a real outage. */
+    message: string;
+}
+/**
+ * Render a plan back to the declaration form the environment carries.
+ *
+ * The round trip matters: the harness declares a scenario's fault by writing this
+ * string into the environment, and a failure report shows the same string, so an
+ * operator can copy it straight into a shell.
+ */
+export declare function formatFaultPlan(plan: FaultPlan): string;
+/**
+ * Parse `site:kind[:times|all[:match]]`.
+ *
+ * Accepts `off`/`none`/`0` as "no fault" (an easy way for a script to switch one
+ * off without unsetting the variable). Anything else that does not parse THROWS —
+ * see the header: a declaration that silently injects nothing is worse than no
+ * declaration at all.
+ */
+export declare function parseFaultPlan(raw: string | undefined | null): FaultPlan | null;
+/** The declared fault for this process, or null. Throws on a malformed declaration. */
+export declare function faultPlanFromEnv(env?: Record<string, string | undefined>): FaultPlan | null;
+/**
+ * The message a fired fault carries into the tool result / provider error.
+ *
+ * Names the declaration and the subject, and says PLAINLY that it was injected —
+ * every consumer of this text (the model included) must be able to tell a
+ * declared fault from a real failure.
+ */
+export declare function faultMessage(plan: FaultPlan, subject: string): string;
+/**
+ * A counting injector for one declaration.
+ *
+ * `at()` is the whole API: it answers "should this call fail?", and returns null
+ * once the declaration's allowance is spent. Counting (rather than a boolean) is
+ * what makes `times` mean anything — and it is also the evidence a caller needs:
+ * a declared fault that never fired is a fault that measured nothing.
+ */
+export declare class FaultInjector {
+    readonly plan: FaultPlan;
+    private remaining;
+    private readonly firings;
+    constructor(plan: FaultPlan);
+    /** How many times this injector has fired so far. */
+    get fired(): number;
+    /** What fired, in order — for a report or an assertion. */
+    get history(): readonly FaultFiring[];
+    /** True when the declaration's allowance is spent. */
+    get exhausted(): boolean;
+    /**
+     * Ask whether the call about to run should fail instead.
+     *
+     * Consumes one firing when it answers yes. A site that does not match — or a
+     * tool name that does not match — is never consumed, so `tool:error:read_file`
+     * does not spend its allowance on the writes around it.
+     */
+    at(site: FaultSite, subject: string): FaultFiring | null;
+}
+/** Build an injector for a plan. Off (null) when there is no plan. */
+export declare function createFaultInjector(plan: FaultPlan | null | undefined): FaultInjector | null;
+/**
+ * The injector for the CURRENT declaration, rebuilt when the declaration changes.
+ *
+ * Cached so one declaration's `times` is spent across the whole turn rather than
+ * reset per call, and keyed on the raw string so a caller that re-declares a fault
+ * (the parity harness does, once per surface) gets a fresh allowance without
+ * having to know this cache exists.
+ */
+export declare function activeFaultInjector(env?: Record<string, string | undefined>): FaultInjector | null;
+/** Forget the cached injector — call after changing the declaration (tests, the harness). */
+export declare function resetFaultInjector(): void;
+/** Should the call about to run fail? The one-liner the seams call. */
+export declare function faultAt(site: FaultSite, subject: string): FaultFiring | null;
+/**
+ * Wrap a provider so declared `provider` faults fail its model calls.
+ *
+ * TWO PROPERTIES, and both are load-bearing:
+ *
+ *   - ONLY WHEN A DECLARATION EXISTS. With no `NUVIRA_INJECT_FAULT`, the provider
+ *     is returned UNCHANGED — same object, not a transparent copy — so a run that
+ *     asked for nothing cannot be affected by this module.
+ *   - ONLY THE METHODS THAT EXIST. `generateTools` is optional (`InferenceProvider`)
+ *     and its PRESENCE is how the loop picks the native transport over the JSON
+ *     fallback (`child-agent-runtime.ts:181`). Adding it to a provider that lacks
+ *     it would silently change the transport a run was measured on, so an absent
+ *     method stays absent.
+ */
+export declare function withFaultInjection(provider: InferenceProvider, injector?: FaultInjector | null): InferenceProvider;
+/** What the seam can inject, for the CLI's `parity faults` listing. */
+export declare function describeFaultProtocol(): string[];
+//# sourceMappingURL=fault-injection.d.ts.map

package/dist/runtime/fault-injection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fault-injection.d.ts","sourceRoot":"","sources":["../../src/runtime/fault-injection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,sFAAsF;AACtF,eAAO,MAAM,SAAS,wBAAwB,CAAC;AAE/C;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,KAAK,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,WAAW,GAAG,aAAa,CAAC;AAE9D,2DAA2D;AAC3D,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,SAAS,CAAC;IAChB;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qCAAqC;AACrC,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,SAAS,CAAC;IAChB,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,wGAAwG;IACxG,OAAO,EAAE,MAAM,CAAC;CACjB;AAaD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAOvD;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAsD/E;AAED,uFAAuF;AACvF,wBAAgB,gBAAgB,CAAC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GAAG,SAAS,GAAG,IAAI,CAExG;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAWrE;AAED;;;;;;;GAOG;AACH,qBAAa,aAAa;IAIZ,QAAQ,CAAC,IAAI,EAAE,SAAS;IAHpC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;gBAExB,IAAI,EAAE,SAAS;IAIpC,qDAAqD;IACrD,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,2DAA2D;IAC3D,IAAI,OAAO,IAAI,SAAS,WAAW,EAAE,CAEpC;IAED,sDAAsD;IACtD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;;;;;OAMG;IACH,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;CAczD;AAED,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,aAAa,GAAG,IAAI,CAE5F;AAID;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GAAG,aAAa,GAAG,IAAI,CAK/G;AAED,6FAA6F;AAC7F,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED,uEAAuE;AACvE,wBAAgB,OAAO,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAE5E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,iBAAiB,EAC3B,QAAQ,GAAE,aAAa,GAAG,IAA4B,GACrD,iBAAiB,CAkBnB;AAED,uEAAuE;AACvE,wBAAgB,qBAAqB,IAAI,MAAM,EAAE,CAgBhD"}

package/dist/runtime/fault-injection.js

@@ -0,0 +1,281 @@
+/**
+ * WS6 (#28) — fault injection.
+ *
+ * WHY THIS IS TEST INFRASTRUCTURE AND NOT A MATRIX ROW. `src/parity/matrix.ts`
+ * says it in one line: fault injection is not a capability a surface can have, so
+ * it has no cells and no parity verdict of its own. What it DOES have is a job —
+ * make a dependency fail ON PURPOSE, deterministically, on every surface, so the
+ * honest answer to a failure can be measured instead of assumed. The whole
+ * truthfulness workstream exists because a failure reported as success is the one
+ * defect an agent cannot recover from, and nothing measures that shape as well as
+ * a fault that is declared in advance and cannot be confused with a real outage.
+ *
+ * TWO HALVES, and keeping them apart is the design:
+ *
+ *   1. THE WIRE (no production code involved). A parity scenario declares
+ *      `fault: { site: 'provider', kind: 'error', times: Infinity }` and the
+ *      harness's own loopback stub answers 500 / malformed JSON / 503. The REAL
+ *      adapter's error mapping runs, the model call still happens (so the
+ *      harness's "the turn must have reached a model" rule holds), and every
+ *      surface must report the same failure. This is where a provider fault is
+ *      proven, because the adapter — not this module — is what a user's real
+ *      outage exercises.
+ *
+ *   2. THE SEAM (this module). `NUVIRA_INJECT_FAULT=provider:error:2` or
+ *      `tool:error:list_dir` makes the running agent fail one of its own
+ *      dependencies, in-process, for a live run, a demo, or a test that wants a
+ *      fault without a stub server. OFF BY DEFAULT AND FREE WHEN OFF: with the
+ *      variable unset, `activeFaultInjector()` returns null and nothing is
+ *      wrapped — `ProviderFactory.createProvider` hands back the very same object
+ *      it always did, so no run that did not ask for a fault is affected.
+ *
+ * THE ONE RULE THAT MAKES IT USEFUL: an injected fault must never look like a
+ * real one. Every message this module produces says, in the text the model and
+ * the operator both read, that the failure was declared and where the declaration
+ * came from. A fault that could be mistaken for a genuine outage would corrupt
+ * exactly the evidence it was injected to gather.
+ *
+ * A TYPO IS NOT A SILENT NO-OP. A declaration that cannot be parsed THROWS. The
+ * alternative — ignoring it and running the turn unfaulted — would let a demo or
+ * a test "prove" failure handling while nothing ever failed, which is the same
+ * class of lie this repo has spent a workstream removing.
+ */
+/** The environment variable that declares a fault. Unset (the default) = no fault. */
+export const FAULT_ENV = 'NUVIRA_INJECT_FAULT';
+const SITES = ['provider', 'tool', 'ipc'];
+const KINDS = ['error', 'malformed', 'unavailable'];
+function isSite(value) {
+    return SITES.includes(value);
+}
+function isKind(value) {
+    return KINDS.includes(value);
+}
+/**
+ * Render a plan back to the declaration form the environment carries.
+ *
+ * The round trip matters: the harness declares a scenario's fault by writing this
+ * string into the environment, and a failure report shows the same string, so an
+ * operator can copy it straight into a shell.
+ */
+export function formatFaultPlan(plan) {
+    const parts = [plan.site, plan.kind];
+    const finite = Number.isFinite(plan.times) ? plan.times : Number.POSITIVE_INFINITY;
+    // Only spelled out when it is not the bare default, so `tool:error` stays short.
+    if (finite !== 1 || plan.match)
+        parts.push(finite === Number.POSITIVE_INFINITY ? 'all' : String(finite));
+    if (plan.match)
+        parts.push(plan.match);
+    return parts.join(':');
+}
+/**
+ * Parse `site:kind[:times|all[:match]]`.
+ *
+ * Accepts `off`/`none`/`0` as "no fault" (an easy way for a script to switch one
+ * off without unsetting the variable). Anything else that does not parse THROWS —
+ * see the header: a declaration that silently injects nothing is worse than no
+ * declaration at all.
+ */
+export function parseFaultPlan(raw) {
+    const text = (raw ?? '').trim();
+    if (!text)
+        return null;
+    const lowered = text.toLowerCase();
+    if (lowered === 'off' || lowered === 'none' || lowered === '0')
+        return null;
+    const parts = text.split(':').map((part) => part.trim());
+    const [siteRaw, kindRaw, third, fourth] = parts;
+    if (!siteRaw || !kindRaw || !isSite(siteRaw) || !isKind(kindRaw)) {
+        throw new Error(`Invalid ${FAULT_ENV} declaration ${JSON.stringify(text)}: expected ` +
+            `<site>:<kind>[:<times|all>[:<match>]] where site is one of ${SITES.join(', ')} ` +
+            `and kind is one of ${KINDS.join(', ')}. Use \`off\` to disable.`);
+    }
+    let times = 1;
+    let match;
+    if (third !== undefined && third !== '') {
+        // ORDER MATTERS, and it was measured: `all` has to be recognised as a COUNT
+        // before the "not a number, so it must be a tool name" rule runs, because
+        // `Number('all')` is NaN — the first version of this parser read
+        // `tool:error:all:read_file` as "one call, matching the tool named `all`".
+        const parsed = Number(third);
+        if (third.toLowerCase() === 'all' || third === '*') {
+            times = Number.POSITIVE_INFINITY;
+        }
+        else if (!Number.isNaN(parsed)) {
+            if (!Number.isFinite(parsed) || parsed < 1 || !Number.isInteger(parsed)) {
+                throw new Error(`Invalid ${FAULT_ENV} declaration ${JSON.stringify(text)}: times must be a positive ` +
+                    `integer or \`all\` (got ${JSON.stringify(third)}).`);
+            }
+            times = parsed;
+        }
+        else if (siteRaw === 'tool') {
+            match = third;
+        }
+        else {
+            throw new Error(`Invalid ${FAULT_ENV} declaration ${JSON.stringify(text)}: times must be a positive ` +
+                `integer or \`all\` (got ${JSON.stringify(third)}).`);
+        }
+    }
+    if (fourth !== undefined && fourth !== '') {
+        if (siteRaw !== 'tool') {
+            throw new Error(`Invalid ${FAULT_ENV} declaration ${JSON.stringify(text)}: only \`tool\` faults take a ` +
+                `tool name to match (got ${JSON.stringify(fourth)} on a \`${siteRaw}\` fault).`);
+        }
+        match = fourth;
+    }
+    return match ? { site: siteRaw, kind: kindRaw, times, match } : { site: siteRaw, kind: kindRaw, times };
+}
+/** The declared fault for this process, or null. Throws on a malformed declaration. */
+export function faultPlanFromEnv(env = process.env) {
+    return parseFaultPlan(env[FAULT_ENV]);
+}
+/**
+ * The message a fired fault carries into the tool result / provider error.
+ *
+ * Names the declaration and the subject, and says PLAINLY that it was injected —
+ * every consumer of this text (the model included) must be able to tell a
+ * declared fault from a real failure.
+ */
+export function faultMessage(plan, subject) {
+    const what = plan.kind === 'malformed'
+        ? `returned a response nothing could parse`
+        : plan.kind === 'unavailable'
+            ? `reported itself unavailable`
+            : `failed`;
+    return (`injected ${plan.site} fault: ${subject} was made to ${what} ON PURPOSE ` +
+        `(${FAULT_ENV}=${formatFaultPlan(plan)}). This is a declared fault, not a real ${plan.site} failure.`);
+}
+/**
+ * A counting injector for one declaration.
+ *
+ * `at()` is the whole API: it answers "should this call fail?", and returns null
+ * once the declaration's allowance is spent. Counting (rather than a boolean) is
+ * what makes `times` mean anything — and it is also the evidence a caller needs:
+ * a declared fault that never fired is a fault that measured nothing.
+ */
+export class FaultInjector {
+    plan;
+    remaining;
+    firings = [];
+    constructor(plan) {
+        this.plan = plan;
+        this.remaining = plan.times;
+    }
+    /** How many times this injector has fired so far. */
+    get fired() {
+        return this.firings.length;
+    }
+    /** What fired, in order — for a report or an assertion. */
+    get history() {
+        return [...this.firings];
+    }
+    /** True when the declaration's allowance is spent. */
+    get exhausted() {
+        return this.remaining <= 0;
+    }
+    /**
+     * Ask whether the call about to run should fail instead.
+     *
+     * Consumes one firing when it answers yes. A site that does not match — or a
+     * tool name that does not match — is never consumed, so `tool:error:read_file`
+     * does not spend its allowance on the writes around it.
+     */
+    at(site, subject) {
+        if (site !== this.plan.site)
+            return null;
+        if (this.plan.match !== undefined && this.plan.match !== subject)
+            return null;
+        if (this.remaining <= 0)
+            return null;
+        this.remaining -= 1;
+        const firing = {
+            site,
+            kind: this.plan.kind,
+            subject,
+            message: faultMessage(this.plan, subject),
+        };
+        this.firings.push(firing);
+        return firing;
+    }
+}
+/** Build an injector for a plan. Off (null) when there is no plan. */
+export function createFaultInjector(plan) {
+    return plan ? new FaultInjector(plan) : null;
+}
+let cached = null;
+/**
+ * The injector for the CURRENT declaration, rebuilt when the declaration changes.
+ *
+ * Cached so one declaration's `times` is spent across the whole turn rather than
+ * reset per call, and keyed on the raw string so a caller that re-declares a fault
+ * (the parity harness does, once per surface) gets a fresh allowance without
+ * having to know this cache exists.
+ */
+export function activeFaultInjector(env = process.env) {
+    const raw = env[FAULT_ENV];
+    if (cached && cached.raw === raw)
+        return cached.injector;
+    cached = { raw, injector: createFaultInjector(faultPlanFromEnv(env)) };
+    return cached.injector;
+}
+/** Forget the cached injector — call after changing the declaration (tests, the harness). */
+export function resetFaultInjector() {
+    cached = null;
+}
+/** Should the call about to run fail? The one-liner the seams call. */
+export function faultAt(site, subject) {
+    return activeFaultInjector()?.at(site, subject) ?? null;
+}
+/**
+ * Wrap a provider so declared `provider` faults fail its model calls.
+ *
+ * TWO PROPERTIES, and both are load-bearing:
+ *
+ *   - ONLY WHEN A DECLARATION EXISTS. With no `NUVIRA_INJECT_FAULT`, the provider
+ *     is returned UNCHANGED — same object, not a transparent copy — so a run that
+ *     asked for nothing cannot be affected by this module.
+ *   - ONLY THE METHODS THAT EXIST. `generateTools` is optional (`InferenceProvider`)
+ *     and its PRESENCE is how the loop picks the native transport over the JSON
+ *     fallback (`child-agent-runtime.ts:181`). Adding it to a provider that lacks
+ *     it would silently change the transport a run was measured on, so an absent
+ *     method stays absent.
+ */
+export function withFaultInjection(provider, injector = activeFaultInjector()) {
+    if (!injector || injector.plan.site !== 'provider')
+        return provider;
+    const modelMethods = ['generate', 'generateTools', 'generateToolsStream'];
+    return new Proxy(provider, {
+        get(target, prop, receiver) {
+            if (typeof prop === 'string' && modelMethods.includes(prop)) {
+                const original = Reflect.get(target, prop, target);
+                if (typeof original !== 'function')
+                    return original;
+                return async (...args) => {
+                    const firing = injector.at('provider', prop);
+                    if (firing)
+                        throw new Error(firing.message);
+                    return original.apply(target, args);
+                };
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}
+/** What the seam can inject, for the CLI's `parity faults` listing. */
+export function describeFaultProtocol() {
+    return [
+        `Declaration: ${FAULT_ENV}=<site>:<kind>[:<times|all>[:<tool name>]]`,
+        `  sites: ${SITES.join(', ')}   kinds: ${KINDS.join(', ')}   times: 1 (default), N, or all`,
+        '',
+        '  provider:error           the next model call fails (HTTP 500 / a thrown provider error)',
+        '  provider:malformed:all   every model call returns a body nothing can parse',
+        '  provider:unavailable     the backend reports itself temporarily unavailable (503)',
+        '  tool:error:list_dir      the next list_dir call fails, and reports why',
+        '  tool:error:2             the next two tool calls fail',
+        '  ipc:error                the forked child exits before it does any work',
+        '  off                      no fault (the default when the variable is unset)',
+        '',
+        'A declaration that cannot be parsed THROWS rather than running unfaulted, and every',
+        'message names the declaration, so an injected fault can never be mistaken for a real one.',
+    ];
+}
+//# sourceMappingURL=fault-injection.js.map

package/dist/runtime/fault-injection.js.map

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

package/dist/tools/child-agent-entry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Child-agent entry point (`src/tools/child-agent-entry.ts`) — the file the
+ * spawner forks.
+ *
+ * It exists as TypeScript for two reasons that were both live defects:
+ *
+ *   1. **It is shipped.** `tsc` emits `dist/tools/child-agent-entry.js`, so the
+ *      compiled layout forks a file that exists. The previous entry was a
+ *      hand-written `child-agent-entry.js` under `src/`, which nothing copied to
+ *      `dist/` (`allowJs` is false) — a compiled install forked a path that was
+ *      never there, and `spawn()` threw ENOENT.
+ *   2. **It runs in this package's module system.** `package.json` is
+ *      `"type": "module"`, so that same `.js` file was parsed as ESM while being
+ *      written in CommonJS (`require`, `__dirname`, a `parentPort` import from a
+ *      worker-thread API that a `fork()`ed process does not have). It died on
+ *      `require is not defined` before it read a single environment variable.
+ *
+ * The child reports over the IPC channel `fork()` establishes: `progress` while
+ * it works, then exactly one `result` or `error`. The parent treats "exited
+ * without a result" as a failure, so this file must never exit 0 silently.
+ */
+export {};
+//# sourceMappingURL=child-agent-entry.d.ts.map

package/dist/tools/child-agent-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-agent-entry.d.ts","sourceRoot":"","sources":["../../src/tools/child-agent-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG"}

package/dist/tools/child-agent-entry.js

@@ -0,0 +1,129 @@
+/**
+ * Child-agent entry point (`src/tools/child-agent-entry.ts`) — the file the
+ * spawner forks.
+ *
+ * It exists as TypeScript for two reasons that were both live defects:
+ *
+ *   1. **It is shipped.** `tsc` emits `dist/tools/child-agent-entry.js`, so the
+ *      compiled layout forks a file that exists. The previous entry was a
+ *      hand-written `child-agent-entry.js` under `src/`, which nothing copied to
+ *      `dist/` (`allowJs` is false) — a compiled install forked a path that was
+ *      never there, and `spawn()` threw ENOENT.
+ *   2. **It runs in this package's module system.** `package.json` is
+ *      `"type": "module"`, so that same `.js` file was parsed as ESM while being
+ *      written in CommonJS (`require`, `__dirname`, a `parentPort` import from a
+ *      worker-thread API that a `fork()`ed process does not have). It died on
+ *      `require is not defined` before it read a single environment variable.
+ *
+ * The child reports over the IPC channel `fork()` establishes: `progress` while
+ * it works, then exactly one `result` or `error`. The parent treats "exited
+ * without a result" as a failure, so this file must never exit 0 silently.
+ */
+import { runSubagent } from './child-agent-runtime.js';
+import { SubagentRefusalError } from './subagent-refusal.js';
+// WS6 (#28) — the declared fault seam, read in the CHILD's own process (the
+// declaration reaches it through the environment it inherited).
+import { faultAt } from '../runtime/fault-injection.js';
+function num(raw, fallback) {
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+/** Env vars the spawner sets; anything malformed falls back rather than throwing. */
+function readConfig() {
+    const parseList = (raw) => {
+        try {
+            const parsed = JSON.parse(raw ?? '[]');
+            return Array.isArray(parsed) ? parsed.filter((t) => typeof t === 'string') : [];
+        }
+        catch {
+            return [];
+        }
+    };
+    return {
+        goal: process.env.SUBAGENT_GOAL ?? '',
+        provider: process.env.SUBAGENT_PROVIDER || 'auto',
+        model: process.env.SUBAGENT_MODEL || undefined,
+        tools: parseList(process.env.SUBAGENT_TOOLS),
+        blockedTools: parseList(process.env.SUBAGENT_BLOCKED_TOOLS),
+        maxLlmCalls: num(process.env.SUBAGENT_MAX_LLM_CALLS, 25),
+        maxIterations: num(process.env.SUBAGENT_MAX_ITERATIONS, 12),
+        cwd: process.cwd(),
+    };
+}
+/**
+ * The run's identity, as the runtime announced it: which provider, which model it
+ * pinned, and which transport carries tool calls.
+ *
+ * Remembered on the way OUT so the failure frame can carry it too. A child that
+ * died before producing a result used to reach the parent as a bare message, so a
+ * failed subagent could not be attributed to a backend — the one moment you most
+ * want to know which provider/model was serving the run.
+ */
+const identity = {};
+function send(msg) {
+    if (typeof msg.provider === 'string')
+        identity.provider = msg.provider;
+    if (typeof msg.model === 'string')
+        identity.model = msg.model;
+    if (typeof msg.transport === 'string')
+        identity.transport = msg.transport;
+    try {
+        process.send?.(msg);
+    }
+    catch {
+        // A closed IPC channel must not turn a finished task into a crash.
+    }
+}
+async function main() {
+    // WS6 (#28) — a DECLARED ipc fault: this process dies before it does any work,
+    // and deliberately WITHOUT a frame, because a crash is the failure the parent
+    // cannot observe from inside its own process. The assertion it exists for is
+    // that the parent reports the run as failed rather than hanging on a child that
+    // will never speak, or inventing a result for it.
+    if (faultAt('ipc', 'child'))
+        process.exit(3);
+    const config = readConfig();
+    if (!config.goal) {
+        send({ type: 'error', error: 'SUBAGENT_GOAL is empty — nothing to do.' });
+        process.exit(1);
+        return;
+    }
+    try {
+        const outcome = await runSubagent(config, { send });
+        send({
+            type: 'result',
+            result: outcome.result,
+            llmCalls: outcome.llmCalls,
+            toolCalls: outcome.toolCalls,
+            provider: outcome.provider,
+            // Which model and which tool transport actually served the run — recorded
+            // so a finished subagent can be inspected after the fact rather than guessed
+            // at from its output.
+            ...(outcome.model ? { model: outcome.model } : {}),
+            transport: outcome.transport,
+            truncated: outcome.truncated,
+            // G1 — the child's OWN verification verdict, on the frame like every other
+            // fact the parent can only learn across the fork. Without it a delegated run
+            // that wrote and verified nothing looked exactly like one that checked its
+            // work: the honesty flags live in this process and nowhere else.
+            ...(outcome.unverifiedEdit ? { unverifiedEdit: true } : {}),
+            ...(outcome.unverifiedEditClaim ? { unverifiedEditClaim: true } : {}),
+        });
+        process.exit(0);
+    }
+    catch (err) {
+        // The refusal's code crosses the boundary with the message: the parent logs
+        // WHY, instead of inferring it from an exit code. The identity rides along so
+        // the parent can record which provider/model/transport failed.
+        const code = err instanceof SubagentRefusalError ? err.code : 'unavailable';
+        send({
+            type: 'error',
+            code,
+            error: err instanceof Error ? err.message : String(err),
+            ...identity,
+        });
+        process.exit(1);
+    }
+}
+void main();
+//# sourceMappingURL=child-agent-entry.js.map

package/dist/tools/child-agent-entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-agent-entry.js","sourceRoot":"","sources":["../../src/tools/child-agent-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,WAAW,EAA8B,MAAM,0BAA0B,CAAC;AACnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,4EAA4E;AAC5E,gEAAgE;AAChE,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAExD,SAAS,GAAG,CAAC,GAAuB,EAAE,QAAgB;IACpD,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IACtB,OAAO,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;AACpD,CAAC;AAED,qFAAqF;AACrF,SAAS,UAAU;IACjB,MAAM,SAAS,GAAG,CAAC,GAAuB,EAAY,EAAE;QACtD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC;YACvC,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/F,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC,CAAC;IACF,OAAO;QACL,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,EAAE;QACrC,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,iBAAiB,IAAI,MAAM;QACjD,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,SAAS;QAC9C,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;QAC5C,YAAY,EAAE,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC;QAC3D,WAAW,EAAE,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,sBAAsB,EAAE,EAAE,CAAC;QACxD,aAAa,EAAE,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,uBAAuB,EAAE,EAAE,CAAC;QAC3D,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE;KACnB,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,QAAQ,GAA8D,EAAE,CAAC;AAE/E,SAAS,IAAI,CAAC,GAA4B;IACxC,IAAI,OAAO,GAAG,CAAC,QAAQ,KAAK,QAAQ;QAAE,QAAQ,CAAC,QAAQ,GAAG,GAAG,CAAC,QAAQ,CAAC;IACvE,IAAI,OAAO,GAAG,CAAC,KAAK,KAAK,QAAQ;QAAE,QAAQ,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;IAC9D,IAAI,OAAO,GAAG,CAAC,SAAS,KAAK,QAAQ;QAAE,QAAQ,CAAC,SAAS,GAAG,GAAG,CAAC,SAAS,CAAC;IAC1E,IAAI,CAAC;QACH,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC;IACtB,CAAC;IAAC,MAAM,CAAC;QACP,mEAAmE;IACrE,CAAC;AACH,CAAC;AAED,KAAK,UAAU,IAAI;IACjB,+EAA+E;IAC/E,8EAA8E;IAC9E,6EAA6E;IAC7E,gFAAgF;IAChF,kDAAkD;IAClD,IAAI,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC;QAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAE7C,MAAM,MAAM,GAAG,UAAU,EAAE,CAAC;IAC5B,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACjB,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,yCAAyC,EAAE,CAAC,CAAC;QAC1E,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAChB,OAAO;IACT,CAAC;IAED,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,MAAM,WAAW,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;QACpD,IAAI,CAAC;YACH,IAAI,EAAE,QAAQ;YACd,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,0EAA0E;YAC1E,6EAA6E;YAC7E,sBAAsB;YACtB,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAClD,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,2EAA2E;YAC3E,6EAA6E;YAC7E,2EAA2E;YAC3E,iEAAiE;YACjE,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3D,GAAG,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,mBAAmB,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACtE,CAAC,CAAC;QACH,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,4EAA4E;QAC5E,8EAA8E;QAC9E,+DAA+D;QAC/D,MAAM,IAAI,GAAG,GAAG,YAAY,oBAAoB,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC;QAC5E,IAAI,CAAC;YACH,IAAI,EAAE,OAAO;YACb,IAAI;YACJ,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;YACvD,GAAG,QAAQ;SACZ,CAAC,CAAC;QACH,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;AACH,CAAC;AAED,KAAK,IAAI,EAAE,CAAC"}