agent-bober 0.18.0 → 0.19.0

package/dist/orchestrator/security-gate.js

@@ -0,0 +1,174 @@
+import { runSecurityAudit } from "./security-auditor-agent.js";
+import { saveSecurityAudit } from "../state/security-audit-state.js";
+import { logger } from "../utils/logger.js";
+import { emitSecurityFindings, mapAuditToFindings } from "./security-hub.js";
+import { ingestFinding } from "../hub/finding-store.js";
+import { FactStore, factsDbPath, ensureFactsDir } from "../state/facts.js";
+// Unique sentinel so a race timeout is distinguishable from any other
+// rejection (provider/network/budget error) surfaced by runSecurityAudit.
+const TIMEOUT_MESSAGE = "security-audit timeout";
+// ── Gate ───────────────────────────────────────────────────────────
+/**
+ * Evaluate the security gate for a sprint that just passed evaluation.
+ *
+ * Never throws. Resolution mapping:
+ * - `config.security` absent or `enabled !== true` → `{blocked:false, reason:'disabled'}`
+ *   WITHOUT invoking the audit at all.
+ * - `runSecurityAudit` rejects (any error) → `{blocked:true, reason:'audit-error'}`.
+ * - The Promise.race timeout (`config.security.timeoutMs`) fires first →
+ *   `{blocked:true, reason:'timeout'}`.
+ * - `result.parsed === false` (unparseable auditor output) →
+ *   `{blocked:true, reason:'audit-error', result}` — checked BEFORE
+ *   `result.verdict` so a parse failure is never mistaken for a genuine
+ *   critical finding.
+ * - `result.verdict === 'blocked'` (a real critical finding) →
+ *   `{blocked:true, reason:'critical-finding', result}`.
+ * - Otherwise → `{blocked:false, reason:'clean', result}`.
+ *
+ * A `saveSecurityAudit` persistence failure is caught, logged, and never
+ * changes the already-computed verdict in either direction (sc-3-6).
+ */
+export async function evaluateSecurityGate(input) {
+    const { contract, evaluation, projectRoot, config, findingSink } = input;
+    // Disabled short-circuit — construct nothing, invoke nothing.
+    if (config.security?.enabled !== true) {
+        return { blocked: false, reason: "disabled" };
+    }
+    const timeoutMs = config.security.timeoutMs;
+    let result;
+    try {
+        result = await Promise.race([
+            runSecurityAudit(contract, evaluation, projectRoot, config),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(TIMEOUT_MESSAGE)), timeoutMs)),
+        ]);
+    }
+    catch (err) {
+        const timedOut = err instanceof Error && err.message === TIMEOUT_MESSAGE;
+        logger.warn(`Security audit ${timedOut ? "timed out" : "failed"}: ${err instanceof Error ? err.message : String(err)}`);
+        return { blocked: true, reason: timedOut ? "timeout" : "audit-error" };
+    }
+    // Parse-failure elevation MUST be checked before result.verdict: a parse
+    // failure already forces verdict:'blocked' inside runSecurityAudit, but the
+    // gate reports the distinct reason 'audit-error' (not 'critical-finding')
+    // so callers/tests can tell the two failure modes apart.
+    if (result.parsed === false) {
+        return { blocked: true, reason: "audit-error", result };
+    }
+    // Best-effort hub emission — result.verdict is already computed (above)
+    // and this call is OUTSIDE the Promise.race time-box, so a slow or
+    // failing ingest can never manufacture a false 'timeout' or flip the
+    // verdict (nonGoals[3]). Guarded by config.security.hub (default true).
+    await emitFindingsToHub(result, projectRoot, config, findingSink);
+    // Best-effort persistence. runSecurityAudit already persisted internally
+    // (security-auditor-agent.ts) — this is a deliberate, idempotent re-save
+    // guarded independently so a store failure here can never flip the
+    // already-computed verdict (sc-3-6).
+    try {
+        await saveSecurityAudit(projectRoot, contract.contractId, result);
+    }
+    catch (err) {
+        logger.warn(`Security audit persistence failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return result.verdict === "blocked"
+        ? { blocked: true, reason: "critical-finding", result }
+        : { blocked: false, reason: "clean", result };
+}
+// ── Hub emission ─────────────────────────────────────────────────────
+/**
+ * Emit a SecurityAuditResult's critical/important findings into the
+ * priority hub. Best-effort: emitSecurityFindings already catches and logs
+ * sink failures internally, so this helper never throws and never affects
+ * the gate's verdict.
+ *
+ * - `config.security.hub === false` -> no-op (zero hub writes).
+ * - An injected `findingSink` (tests) is used as-is.
+ * - Otherwise, a FactStore is opened lazily — only when mapAuditToFindings
+ *   produces at least one finding to emit — so a clean audit (or a
+ *   `hub:false` config) never touches the filesystem.
+ *
+ * `now` is stamped here (not injected) — SecurityGateInput has no clock
+ * dependency today, and pipeline.ts already stamps `new Date()` at its own
+ * history-event boundaries (pipeline.ts:481,525), so this is a genuine,
+ * consistent side-effecting boundary.
+ */
+async function emitFindingsToHub(result, projectRoot, config, findingSink) {
+    if (config.security?.hub === false)
+        return;
+    const now = new Date().toISOString();
+    if (findingSink !== undefined) {
+        await emitSecurityFindings(result, findingSink, logger, now);
+        return;
+    }
+    // Check emptiness BEFORE opening a store — a clean audit (mapAuditToFindings
+    // returns []) never touches the filesystem. mapAuditToFindings is pure and
+    // cheap, so computing it twice (here + inside emitSecurityFindings) is fine.
+    if (mapAuditToFindings(result, now).length === 0)
+        return;
+    // The ENTIRE default-sink sequence (dir creation, store open, emission,
+    // store close) is wrapped in one try/catch/finally: `emitSecurityFindings`
+    // only guards the emission loop itself — it does NOT cover `ensureFactsDir`
+    // or `new FactStore`, so an fs failure there (disk full, EACCES, a
+    // non-directory occupying `.bober`, a locked/corrupt sqlite file) must be
+    // caught here too, or it propagates as an unhandled rejection out of this
+    // async function and never reaches the gate's already-computed verdict
+    // (sc-6-2 regression fix, iteration 2).
+    let store;
+    try {
+        await ensureFactsDir(projectRoot);
+        const opened = new FactStore(factsDbPath(projectRoot));
+        store = opened;
+        const defaultSink = async (finding) => {
+            await ingestFinding(opened, finding, { now });
+        };
+        await emitSecurityFindings(result, defaultSink, logger, now);
+    }
+    catch (err) {
+        logger.warn(`Security hub emission failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    finally {
+        store?.close();
+    }
+}
+// ── Feedback rendering ─────────────────────────────────────────────
+/** Bound the number of findings rendered/logged per blocked round. */
+const MAX_RENDERED_FINDINGS = 20;
+/**
+ * Render a blocked SecurityGateVerdict into feedback strings for the
+ * generator's next retry iteration (ADR-5), phrased for a fixer. Pure
+ * function — no side effects, no I/O.
+ *
+ * Returns `[]` for a non-blocked verdict. Returns a single generic message
+ * when there is no `result` to enumerate findings from (a `timeout` or a
+ * rejected `audit-error` never resolves a SecurityAuditResult). Otherwise
+ * returns a summary line followed by one line per critical finding, capped
+ * to MAX_RENDERED_FINDINGS.
+ */
+export function renderSecurityFeedback(verdict) {
+    if (!verdict.blocked)
+        return [];
+    if (!verdict.result) {
+        const reasonText = verdict.reason === "timeout"
+            ? "the security audit timed out before completing"
+            : "the security audit could not be completed";
+        return [
+            `[SECURITY] Sprint blocked: ${reasonText}. No specific findings are available — investigate the audit failure and retry.`,
+        ];
+    }
+    const { review } = verdict.result;
+    // The auditor always constructs `review.critical` from SecurityFinding
+    // objects (security-auditor-agent.ts), a superset of the locked
+    // ReviewFinding shape — safe to narrow here to read the optional vulnClass.
+    const criticalFindings = review.critical;
+    const parts = [
+        `[SECURITY] Security audit blocked this sprint (reason: ${verdict.reason}, ${criticalFindings.length} critical finding(s)).`,
+    ];
+    for (const finding of criticalFindings.slice(0, MAX_RENDERED_FINDINGS)) {
+        const evidence = finding.evidence[0];
+        const path = evidence?.path ?? "unknown";
+        const line = evidence?.line ?? 0;
+        const vulnPrefix = finding.vulnClass ? `${finding.vulnClass}: ` : "";
+        parts.push(`[CRITICAL] ${vulnPrefix}${finding.description} at ${path}:${line} — remediate by fixing the flagged vulnerability before this sprint can pass.`);
+    }
+    return parts;
+}
+//# sourceMappingURL=security-gate.js.map

package/dist/orchestrator/security-gate.js.map

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

package/dist/orchestrator/security-hub.d.ts

@@ -0,0 +1,45 @@
+/**
+ * security-hub.ts — maps SecurityAuditResult findings into the canonical hub
+ * Finding shape and emits them via an injected sink (spec-20260712-security-
+ * audit-agent-team, sprint 6). Closes the ADR open question at
+ * .bober/architecture/arch-20260712-security-audit-agent-team-architecture.md:363
+ * ("wiring important findings into the priority hub ... must respect the
+ * hub's canonical FindingSchema").
+ *
+ * Two callers wire this module in AFTER the audit's verdict is already
+ * computed: the pipeline gate (security-gate.ts) and the standalone CLI
+ * (security-audit.ts). Neither call site awaits emission inside a
+ * time-boxed race, and a hub failure never changes the verdict or exit code
+ * — emission is a best-effort side effect (nonGoals[3]).
+ *
+ * Mirrors the injected-FindingSink precedent in src/research/runner.ts:
+ * the mapper is PURE (never reads the clock — `now` is injected by the
+ * caller) and the sink is a dependency the caller binds to the real
+ * `ingestFinding` (src/hub/finding-store.ts) at the fs boundary.
+ */
+import type { Finding } from "../hub/finding.js";
+import type { SecurityAuditResult } from "./security-audit-types.js";
+import type { Logger } from "../utils/logger.js";
+/** Hub Finding emitter — mirrors research runner's FindingSink (runner.ts:44). */
+export type SecurityFindingSink = (finding: Finding) => Promise<void>;
+/**
+ * Map a SecurityAuditResult into hub Findings — one per critical (severity
+ * 5) and important (severity 3) finding. `minor` and `approvedAreas` are
+ * never emitted (nonGoals[2]) — the LLM auditor did not confirm those into a
+ * blocking or notable bucket. A clean audit (no critical/important) returns
+ * `[]`.
+ *
+ * PURE: never reads the clock — `now` is injected by the caller.
+ */
+export declare function mapAuditToFindings(result: SecurityAuditResult, now: string): Finding[];
+/**
+ * Map and emit a SecurityAuditResult's findings through the injected sink.
+ *
+ * Best-effort: never throws. A failure raised by the sink (or by the
+ * mapping) is caught and logged via `log.warn` — it must NEVER alter the
+ * audit verdict or block the pipeline/CLI (sc-6-2). Callers invoke this
+ * strictly AFTER the verdict has already been computed and OUTSIDE any
+ * time-boxed race (nonGoals[3]).
+ */
+export declare function emitSecurityFindings(result: SecurityAuditResult, sink: SecurityFindingSink, log: Pick<Logger, "warn">, now: string): Promise<void>;
+//# sourceMappingURL=security-hub.d.ts.map

package/dist/orchestrator/security-hub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-hub.d.ts","sourceRoot":"","sources":["../../src/orchestrator/security-hub.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,mBAAmB,EAAmB,MAAM,2BAA2B,CAAC;AACtF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD,kFAAkF;AAClF,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAqGtE;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,mBAAmB,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,EAAE,CAYtF;AAID;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,mBAAmB,EACzB,GAAG,EAAE,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,EACzB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,IAAI,CAAC,CAQf"}

package/dist/orchestrator/security-hub.js

@@ -0,0 +1,147 @@
+/**
+ * security-hub.ts — maps SecurityAuditResult findings into the canonical hub
+ * Finding shape and emits them via an injected sink (spec-20260712-security-
+ * audit-agent-team, sprint 6). Closes the ADR open question at
+ * .bober/architecture/arch-20260712-security-audit-agent-team-architecture.md:363
+ * ("wiring important findings into the priority hub ... must respect the
+ * hub's canonical FindingSchema").
+ *
+ * Two callers wire this module in AFTER the audit's verdict is already
+ * computed: the pipeline gate (security-gate.ts) and the standalone CLI
+ * (security-audit.ts). Neither call site awaits emission inside a
+ * time-boxed race, and a hub failure never changes the verdict or exit code
+ * — emission is a best-effort side effect (nonGoals[3]).
+ *
+ * Mirrors the injected-FindingSink precedent in src/research/runner.ts:
+ * the mapper is PURE (never reads the clock — `now` is injected by the
+ * caller) and the sink is a dependency the caller binds to the real
+ * `ingestFinding` (src/hub/finding-store.ts) at the fs boundary.
+ */
+import { createHash } from "node:crypto";
+// ── Local id hash ────────────────────────────────────────────────────────
+/**
+ * Content-stable id: hash of domain|title|kind. Replicated locally because
+ * finding-store.ts's own deriveFindingId is not exported — src/research/
+ * runner.ts sets this precedent (runner.ts:104-109). This is an id hash,
+ * NOT a schema-level redefinition of the Finding shape (sc-6-4).
+ */
+function deriveFindingId(domain, title, kind) {
+    return createHash("sha256").update(`${domain}|${title}|${kind}`).digest("hex").slice(0, 16);
+}
+// ── Severity mapping (sc-6-1) ────────────────────────────────────────────
+//
+// Read directly from the REAL FindingSchema (src/hub/finding.ts:15-16):
+// both `severity` and `urgency` are `z.number().int().min(1).max(5)`.
+//
+//   Audit bucket             Hub severity   Hub urgency   Rationale
+//   ------------------------ -------------  ------------  ----------------------
+//   review.critical[]        5 (highest)    5             blocking vulnerability
+//   review.important[]       3 (mid)        3             non-blocking, surfaced
+//   review.minor[] /         (not emitted)  --            nonGoals[2] — the LLM
+//   approvedAreas                                          auditor did not confirm
+//                                                           these into a blocking
+//                                                           or notable bucket.
+const CRITICAL_SEVERITY = 5;
+const CRITICAL_URGENCY = 5;
+const IMPORTANT_SEVERITY = 3;
+const IMPORTANT_URGENCY = 3;
+// ── Mapping ──────────────────────────────────────────────────────────────
+/**
+ * Build one hub Finding per SecurityFinding in a bucket.
+ *
+ * `title` is STABLE — vulnClass + a discriminator + the first evidence
+ * entry's path:line. It must NEVER embed the free-text description
+ * verbatim: the Finding `id` is derived from `domain|title|kind`, so a
+ * title that varies across retries would mint a new id every time and
+ * defeat the hub's content-hash dedup (sc-6-3).
+ *
+ * The discriminator (`#${...}`) fixes a title collision (G10): two
+ * DIFFERENT vulnerabilities of the same vulnClass at the same path:line
+ * used to hash to the SAME id and silently overwrite each other. It
+ * prefers `signatureId`, then `cwe`, then falls back to a short stable
+ * hash of the finding's own `description` — content-derived so identical
+ * retries (same description) still resolve to the same discriminator and
+ * dedup, while two distinct descriptions diverge into distinct ids.
+ *
+ * The description itself still lands in `evidence[]` — FindingSchema has
+ * no `body` field, and its `evidence` is `z.array(z.string())` (finding.
+ * ts:17), NOT the `{path,line,snippet}[]` shape a SecurityFinding
+ * carries — so each evidence entry is flattened to a string.
+ */
+function mapBucket(findings, severity, urgency, stack, now) {
+    return findings.map((finding) => {
+        const primaryEvidence = finding.evidence[0];
+        const path = primaryEvidence?.path ?? "unknown";
+        const line = primaryEvidence?.line ?? 0;
+        const discriminator = finding.signatureId ??
+            finding.cwe ??
+            createHash("sha256").update(finding.description).digest("hex").slice(0, 8);
+        const title = `[security] ${finding.vulnClass ?? "vulnerability"} #${discriminator} at ${path}:${line}`;
+        const evidence = [
+            finding.description,
+            ...finding.evidence.map((e) => `${e.path}:${e.line} — ${e.snippet}`),
+        ];
+        return {
+            id: deriveFindingId("security", title, "risk"),
+            domain: "security",
+            title,
+            kind: "risk",
+            urgency,
+            severity,
+            evidence,
+            surfacedAt: now,
+            tags: [
+                "security",
+                ...(finding.vulnClass ? [`vuln:${finding.vulnClass}`] : []),
+                `stack:${stack}`,
+                ...(finding.cwe ? [`cwe:${finding.cwe}`] : []),
+                ...(finding.severity ? [`severity:${finding.severity}`] : []),
+                ...(finding.confidence ? [`confidence:${finding.confidence}`] : []),
+                ...(finding.signatureId ? [`sig:${finding.signatureId}`] : []),
+            ],
+            status: "open",
+        };
+    });
+}
+/**
+ * Map a SecurityAuditResult into hub Findings — one per critical (severity
+ * 5) and important (severity 3) finding. `minor` and `approvedAreas` are
+ * never emitted (nonGoals[2]) — the LLM auditor did not confirm those into a
+ * blocking or notable bucket. A clean audit (no critical/important) returns
+ * `[]`.
+ *
+ * PURE: never reads the clock — `now` is injected by the caller.
+ */
+export function mapAuditToFindings(result, now) {
+    // review.critical/important are always built from SecurityFinding objects
+    // inside runSecurityAudit (a superset of the locked ReviewFinding shape) —
+    // the same safe narrowing security-gate.ts's renderSecurityFeedback relies
+    // on (security-gate.ts:158).
+    const critical = result.review.critical;
+    const important = result.review.important;
+    return [
+        ...mapBucket(critical, CRITICAL_SEVERITY, CRITICAL_URGENCY, result.stack, now),
+        ...mapBucket(important, IMPORTANT_SEVERITY, IMPORTANT_URGENCY, result.stack, now),
+    ];
+}
+// ── Emission ─────────────────────────────────────────────────────────────
+/**
+ * Map and emit a SecurityAuditResult's findings through the injected sink.
+ *
+ * Best-effort: never throws. A failure raised by the sink (or by the
+ * mapping) is caught and logged via `log.warn` — it must NEVER alter the
+ * audit verdict or block the pipeline/CLI (sc-6-2). Callers invoke this
+ * strictly AFTER the verdict has already been computed and OUTSIDE any
+ * time-boxed race (nonGoals[3]).
+ */
+export async function emitSecurityFindings(result, sink, log, now) {
+    try {
+        for (const finding of mapAuditToFindings(result, now)) {
+            await sink(finding);
+        }
+    }
+    catch (err) {
+        log.warn(`Security hub emission failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+//# sourceMappingURL=security-hub.js.map

package/dist/orchestrator/security-hub.js.map

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

package/dist/orchestrator/security-knowledge/benchmark/harness.d.ts

@@ -0,0 +1,43 @@
+import type { VulnClass } from "../../security-audit-types.js";
+import type { SecurityStackId } from "../signature.js";
+/**
+ * Deterministic measurement harness for the security-auditor finder+verifier
+ * pipeline (spec-20260714 sprint 9, architecture success criterion #3:
+ * "measured, not asserted"). Pure — no fs, no network, no `Math.random`, no
+ * `new Date()`/`Date.now()`. Not wired into `runSecurityAudit` or the gate
+ * (nonGoals: "not a new blocking gate") — this is a leaf measurement module
+ * consumed only by `harness.test.ts`.
+ */
+/** One labelled benchmark case (mirrors a `fixtures/manifest.json` entry). */
+export interface BenchmarkCase {
+    /** Stable id, unique in the corpus (used by fakes to pick the FP subset). */
+    id: string;
+    expected: "vulnerable" | "safe";
+    stack: SecurityStackId;
+    /** Only meaningful for expected:"vulnerable". Omitted for scanner-only classes (supply-chain). */
+    signatureId?: string;
+    vulnClass?: VulnClass;
+    /** The illustrative snippet — inline, never a separate compiled file. */
+    code: string;
+}
+/** Injected finder: does this case get flagged CRITICAL? (pluggable so CI uses a fake). */
+export type FinderFn = (c: BenchmarkCase) => boolean;
+/**
+ * Injected verifier: given the finder's critical verdict, the post-verify verdict.
+ * DOWNGRADE-ONLY, mirroring `VerifierResult` semantics (security-verifier-agent.ts):
+ * may only turn true->false (drop/downgrade), never false->true.
+ */
+export type VerifierFn = (c: BenchmarkCase, finderCritical: boolean) => boolean;
+export interface StageMetrics {
+    /** vulnerable cases flagged critical / total vulnerable cases (detection retained; higher is better). */
+    recall: number;
+    /** safe cases flagged critical / total safe cases (false-positive BLOCK rate; lower is better). */
+    fpBlockRate: number;
+}
+export interface MeasureResult {
+    finderOnly: StageMetrics;
+    finderPlusVerifier: StageMetrics;
+}
+/** PURE. No fs, no network, NO Math.random, NO new Date(). */
+export declare function measure(corpus: BenchmarkCase[], finderFn: FinderFn, verifierFn: VerifierFn): MeasureResult;
+//# sourceMappingURL=harness.d.ts.map

package/dist/orchestrator/security-knowledge/benchmark/harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../../../../src/orchestrator/security-knowledge/benchmark/harness.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD;;;;;;;GAOG;AAEH,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC5B,6EAA6E;IAC7E,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,YAAY,GAAG,MAAM,CAAC;IAChC,KAAK,EAAE,eAAe,CAAC;IACvB,kGAAkG;IAClG,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC;CACd;AAED,2FAA2F;AAC3F,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,EAAE,aAAa,KAAK,OAAO,CAAC;AAErD;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,EAAE,aAAa,EAAE,cAAc,EAAE,OAAO,KAAK,OAAO,CAAC;AAEhF,MAAM,WAAW,YAAY;IAC3B,yGAAyG;IACzG,MAAM,EAAE,MAAM,CAAC;IACf,mGAAmG;IACnG,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,YAAY,CAAC;IACzB,kBAAkB,EAAE,YAAY,CAAC;CAClC;AAED,8DAA8D;AAC9D,wBAAgB,OAAO,CAAC,MAAM,EAAE,aAAa,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,GAAG,aAAa,CAc1G"}

package/dist/orchestrator/security-knowledge/benchmark/harness.js

@@ -0,0 +1,13 @@
+/** PURE. No fs, no network, NO Math.random, NO new Date(). */
+export function measure(corpus, finderFn, verifierFn) {
+    const vulnerable = corpus.filter((c) => c.expected === "vulnerable");
+    const safe = corpus.filter((c) => c.expected === "safe");
+    const finderOnly = (c) => finderFn(c);
+    const finderPlusVerifier = (c) => verifierFn(c, finderFn(c));
+    const rate = (cases, flag) => cases.length === 0 ? 0 : cases.filter(flag).length / cases.length;
+    return {
+        finderOnly: { recall: rate(vulnerable, finderOnly), fpBlockRate: rate(safe, finderOnly) },
+        finderPlusVerifier: { recall: rate(vulnerable, finderPlusVerifier), fpBlockRate: rate(safe, finderPlusVerifier) },
+    };
+}
+//# sourceMappingURL=harness.js.map

package/dist/orchestrator/security-knowledge/benchmark/harness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness.js","sourceRoot":"","sources":["../../../../src/orchestrator/security-knowledge/benchmark/harness.ts"],"names":[],"mappings":"AA+CA,8DAA8D;AAC9D,MAAM,UAAU,OAAO,CAAC,MAAuB,EAAE,QAAkB,EAAE,UAAsB;IACzF,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,YAAY,CAAC,CAAC;IACrE,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,MAAM,CAAC,CAAC;IAEzD,MAAM,UAAU,GAAG,CAAC,CAAgB,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IACrD,MAAM,kBAAkB,GAAG,CAAC,CAAgB,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;IAE5E,MAAM,IAAI,GAAG,CAAC,KAAsB,EAAE,IAAmC,EAAE,EAAE,CAC3E,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAEpE,OAAO;QACL,UAAU,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,EAAE;QACzF,kBAAkB,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,kBAAkB,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,IAAI,EAAE,kBAAkB,CAAC,EAAE;KAClH,CAAC;AACJ,CAAC"}

package/dist/orchestrator/security-knowledge/diff-provider.d.ts

@@ -0,0 +1,79 @@
+import type { BoberConfig } from "../../config/schema.js";
+/**
+ * Orchestrator-owned real-diff provider (spec-20260714 sprint 6, ADR-5).
+ *
+ * Shells `git` in orchestrator Node — NEVER as an auditor tool — to compute
+ * the actual changed files/hunks for a sprint, replacing the sprint-5 seam
+ * that ranked signatures against `contract.estimatedFiles` only. Mirrors
+ * `security-scanners.ts`'s injectable never-throw runner shape exactly
+ * (Pattern A): any git failure (ENOENT, not-a-repo, abort, malformed
+ * output) degrades to an empty `AuditDiff` rather than throwing, so a
+ * broken git environment never crashes the audit — it just falls back to
+ * `estimated-files` behavior.
+ *
+ * `AuditDiff` is the shared input type future sprints (7: supply-chain,
+ * 8: verifier) will also consume — kept clean and exported.
+ */
+export interface DiffHunk {
+    startLine: number;
+    lineCount: number;
+    content: string;
+}
+export interface ChangedFile {
+    path: string;
+    status: "added" | "modified" | "deleted" | "renamed";
+    hunks: DiffHunk[];
+}
+export interface AuditDiff {
+    changedFiles: ChangedFile[];
+    neighborhoodFiles: string[];
+    truncated: boolean;
+}
+export declare const EMPTY_DIFF: AuditDiff;
+export interface GitRunResult {
+    exitCode: number | undefined;
+    stdout: string;
+    failed: boolean;
+}
+export type GitRunner = (args: string[], opts: {
+    cwd: string;
+    signal: AbortSignal;
+}) => Promise<GitRunResult>;
+/**
+ * Parse `git diff --name-status` + `git diff -U<n>` output into
+ * `ChangedFile[]`, bounded by `MAX_CHANGED_FILES` (file count) and
+ * `MAX_HUNK_BYTES` (total hunk content bytes). Pure and total — any
+ * structural surprise (non-string input, malformed lines) is skipped
+ * rather than thrown (Pattern B, mirrors `parseSlitherOutput`).
+ */
+export declare function parseUnifiedDiff(nameStatus: string, unified: string): {
+    files: ChangedFile[];
+    truncated: boolean;
+};
+/**
+ * Tokenizes changed-hunk text into keywords for the selector's
+ * keyword-overlap ranking (selector.ts). Pure and total: guards every
+ * field access, never throws on malformed hunk content.
+ */
+export declare function extractDiffKeywords(files: ChangedFile[]): string[];
+export interface SecurityDiffComputeInput {
+    projectRoot: string;
+    baseRef?: string;
+    expandWithGraph: boolean;
+    signal: AbortSignal;
+    /** Needed for the `getGraphState(config).engineHealth === 'ready'` gate (sc-6-2). */
+    config?: BoberConfig;
+    /** Injected in tests — default wraps execa. */
+    runner?: GitRunner;
+}
+export interface SecurityDiffProvider {
+    compute(input: SecurityDiffComputeInput): Promise<AuditDiff>;
+}
+/**
+ * Computes a real, bounded `AuditDiff` by shelling git in orchestrator
+ * Node. NEVER throws: any failure (missing git, not-a-repo, abort,
+ * malformed diff output) degrades to `EMPTY_DIFF`, which callers treat as
+ * "fall back to estimated-files" rather than an audit-crashing error.
+ */
+export declare const securityDiffProvider: SecurityDiffProvider;
+//# sourceMappingURL=diff-provider.d.ts.map

package/dist/orchestrator/security-knowledge/diff-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-provider.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/security-knowledge/diff-provider.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAI1D;;;;;;;;;;;;;;GAcG;AAIH,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,CAAC;IACrD,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,eAAO,MAAM,UAAU,EAAE,SAAyE,CAAC;AAInG,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,MAAM,SAAS,GAAG,CACtB,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,KACvC,OAAO,CAAC,YAAY,CAAC,CAAC;AAqL3B;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GACd;IAAE,KAAK,EAAE,WAAW,EAAE,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAmC9C;AAoBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM,EAAE,CAyBlE;AAqCD,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,EAAE,WAAW,CAAC;IACpB,qFAAqF;IACrF,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,+CAA+C;IAC/C,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;CAC9D;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,EAAE,oBAwDlC,CAAC"}