agent-threat-rules 3.5.11 → 4.0.0

package/dist/corpus-event.d.ts

@@ -0,0 +1,368 @@
+/**
+ * corpus-event.ts — the ONE way a text sample becomes engine events.
+ *
+ * WHY THIS FILE EXISTS
+ *
+ * An ATR rule condition names a field (`field: tool_args`). The engine resolves
+ * that name against the event it is given (src/engine.ts resolveField). If the
+ * harness that measures false positives builds an event that cannot resolve the
+ * field, every condition on that field silently evaluates to false: the rule
+ * cannot fire, cannot be counted as an FP, and the gate reports it CLEAN. That
+ * is a zero-measurement PASS — indistinguishable, in the output, from a rule
+ * that was measured and found innocent.
+ *
+ * That is exactly what happened. Five harnesses each carried a private copy of
+ *
+ *     { type: "mcp_exchange",
+ *       fields: { tool_name, tool_input, tool_response, user_input } }
+ *
+ * which resolves NONE of tool_args / agent_output / agent_message /
+ * tool_description. 40 rules declare `field: tool_args` (3 of them
+ * maturity: stable, i.e. the enforce/auto-block lane) and their tool_args
+ * conditions had never been measured against a single benign sample.
+ *
+ * THE RULE THIS FILE ENFORCES
+ *
+ * True positives and benign samples MUST be pushed through the IDENTICAL shape
+ * set. Measuring TP on a wide shape and FP on a narrow one manufactures a 0-FP
+ * result: the rule earns its detection credit on a shape that is never charged
+ * for its false positives. Whatever shape a rule is allowed to fire on is the
+ * shape it must also survive the benign corpus on. Import this module from both
+ * sides of any measurement rather than hand-rolling an event.
+ *
+ * ENCODING FIDELITY
+ *
+ * Production does not hand the engine one flat string. src/hook-handler.ts
+ * builds `tool_args: JSON.stringify(toolInput)` — a JSON-ENCODED string, where a
+ * newline is the two characters `\` `n`, not U+000A. A pattern can match one
+ * encoding and not the other (a real FP was found this way: a JSON-escaped `\n`
+ * read as a shell line-continuation and joined two independent commands). So the
+ * sample is presented in both the raw and the JSON-encoded form, and each field
+ * receives the encoding production would actually put there — no more, no less.
+ *
+ * @module scripts/lib/corpus-event
+ */
+import type { AgentEvent } from "./types.js";
+/**
+ * Placeholder tool name — deliberately NOT the sample text.
+ *
+ * The corpus is a corpus of documents; it contains no tool names. In production
+ * `tool_name` holds a short identifier ("Bash", "mcp__github__create_issue"),
+ * and the rules that key on it match short verbs — `(?i)(exec|execute|shell|
+ * bash|cmd|eval)`, `(?i)(delete|remove|drop|truncate)`, `(?i)(pay|payment|
+ * transfer)`. Pouring a whole SKILL.md into that field would match nearly every
+ * document and report a flood of false positives that cannot occur in
+ * production, which is worse than not measuring: fabricated FPs push a
+ * maintainer to weaken a rule that is correct.
+ *
+ * So tool_name is pinned to a constant. Conditions on it are therefore NOT
+ * measured, and that is reported explicitly (see UNMEASURABLE_FIELDS) instead of
+ * being passed off as clean. Frozen at the legacy value so the historical shape
+ * is reproduced byte for byte and old FP counts stay comparable.
+ */
+export declare const CORPUS_TOOL_NAME = "corpus-sample";
+/** Name of a shape, for reporting which presentation produced a match. */
+export type CorpusShapeName = "wide-raw" | "pre-tool-json-arg" | "pre-tool-json-both" | "post-tool-json" | "llm-input" | "tool-response";
+export interface CorpusShape {
+    readonly name: CorpusShapeName;
+    readonly event: AgentEvent;
+}
+/**
+ * Every field name a sample's text is actually poured into by some shape.
+ * A condition on any of these IS measured. Kept in sync with the shapes below
+ * by tests/corpus-event-shapes.test.ts, which proves reachability through the
+ * real engine rather than trusting this list.
+ */
+export declare const MEASURED_FIELDS: readonly string[];
+/**
+ * Field names the engine can resolve but that a TEXT corpus cannot honestly
+ * fill, with the reason. A rule whose conditions live here is UNMEASURED by
+ * this harness — callers must say so out loud rather than report it clean.
+ */
+export declare const UNMEASURABLE_FIELDS: ReadonlyMap<string, string>;
+/** A trace-method rule needs event.trace (a span DAG), which text cannot supply. */
+export declare const TRACE_FIELD_PREFIX = "trace.";
+/** A behavioral condition needs a numeric metric window, which text cannot supply. */
+export declare const BEHAVIORAL_FIELD_PREFIX = "behavioral.";
+/** True when a condition field can be measured with a text corpus. */
+export declare function isMeasurableField(field: string): boolean;
+/** Why a field cannot be measured — a sentence, or null when it can be. */
+export declare function unmeasurableReason(field: string): string | null;
+/**
+ * The canonical shape set. Callers must ALSO run engine.scanSkill(text) — the
+ * SKILL.md path is a separate engine entry point, not an event shape.
+ *
+ * Two axes have to be covered, and missing either one hides false positives:
+ *   - ENCODING: raw (shape 1) vs JSON-encoded (shapes 2-4), because a pattern
+ *     can match one and not the other.
+ *   - RULE ADMISSION: the engine filters rules by agent_source.type against the
+ *     event type. mcp_exchange (shape 1) is filtered against nothing, so every
+ *     rule runs; tool_call (2-3) admits tool_call + mcp_exchange rules;
+ *     tool_response (4) admits mcp_exchange + llm_io rules.
+ *
+ * Deliberately omitted: `llm_input` / `llm_output` / `multi_agent_message`
+ * events. Shape 1 already carries user_input / agent_output / agent_message
+ * explicitly and is admitted for every rule, so those types can only narrow.
+ */
+export declare function corpusShapes(text: string): readonly CorpusShape[];
+/** Human-readable list of the shapes, for harness banners. */
+export declare function shapeNames(): readonly string[];
+/**
+ * The two channels a raw adversarial PROMPT (garak, PINT, academic jailbreak
+ * corpora) can actually arrive through in production, as built by
+ * src/hook-handler.ts:
+ *
+ *   - `llm_input`     — the human typed it. Maps to source `llm_io`, so only
+ *                       llm_io rules are admitted.
+ *   - `tool_response` — a tool / MCP / RAG result carried it in (indirect
+ *                       injection). Maps to source `mcp_exchange`, and the
+ *                       engine additionally admits llm_io rules on it.
+ *
+ * WHY THIS IS SEPARATE FROM `corpusShapes()`
+ *
+ * `corpusShapes()` exists for a DOCUMENT corpus measured for false positives,
+ * and it is deliberately as wide as the engine allows — including
+ * `engine.scanSkill()`, the SKILL.md entry point. Scoring a garak jailbreak
+ * prompt through scanSkill() credits detections on a channel that prompt never
+ * travels, which inflates recall on a corpus that can never pay a false
+ * positive back (garak is 100% adversarial, so precision is 1 by construction
+ * and nothing charges the wide shape for its FPs).
+ *
+ * So: FP measurement uses the widest honest shape set; a pure-recall prompt
+ * corpus uses the production channels. Both live in this module so no harness
+ * hand-rolls a third one — the mistake this file was written to end.
+ *
+ * WHAT THIS REPLACED
+ *
+ * Four eval scripts built `{ type: 'llm_io', ... }`. `llm_io` is a rule
+ * SOURCE, not an `AgentEventType` (see src/types.ts). `EVENT_TYPE_TO_SOURCE`
+ * has no entry for it, so `eventSourceType` came out `undefined` and
+ * src/engine.ts skipped source-type filtering entirely — every rule of every
+ * source ran against an event that carried only `user_input`. That is not the
+ * narrow llm_input channel those scripts documented themselves as measuring.
+ * `tsc` would have caught it on the first run; tsconfig.json never included
+ * `scripts/`.
+ */
+export declare function promptChannelShapes(text: string): readonly CorpusShape[];
+/**
+ * True when `text` trips at least one rule on either production prompt channel.
+ * The one way a prompt-corpus harness decides "detected".
+ */
+export declare function detectedOnPromptChannels(engine: ScannableEngine, text: string): boolean;
+/**
+ * The same event, re-typed so the engine's source-type filter admits every rule.
+ *
+ * src/engine.ts maps an event type to an ATR source type (EVENT_TYPE_TO_SOURCE)
+ * and then skips every rule whose `agent_source.type` differs. `mcp_exchange`
+ * has NO entry in that map, so an mcp_exchange event is filtered against
+ * nothing — that is precisely why shape 1 above uses it.
+ *
+ * This helper isolates that single effect for a caller that already holds an
+ * event and wants to know how much of a measurement gap is rule ADMISSION as
+ * opposed to field POURING. It changes nothing else: same content, same fields,
+ * so a rule that newly fires here fires on the caller's own presentation of the
+ * sample, not on a fabricated one.
+ *
+ * Use it ALONGSIDE the original event, never instead of it. Re-typing drops the
+ * type-specific aliases in resolveField (an llm_input event resolves
+ * `user_input` from event.content; an mcp_exchange event does not), so the pair
+ * {original, sourceAgnostic(original)} is a strict superset of the original and
+ * the widening can only reveal matches, never hide them.
+ */
+export declare function sourceAgnosticEvent(event: AgentEvent): AgentEvent;
+/**
+ * The slice of ATREngine a corpus scan needs. Structural on purpose: this module
+ * stays free of a concrete engine import so the shape set can be reasoned about
+ * (and unit-tested) without loading the engine.
+ */
+export interface ScannableEngine {
+    evaluate(event: AgentEvent): readonly {
+        readonly rule: {
+            readonly id: string;
+        };
+    }[];
+    scanSkill(text: string): readonly {
+        readonly rule: {
+            readonly id: string;
+        };
+    }[];
+}
+/**
+ * Every rule id a sample matches: the canonical shape set PLUS scanSkill().
+ *
+ * Both halves are mandatory. scanSkill() is a separate engine entry point (the
+ * `pga scan` path), not an event shape, and rules with `scan_target: skill`
+ * reach production through it alone — a harness that only calls evaluate() would
+ * score them clean without reading them.
+ *
+ * The converse is equally true and much less obvious: the scanSkill() half is a
+ * no-op for most of the corpus. Its compound gate is unreachable for every
+ * `condition: any` rule that is not `scan_target: skill|both`, so counting it
+ * among the shapes does NOT mean a rule was measured on it. Ask
+ * skillPathCoverage() which ones the skill path never asked about, and say so.
+ *
+ * Counted PER SAMPLE, not per shape: a document that trips a rule on three
+ * shapes is one false positive, not three. Every harness that measures FP, TP or
+ * coverage must go through this function, so a rule can never earn its detection
+ * credit on a wider presentation than the one it pays its false positives on.
+ */
+export declare function matchedRuleIds(engine: ScannableEngine, text: string): ReadonlySet<string>;
+/** Minimal view of a rule — avoids importing the full ATRRule type surface. */
+export interface RuleLike {
+    readonly id: string;
+    readonly status?: string;
+    readonly maturity?: string;
+    readonly tags?: {
+        readonly scan_target?: unknown;
+    };
+    readonly detection?: {
+        readonly method?: string;
+        readonly condition?: string;
+        readonly conditions?: unknown;
+        readonly semantic?: {
+            readonly fallback_method?: unknown;
+        };
+    };
+}
+/** Every field name a rule's conditions declare, in declaration order. */
+export declare function conditionFields(rule: RuleLike): readonly string[];
+export interface FieldCoverage {
+    readonly ruleId: string;
+    /** Declared fields this harness cannot pour the sample into. */
+    readonly unmeasured: readonly string[];
+    /**
+     * True when NOTHING about this rule was measured — either no declared field is
+     * measurable, or the rule ANDs its conditions so a single unmeasurable field
+     * makes the whole rule unable to fire.
+     */
+    readonly zeroMeasurement: boolean;
+}
+/** Rules whose conditions this harness cannot fully measure. Clean rules omitted. */
+export declare function fieldCoverage(rules: readonly RuleLike[]): readonly FieldCoverage[];
+/**
+ * Statuses src/engine.ts drops BEFORE the lane gate, on both evaluation paths:
+ *
+ *     if (rule.status === 'deprecated' || rule.status === 'draft') continue;
+ *     if (!this.passesLane(rule)) continue;
+ *
+ * The order is the whole problem. `maturity` decides the lane; `status` decides
+ * whether the rule exists at all. A rule can therefore carry `maturity: stable`
+ * — the enforce lane, auto-block, no human in the loop — while `status: draft`
+ * keeps the engine from ever evaluating it. Seven rules on main are in exactly
+ * that state today.
+ *
+ * For an FP harness the consequence is the same disease fieldCoverage exists to
+ * name: the rule cannot fire, so it cannot be counted as a false positive, so
+ * the gate reports it CLEAN. Nothing in a field-based coverage check can see it,
+ * because every field the rule declares is perfectly measurable — the sample
+ * simply never reaches the rule.
+ *
+ * Kept honest by tests/corpus-event-shapes.test.ts, which parses the status
+ * comparisons out of src/engine.ts rather than trusting this list.
+ */
+export declare const INERT_STATUSES: ReadonlySet<string>;
+/** Rule maturities that put a rule in the enforce (auto-block) lane. */
+export declare const ENFORCE_LANE_MATURITIES: ReadonlySet<string>;
+/** True when the engine skips this status outright, in every lane. */
+export declare function isInertStatus(status: string | undefined): boolean;
+/** Why a status makes a rule unmeasurable — a sentence, or null when it does not. */
+export declare function inertStatusReason(status: string | undefined): string | null;
+export interface StatusGap {
+    readonly ruleId: string;
+    /** The normalised inert status that stopped the rule from being evaluated. */
+    readonly status: string;
+    /** The rule's declared maturity, so a caller can say how bad this is. */
+    readonly maturity: string | null;
+    /** True when the rule also claims the enforce (auto-block) lane. */
+    readonly claimsEnforceLane: boolean;
+    readonly reason: string;
+}
+/**
+ * Rules the engine will not evaluate at all. Measurable rules are omitted.
+ *
+ * Unlike an unmeasurABLE field (no benign corpus can supply a tool_name; a text
+ * corpus has no span DAG), this one has a remedy that is always available and is
+ * one line long: flip the status, or drop the maturity out of the enforce lane.
+ * That difference is why callers are expected to FAIL on this rather than merely
+ * print it — see the exit-code note in scripts/gate-promotion-fp.ts.
+ */
+export declare function statusCoverage(rules: readonly RuleLike[]): readonly StatusGap[];
+/**
+ * matchedRuleIds() runs four evaluate() shapes AND engine.scanSkill(), and the
+ * gate prints `shapes = wide-raw, ..., skill`. That banner reads as "every rule
+ * you are gating was offered to the skill path". For 645 of the 780 rules on
+ * main that is false, and not by a little: they cannot produce a match on that
+ * path for ANY input whatsoever.
+ *
+ * THE MECHANISM (src/engine.ts, evaluateRaw / evaluateAsync)
+ *
+ * scanSkill() builds an event with `scanContext: 'skill'`. In that context the
+ * engine skips source-type filtering — every rule is evaluated — and then
+ * applies a compound gate to any rule NOT declared for skill scanning:
+ *
+ *     if (isSkillContext && rule.tags.scan_target !== 'skill'
+ *                        && rule.tags.scan_target !== 'both') {
+ *       const totalConds = Number(rule.detection?.conditions?.length ?? 1);
+ *       const minRequired = Math.max(2, Math.ceil(totalConds * 0.3));
+ *       if ((matchResult.matchedConditions?.length ?? 0) < minRequired) continue;
+ *     }
+ *
+ * The comment above it describes a graded threshold ("30%+ of conditions").
+ * `matchedConditions` is produced by evaluateArrayConditions, which for
+ * `condition: any` SHORT-CIRCUITS:
+ *
+ *     if (result) { matchedConditionIndices.push(i); if (isAny) break; }
+ *
+ * So for an any-mode rule `matchedConditions.length` is 1 whenever the rule
+ * matches at all, and 0 otherwise. It is never 2. `minRequired` is never below
+ * 2. 776 of the 780 rules on main declare `condition: any`. The threshold is
+ * therefore not a threshold — it is an unconditional reject, and the effective
+ * policy of the SKILL.md path is "only `scan_target: skill|both` rules run".
+ *
+ * That policy is defensible and it is load-bearing (measured 2026-08-05: making
+ * the threshold reachable takes the 466-sample benign skill corpus from 1 flagged
+ * sample to 265, while malicious recall stays 32/32 — the cost is real and the
+ * benefit is unmeasurable on that corpus). What is NOT defensible is the gate
+ * reporting a `skill` shape it never charged those rules on. This axis exists so
+ * the gate says which rules the skill shape did not ask about, exactly as
+ * fieldCoverage does for fields and statusCoverage does for inert rules.
+ *
+ * Like fieldCoverage — and unlike statusCoverage — this must NOT change an exit
+ * code. An `scan_target: mcp` rule being unreachable on the SKILL.md path is the
+ * intended behaviour, not a defect with a one-line remedy; failing on it would
+ * block every promotion with nothing to fix.
+ */
+export declare const SKILL_NATIVE_SCAN_TARGETS: ReadonlySet<string>;
+/** Why a rule can never fire on engine.scanSkill(). */
+export type SkillPathBlocker = "method-trace" | "method-behavioral" | "method-signature" | "method-semantic-no-pattern-fallback" | "no-conditions" | "compound-gate-unreachable";
+export interface SkillPathGap {
+    readonly ruleId: string;
+    readonly blocker: SkillPathBlocker;
+    /** scan_target as declared, or null when the rule declares none. */
+    readonly scanTarget: string | null;
+    readonly maturity: string | null;
+    /** True when the rule also claims the enforce (auto-block) lane. */
+    readonly claimsEnforceLane: boolean;
+    /** Most matchedConditions the engine can ever hand the compound gate. */
+    readonly maxAttainableConditions: number;
+    /** What the compound gate demands. */
+    readonly requiredConditions: number;
+    readonly reason: string;
+}
+/**
+ * Why this rule can never match on the SKILL.md path — or null when it can.
+ *
+ * Inert (draft/deprecated) rules return null on purpose: they cannot fire on ANY
+ * path, which is statusCoverage's finding, and reporting them twice would blur
+ * "the skill path did not ask" into "the engine never loaded it".
+ */
+export declare function skillPathBlocker(rule: RuleLike): SkillPathGap | null;
+/**
+ * Rules engine.scanSkill() can never match. Reachable rules are omitted.
+ *
+ * The skill path is a genuine production entry point (`pga scan`), and it is one
+ * of the two halves of matchedRuleIds(). A caller that prints "skill" among its
+ * shapes owes the reader this list.
+ */
+export declare function skillPathCoverage(rules: readonly RuleLike[]): readonly SkillPathGap[];
+//# sourceMappingURL=corpus-event.d.ts.map

package/dist/corpus-event.d.ts.map

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