@clear-capabilities/agentic-security-scanner 0.175.0 → 0.177.0

package/dist/818.index.js

@@ -11,7 +11,7 @@ export const modules = {
 /* harmony export */ });
 /* harmony import */ var _states_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12090);
 /* harmony import */ var _orchestrator_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3740);
-/* harmony import */ var _runner_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2998);
+/* harmony import */ var _runner_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(23081);
 /* harmony import */ var _reproducer_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(37055);
 // Verified remediation, extended with exploit replay. This EXTENDS the fix-verify vocabulary (`verifiedFull`,
 // `degradedLegs`); it does not define a competing meaning of "verified".
@@ -27,7 +27,7 @@ export const modules = {
 
 
 
-async function verifyFixWithProof({ finding, reproducer, files, scanRoot, revision = null, policy = {}, staticVerification = null, siblings = null, signal, deps = {} } = {}) {
+async function verifyFixWithProof({ finding, reproducer, files, scanRoot, revision = null, policy = {}, staticVerification = null, siblings = null, siblingSearchTruncated = [], signal, deps = {} } = {}) {
   const t0 = Date.now();
   const attemptFn = deps.attemptFn ?? _runner_js__WEBPACK_IMPORTED_MODULE_2__/* .runAttempt */ .Tm;
   const patchHash = (0,_reproducer_js__WEBPACK_IMPORTED_MODULE_3__/* .sha256 */ .sc)((0,_reproducer_js__WEBPACK_IMPORTED_MODULE_3__/* .canonicalize */ .dw)(files || {}));
@@ -67,6 +67,7 @@ async function verifyFixWithProof({ finding, reproducer, files, scanRoot, revisi
   const siblingCount = Array.isArray(siblings) ? siblings.length : null;
   if (siblingCount === null) degraded.push('sibling-search-not-run');
   else if (siblingCount > 0) degraded.push(`sibling-exposures:${siblingCount}`);
+  if (siblingCount !== null && siblingSearchTruncated?.length) degraded.push('sibling-search-incomplete');
 
   const full = degraded.length === 0;
   // Same split as fix-verify: `ok` (nothing that ran failed) earns FIX_VERIFIED; `completeness` says whether anything was skipped.
@@ -99,7 +100,7 @@ function formatFixProof(r) {
 /* unused harmony exports independentVerify, applySeverityPolicy, _newRunId */
 /* harmony import */ var node_crypto__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(77598);
 /* harmony import */ var _states_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12090);
-/* harmony import */ var _runner_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2998);
+/* harmony import */ var _runner_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(23081);
 /* harmony import */ var _reproducer_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(37055);
 /* harmony import */ var _proof_tier_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(40216);
 // Proof orchestration: finding + revision + reproducer + policy -> structured evidence.

package/dist/83.index.js

@@ -0,0 +1,159 @@
+export const id = 83;
+export const ids = [83];
+export const modules = {
+
+/***/ 20083:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   EDGE_STATES: () => (/* binding */ EDGE_STATES),
+/* harmony export */   deriveEdgeStates: () => (/* binding */ deriveEdgeStates),
+/* harmony export */   identitiesUsingRiskyPaths: () => (/* binding */ identitiesUsingRiskyPaths),
+/* harmony export */   runtimeFlowsAbsentFromStatic: () => (/* binding */ runtimeFlowsAbsentFromStatic),
+/* harmony export */   validateExploitEvidence: () => (/* binding */ validateExploitEvidence)
+/* harmony export */ });
+// Edge states and the identity-aware / absent-from-static queries of the Runtime-Corroborated Security Twin (PRD 2: "Edge States",
+// section 6). Pure: no fs, no I/O, never throws, never mutates the graph. It READS what `observation-correlation.js` and the
+// observation store already hold; it adds no second matching engine and writes nothing into the static graph (the overlay stays an
+// overlay).
+//
+// The six states, and when each is ALLOWED to appear:
+//   STATIC_ONLY                no telemetry was consulted at all (not "nothing seen": nothing was looked at)
+//   RUNTIME_NOT_OBSERVED       telemetry was consulted for this environment/window and no trusted observation maps to the edge.
+//                              Never "unreachable": the window may be short, the exporter partial, the mapping weak.
+//   RUNTIME_OBSERVED           at least one high- or medium-confidence observation maps to the edge
+//   RUNTIME_BLOCKED           observations map to the edge and every decision recorded for them was `denied` (the path was
+//                              attempted and refused); an edge with both allowed and denied observations carries OBSERVED and BLOCKED
+//   RUNTIME_POLICY_VIOLATION   the edge was observed (not only denied) AND a flow through it is `prohibited` by the privacy policy
+//   RUNTIME_EXPLOIT_CORRELATED the edge was observed AND the operator supplied explicit evidence naming this edge/flow/node as the
+//                              target of a proven exploit. Never inferred from observation alone: seeing traffic is not seeing an attack.
+// Low-confidence and ambiguous observations (PRD: "low-confidence observations remain unmatched") never create a state; they are
+// counted in `uncertainObservations` so the weakness is visible instead of silently dropped.
+const EDGE_STATES = Object.freeze(['STATIC_ONLY', 'RUNTIME_NOT_OBSERVED', 'RUNTIME_OBSERVED', 'RUNTIME_BLOCKED', 'RUNTIME_POLICY_VIOLATION', 'RUNTIME_EXPLOIT_CORRELATED']);
+const SEVERITY_ORDER = ['RUNTIME_EXPLOIT_CORRELATED', 'RUNTIME_POLICY_VIOLATION', 'RUNTIME_BLOCKED', 'RUNTIME_OBSERVED', 'RUNTIME_NOT_OBSERVED', 'STATIC_ONLY'];
+const TRUSTED = new Set(['high', 'medium']);
+
+const arr = (v) => (Array.isArray(v) ? v : []);
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+
+/** Operator-supplied exploit evidence: [{ kind, id, edgeId?|flowId?|nodeId? }]. Anything malformed is reported, not trusted. */
+function validateExploitEvidence(list) {
+  const errors = []; const ok = [];
+  if (list === null || list === undefined) return { evidence: [], errors };
+  if (!Array.isArray(list)) return { evidence: [], errors: ['exploit evidence must be an array'] };
+  list.forEach((e, i) => {
+    if (!isObj(e) || typeof e.id !== 'string' || !e.id || !['proof', 'dnr-hunt', 'incident'].includes(e.kind)) { errors.push(`entry ${i}: needs kind (proof|dnr-hunt|incident) and id`); return; }
+    const targets = ['edgeId', 'flowId', 'nodeId'].filter((k) => typeof e[k] === 'string' && e[k]);
+    if (targets.length !== 1) { errors.push(`entry ${i}: name exactly one of edgeId, flowId, nodeId`); return; }
+    ok.push({ kind: e.kind, id: e.id.slice(0, 120), [targets[0]]: e[targets[0]] });
+  });
+  return { evidence: ok, errors };
+}
+
+/**
+ * @returns {{ evaluated: boolean, byNode: Record<string, {states: string[], observations: number, allowed: number, denied: number}>, byEdge: Record<string, {states: string[], primary: string, observations: number, allowed: number, denied: number, uncertainObservations: number, identityTokens: string[], exploitEvidence: object[], note: string}>, counts: Record<string, number>, limitations: string[] }}
+ */
+function deriveEdgeStates(graph, correlation, observations, { exploitEvidence = [] } = {}) {
+  const edges = arr(graph?.edges).filter((e) => isObj(e) && typeof e.id === 'string');
+  const flows = arr(graph?.flows).filter((f) => isObj(f) && typeof f.id === 'string');
+  const evaluated = !!correlation?.evaluated;
+  const considered = new Set(arr(correlation?.consideredObservationIds));
+  const byEdge = {}; const counts = Object.fromEntries(EDGE_STATES.map((s) => [s, 0]));
+  const limitations = [
+    'RUNTIME_NOT_OBSERVED means "no trusted observation in this window", never "unreachable" or "safe".',
+    'Only high- and medium-confidence mappings count; low-confidence and ambiguous observations stay unmatched and are counted as uncertain.',
+    'RUNTIME_EXPLOIT_CORRELATED requires explicit operator-supplied evidence naming the edge, flow or node; observation alone never sets it.',
+  ];
+  const flowsByEdge = new Map();
+  for (const f of flows) for (const eid of arr(f.edgeIds)) { const a = flowsByEdge.get(eid) ?? []; a.push(f); flowsByEdge.set(eid, a); }
+  const obsByEdge = new Map();
+  for (const o of arr(observations)) {
+    if (!isObj(o) || (evaluated && considered.size && !considered.has(o.id))) continue;
+    for (const eid of arr(o.matchedEdgeIds)) { const a = obsByEdge.get(eid) ?? []; a.push(o); obsByEdge.set(eid, a); }
+  }
+  for (const e of edges) {
+    if (!evaluated) { byEdge[e.id] = entry(['STATIC_ONLY'], { note: 'no telemetry was consulted' }); counts.STATIC_ONLY++; continue; }
+    const all = obsByEdge.get(e.id) ?? [];
+    const trusted = all.filter((o) => TRUSTED.has(o.matchConfidence));
+    const uncertain = all.length - trusted.length;
+    if (!trusted.length) { byEdge[e.id] = entry(['RUNTIME_NOT_OBSERVED'], { uncertain, note: uncertain ? `${uncertain} low-confidence observation(s) not counted` : 'no observation in this window' }); counts.RUNTIME_NOT_OBSERVED++; continue; }
+    const dec = (o) => o.attributes?.['network.securityDecision'];
+    const allowed = trusted.filter((o) => dec(o) === 'allowed').length; const denied = trusted.filter((o) => dec(o) === 'denied').length;
+    const states = [];
+    const onlyDenied = denied > 0 && allowed === 0 && trusted.every((o) => dec(o) === 'denied');
+    if (!onlyDenied) states.push('RUNTIME_OBSERVED');
+    if (denied > 0) states.push('RUNTIME_BLOCKED');
+    const prohibited = flowsByEdge.get(e.id)?.some((f) => f.policyVerdict === 'prohibited');
+    if (!onlyDenied && prohibited) states.push('RUNTIME_POLICY_VIOLATION');
+    const flowIds = new Set((flowsByEdge.get(e.id) ?? []).map((f) => f.id));
+    const nodeIds = new Set([e.source, e.target, e.from, e.to].filter(Boolean));
+    const ev = arr(exploitEvidence).filter((x) => x.edgeId === e.id || (x.flowId && flowIds.has(x.flowId)) || (x.nodeId && nodeIds.has(x.nodeId)));
+    if (!onlyDenied && ev.length) states.push('RUNTIME_EXPLOIT_CORRELATED');
+    const tokens = [...new Set(trusted.map((o) => o.attributes?.['identity.token']).filter(Boolean))].sort();
+    byEdge[e.id] = entry(states, { observations: trusted.length, allowed, denied, uncertain, tokens, ev, note: '' });
+    for (const s of states) counts[s]++;
+  }
+  // Observations the matcher placed on a NODE but on no edge or flow (a queue publish, a store write with no modelled path into it).
+  // They still carry the allow/deny fact, so the refused queue publish is visible instead of vanishing between edge and node.
+  const byNode = {};
+  if (evaluated) {
+    const perNode = new Map();
+    for (const o of arr(observations)) {
+      if (!isObj(o) || (considered.size && !considered.has(o.id)) || !TRUSTED.has(o.matchConfidence) || arr(o.matchedEdgeIds).length) continue;
+      for (const nid of arr(o.matchedNodeIds)) { const a = perNode.get(nid) ?? []; a.push(o); perNode.set(nid, a); }
+    }
+    for (const [nid, list] of perNode) {
+      const dec = (o) => o.attributes?.['network.securityDecision'];
+      const denied = list.filter((o) => dec(o) === 'denied').length; const allowed = list.filter((o) => dec(o) === 'allowed').length;
+      const onlyDenied = denied > 0 && denied === list.length;
+      byNode[nid] = { states: [...(onlyDenied ? [] : ['RUNTIME_OBSERVED']), ...(denied ? ['RUNTIME_BLOCKED'] : [])], observations: list.length, allowed, denied };
+    }
+  }
+  return { evaluated, byEdge, byNode, counts, limitations };
+
+  function entry(states, { observations = 0, allowed = 0, denied = 0, uncertain = 0, tokens = [], ev = [], note = '' } = {}) {
+    const primary = SEVERITY_ORDER.find((s) => states.includes(s));
+    return { states, primary, observations, allowed, denied, uncertainObservations: uncertain, identityTokens: tokens, exploitEvidence: ev, note };
+  }
+}
+
+/**
+ * "Show runtime flows absent from the static graph": the observations the matcher could NOT place on any static node, reduced to the
+ * destination identifiers the closed-world schema already allows. These are CANDIDATES. The matcher failing to place an observation
+ * can mean a path the static analysis missed, or a mapping the matcher is too weak to make; this lists them, it does not decide.
+ */
+function runtimeFlowsAbsentFromStatic(observations, correlation) {
+  const unmatched = new Set(arr(correlation?.unmatchedObservationIds));
+  const rows = [];
+  for (const o of arr(observations)) {
+    if (!isObj(o) || !unmatched.has(o.id)) continue;
+    // an observation the matcher placed on a static NODE is not absent from the static graph; it only lacks a modelled flow
+    if (arr(o.matchedNodeIds).length || arr(o.matchedEdgeIds).length) continue;
+    const a = isObj(o.attributes) ? o.attributes : {};
+    const dest = ['destination.host', 'destination.service', 'destination.port', 'destination.scheme'].filter((k) => a[k] !== undefined).map((k) => `${k.split('.')[1]}=${a[k]}`).join(' ');
+    if (!dest) continue;
+    rows.push({ observationId: o.id, destination: dest, service: a['service.name'] ?? null, environment: o.environment ?? null, firstObservedAt: o.firstObservedAt ?? null, lastObservedAt: o.lastObservedAt ?? null, eventCountBand: o.eventCountBand ?? null });
+  }
+  rows.sort((x, y) => (x.destination < y.destination ? -1 : x.destination > y.destination ? 1 : 0));
+  return { candidates: rows, note: 'Unmatched observations are candidates, not proof that static analysis missed a path: the matcher may be too weak to place them.' };
+}
+
+/** "Show identities using risky paths": identity TOKENS (never identities) seen on edges in the risky states, with a band, never an exact count. */
+function identitiesUsingRiskyPaths(edgeStates) {
+  const risky = new Set(['RUNTIME_POLICY_VIOLATION', 'RUNTIME_EXPLOIT_CORRELATED']);
+  const byToken = new Map();
+  for (const [edgeId, e] of Object.entries(edgeStates?.byEdge ?? {})) {
+    if (!e.states.some((s) => risky.has(s))) continue;
+    for (const t of e.identityTokens) { const x = byToken.get(t) ?? { token: t, edges: [], states: new Set() }; x.edges.push(edgeId); e.states.filter((s) => risky.has(s)).forEach((s) => x.states.add(s)); byToken.set(t, x); }
+  }
+  return {
+    identities: [...byToken.values()].map((x) => ({ token: x.token, edgeIds: x.edges.sort(), states: [...x.states].sort() })).sort((a, b) => (a.token < b.token ? -1 : 1)),
+    note: 'Tokens are keyed hashes under this install\'s key; they identify "the same identity" but never reveal who. Edges with no identity telemetry contribute nothing, which is not evidence that no identity used them.',
+  };
+}
+
+
+/***/ })
+
+};

package/dist/8551.index.js

@@ -0,0 +1,82 @@
+export const id = 8551;
+export const ids = [8551];
+export const modules = {
+
+/***/ 58551:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   hasTamperedRecords: () => (/* binding */ hasTamperedRecords),
+/* harmony export */   latestRecord: () => (/* binding */ latestRecord),
+/* harmony export */   listRecords: () => (/* binding */ listRecords),
+/* harmony export */   saveRecord: () => (/* binding */ saveRecord)
+/* harmony export */ });
+/* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73024);
+/* harmony import */ var node_path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(76760);
+/* harmony import */ var _state_dir_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(31174);
+/* harmony import */ var _encryption_provider_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(39984);
+/* harmony import */ var _proof_fabric_reproducer_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(37055);
+/* harmony import */ var _proof_fabric_store_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(62199);
+// Persistence for the detection-and-response loop: `.agentic-security/dnr/<findingKey>/<kind>-<digest>.json`.
+// Same machinery and the same guarantees as the proof store, reused rather than copied where it is exported:
+// safe state-directory writes (no symlinks, no unsafe dirs), the encryption policy, retention as evidence, legal holds, and
+// a recursive secret scrub before anything touches disk. A record that no longer matches its own digest is returned FLAGGED,
+// never trusted and never silently dropped.
+
+
+
+
+
+
+
+const DIR = 'dnr';
+const MAX_RECORD_BYTES = 1024 * 1024;
+const RECORD_KINDS = Object.freeze(['detection', 'hunt', 'window', 'fix']);
+
+const digestOf = (record) => { const { recordDigest: _omit, ...rest } = record; return (0,_proof_fabric_reproducer_js__WEBPACK_IMPORTED_MODULE_4__/* .sha256 */ .sc)((0,_proof_fabric_reproducer_js__WEBPACK_IMPORTED_MODULE_4__/* .canonicalize */ .dw)(rest)); };
+
+function saveRecord(root, findingId, kind, record) {
+  if (!RECORD_KINDS.includes(kind)) return { ok: false, reason: `unknown record kind: ${kind}` };
+  const safe = (0,_proof_fabric_store_js__WEBPACK_IMPORTED_MODULE_5__.scrubDeep)(record);
+  safe.schema = `agentic-security/dnr-${kind}-record`;
+  safe.kind = kind;
+  safe.findingId = String(findingId);
+  safe.savedAt = record.savedAt ?? new Date().toISOString();
+  safe.recordDigest = digestOf(safe);
+  const text = JSON.stringify(safe, null, 2);
+  if (Buffer.byteLength(text) > MAX_RECORD_BYTES) return { ok: false, reason: 'record exceeds the size limit' };
+  if (!(0,_state_dir_js__WEBPACK_IMPORTED_MODULE_2__.ensureStateDir)(root)) return { ok: false, reason: 'no safe state directory for this project' };
+  const enc = (0,_encryption_provider_js__WEBPACK_IMPORTED_MODULE_3__/* .maybeEncryptForWrite */ .v2)(root, DIR, text);
+  if (!enc.ok) return { ok: false, reason: enc.reason };
+  const file = (0,_state_dir_js__WEBPACK_IMPORTED_MODULE_2__.statePath)(root, DIR, (0,_proof_fabric_store_js__WEBPACK_IMPORTED_MODULE_5__.findingKey)(findingId), `${kind}-${safe.recordDigest.slice(0, 16)}.json`);
+  if (!(0,_state_dir_js__WEBPACK_IMPORTED_MODULE_2__.safeWriteState)(file, enc.content)) return { ok: false, reason: 'state write refused' };
+  return { ok: true, file, digest: safe.recordDigest, encrypted: enc.encrypted };
+}
+
+/** Newest-first records of one kind for a finding. Tampered records are flagged. */
+function listRecords(root, findingId, kind) {
+  const dir = (0,_state_dir_js__WEBPACK_IMPORTED_MODULE_2__.statePath)(root, DIR, (0,_proof_fabric_store_js__WEBPACK_IMPORTED_MODULE_5__.findingKey)(findingId));
+  let names = [];
+  try { names = node_fs__WEBPACK_IMPORTED_MODULE_0__.readdirSync(dir).filter((n) => n.startsWith(`${kind}-`) && n.endsWith('.json')); } catch { return []; }
+  const out = [];
+  for (const n of names) {
+    const file = node_path__WEBPACK_IMPORTED_MODULE_1__.join(dir, n);
+    try {
+      const rec = JSON.parse((0,_encryption_provider_js__WEBPACK_IMPORTED_MODULE_3__.maybeDecryptForRead)(node_fs__WEBPACK_IMPORTED_MODULE_0__.readFileSync(file, 'utf8')));
+      out.push({ file, record: rec, tampered: rec.recordDigest !== digestOf(rec), mtime: node_fs__WEBPACK_IMPORTED_MODULE_0__.statSync(file).mtimeMs });
+    } catch { out.push({ file, record: null, tampered: true, mtime: 0 }); }
+  }
+  return out.sort((a, b) => b.mtime - a.mtime);
+}
+
+/** Newest intact record of a kind, or null. A tampered newest record does NOT fall through silently: the caller can see it via listRecords. */
+function latestRecord(root, findingId, kind) {
+  return listRecords(root, findingId, kind).find((r) => r.record && !r.tampered) ?? null;
+}
+const hasTamperedRecords = (root, findingId, kind) => listRecords(root, findingId, kind).some((r) => r.tampered);
+
+
+/***/ })
+
+};

package/dist/8633.index.js

@@ -0,0 +1,93 @@
+export const id = 8633;
+export const ids = [8633];
+export const modules = {
+
+/***/ 98633:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   EngineError: () => (/* binding */ EngineError),
+/* harmony export */   saveFromEngine: () => (/* binding */ saveFromEngine)
+/* harmony export */ });
+/* unused harmony export ENGINE_LIMITS */
+/* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73024);
+/* harmony import */ var node_os__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(48161);
+/* harmony import */ var node_path__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(76760);
+/* harmony import */ var node_child_process__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(31421);
+// Read an image from a LOCAL container engine (`docker save` / `podman save`), for `image scan --engine <name>` (PRD 5, requirement 1:
+// "local image"). The engine produces a docker-archive tar, which then goes through the same hardened parser as any other archive.
+//
+// Nothing here runs the image: `save` only exports it. The engine is a process like any other in this codebase, so it has what the
+// shared contract asks of one: a timeout, cancellation, process-group cleanup, and a byte cap on what it may produce. The cap
+// matters because the output is streamed to a temporary file and counted as it arrives: an engine (or a mislabelled "engine") that
+// writes without end is stopped at the cap instead of filling the disk. The temporary file is removed on every exit path.
+
+
+
+
+
+class EngineError extends Error {
+  constructor(message, code) { super(message); this.name = 'EngineError'; this.code = code; }
+}
+
+const ENGINE_LIMITS = Object.freeze({ timeoutMs: 5 * 60_000, maxBytes: 2 * 1024 * 1024 * 1024 });
+const RUNTIMES = Object.freeze(['docker', 'podman']);
+// a reference, never an option: it must start with a letter or digit, so it can never be read as a flag
+const REF_RE = /^[A-Za-z0-9][A-Za-z0-9._\/:@+-]{0,254}$/;
+
+function findTool(name, pathEnv = process.env.PATH || '') {
+  for (const dir of pathEnv.split(node_path__WEBPACK_IMPORTED_MODULE_2__.delimiter)) {
+    if (!dir) continue;
+    const p = node_path__WEBPACK_IMPORTED_MODULE_2__.join(dir, name);
+    try { node_fs__WEBPACK_IMPORTED_MODULE_0__.accessSync(p, node_fs__WEBPACK_IMPORTED_MODULE_0__.constants.X_OK); if (node_fs__WEBPACK_IMPORTED_MODULE_0__.statSync(p).isFile()) return node_fs__WEBPACK_IMPORTED_MODULE_0__.realpathSync(p); } catch { /* next */ }
+  }
+  return null;
+}
+
+function saveFromEngine(ref, { runtime = 'docker', limits = ENGINE_LIMITS, signal = null, pathEnv = process.env.PATH } = {}) {
+  const L = { ...ENGINE_LIMITS, ...limits };
+  if (!RUNTIMES.includes(runtime)) return Promise.reject(new EngineError(`the container engine must be one of ${RUNTIMES.join(', ')}`, 'bad_runtime'));
+  if (!REF_RE.test(String(ref ?? '')) || String(ref).includes('..')) return Promise.reject(new EngineError('not a valid image reference', 'bad_reference'));
+  const bin = findTool(runtime, pathEnv);
+  if (!bin) return Promise.reject(new EngineError(`${runtime} is not installed or not on PATH; nothing was read`, 'engine_unavailable'));
+  const dir = node_fs__WEBPACK_IMPORTED_MODULE_0__.mkdtempSync(node_path__WEBPACK_IMPORTED_MODULE_2__.join(node_os__WEBPACK_IMPORTED_MODULE_1__.tmpdir(), 'engine-save-'));
+  const file = node_path__WEBPACK_IMPORTED_MODULE_2__.join(dir, 'image.tar');
+  const cleanup = () => { try { node_fs__WEBPACK_IMPORTED_MODULE_0__.rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ } };
+  return new Promise((resolve, reject) => {
+    const out = node_fs__WEBPACK_IMPORTED_MODULE_0__.createWriteStream(file, { mode: 0o600 });
+    out.on('error', (e) => fail(new EngineError(`could not write the export: ${e.code ?? e.message}`, 'engine_error')));
+    const child = (0,node_child_process__WEBPACK_IMPORTED_MODULE_3__.spawn)(bin, ['save', ref], { detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    let bytes = 0; let stderr = ''; let settled = false; let reason = null;
+    const kill = () => { try { process.kill(-child.pid, 'SIGKILL'); } catch { try { child.kill('SIGKILL'); } catch { /* gone */ } } };
+    const fail = (e) => { if (settled) return; settled = true; clearTimeout(timer); signal?.removeEventListener('abort', onAbort); kill(); out.destroy(); cleanup(); reject(e); };
+    const timer = setTimeout(() => { reason = 'timeout'; fail(new EngineError(`${runtime} save did not finish within ${Math.round(L.timeoutMs / 1000)}s`, 'timeout')); }, L.timeoutMs);
+    const onAbort = () => fail(new EngineError('cancelled', 'cancelled'));
+    if (signal) { if (signal.aborted) { onAbort(); return; } signal.addEventListener('abort', onAbort, { once: true }); }
+    child.stdout.on('data', (d) => {
+      if (settled) return;
+      bytes += d.length;
+      if (bytes > L.maxBytes) { fail(new EngineError(`the image export is larger than ${L.maxBytes} bytes`, 'too_large')); return; }
+      out.write(d);
+    });
+    child.stderr.on('data', (d) => { if (stderr.length < 4096) stderr += d; });
+    child.on('error', (e) => fail(new EngineError(`could not start ${runtime}: ${e.code ?? e.message}`, 'engine_unavailable')));
+    child.on('close', (code) => {
+      if (settled) return;
+      out.end(() => {
+        if (settled) return;
+        if (code !== 0) return fail(new EngineError(`${runtime} save failed: ${stderr.trim().split('\n').pop()?.slice(0, 200) || `exit ${code}`}`, /no such image|not found|unable to find/i.test(stderr) ? 'not_found' : 'engine_error'));
+        try {
+          const buf = node_fs__WEBPACK_IMPORTED_MODULE_0__.readFileSync(file);
+          settled = true; clearTimeout(timer); signal?.removeEventListener('abort', onAbort); cleanup();
+          resolve({ tar: buf, source: { kind: 'engine', runtime, reference: ref, bytes: buf.length } });
+        } catch (e) { fail(new EngineError(`could not read the exported image: ${e.code ?? e.message}`, 'engine_error')); }
+      });
+    });
+    void reason;
+  });
+}
+
+
+/***/ })
+
+};

package/dist/8714.index.js

@@ -2,94 +2,94 @@ export const id = 8714;
 export const ids = [8714];
 export const modules = {
 
-/***/ 78714:
+/***/ 58714:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   persistLanguageArtifacts: () => (/* binding */ persistLanguageArtifacts)
+/* harmony export */   renderRuntimeExplorer: () => (/* binding */ renderRuntimeExplorer),
+/* harmony export */   vulnerableFunctionsInProduction: () => (/* binding */ vulnerableFunctionsInProduction)
 /* harmony export */ });
-/* unused harmony exports LANGUAGE_ANALYSIS_FILE, LANGUAGE_BOM_FILE, LANGUAGE_ARTIFACT_SCHEMA, hasLanguageContent, buildLanguageArtifacts */
-/* harmony import */ var node_crypto__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(77598);
-/* harmony import */ var _posture_state_dir_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(31174);
-/* harmony import */ var _posture_integrity_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(71130);
-/* harmony import */ var _context_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(52603);
-// Haskell and Nix analysis metadata as registered state artifacts (X-016).
+// The runtime half of the Data Flow Explorer as ONE static, script-free HTML page (PRD 2 section 5). Pure: it renders what
+// `runtime-edge-states.js` and the correlation already computed, writes nothing, and runs nothing in the browser. It exists as a page
+// rather than a route on the local explore server because that server's contract (`server/CLAUDE.md`) deliberately serves only the
+// signed static graph; widening it is a security decision of its own. A page needs no server, no token and no script.
 //
-// An ordinary scan already leaves last-scan.json. Two things a reviewer, auditor or retention policy needs about the
-// Haskell/Nix side were not artifacts of their own: WHAT analysed the sources (parser/resolver outcomes, capability
-// status, limitations, optional modes) and WHICH components the language BOM recorded. They are written beside
-// last-scan.json as `language-analysis.json` and `language-bom.json`, each with a detached signature, registered in
-// posture/artifact-registry.js (so export, retention, legal hold and `reset` all see them), and described by a record
-// that carries sha256 digests of every input and of the artifact bodies. No source text is ever written: paths and
-// digests only, so the file is metadata, not a copy of customer code.
-
-
-
-
-
+// Five views, in the order the PRD names them: Static, Runtime, Static vs Runtime, Observed High-Risk Paths, Unexpected Runtime Paths.
+// Clicking (expanding) an edge shows BOTH its static evidence and its runtime evidence. Every flow is also shown as a path
+// ("source -> ... -> sink") with the state of each hop, which is the PRD's "credit-card field -> API -> payments service -> DB" view.
+//
+// Everything interpolated into the page is escaped. Attribute values (hosts, services) came from telemetry the operator supplied and
+// are treated as hostile text. The page states, at the top, what absence of observation does and does not mean.
+const esc = (v) => String(v ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+const arr = (v) => (Array.isArray(v) ? v : []);
+const SENSITIVE = new Set(['PII', 'PHI', 'PCI', 'FIN', 'CREDENTIALS']);
+const CSS = 'body{font:14px/1.45 system-ui,sans-serif;margin:24px auto;max-width:1100px;padding:0 16px;color:#1b1f24;background:#fff}'
+  + '@media(prefers-color-scheme:dark){body{background:#14171a;color:#e6e8ea}}'
+  + 'table{border-collapse:collapse;width:100%;margin:8px 0}td,th{border:1px solid #8886;padding:4px 8px;text-align:left;vertical-align:top}'
+  + 'summary{cursor:pointer}.s{display:inline-block;padding:0 6px;border-radius:4px;border:1px solid #8888;font-size:12px;margin-right:4px}'
+  + '.RUNTIME_BLOCKED,.RUNTIME_POLICY_VIOLATION,.RUNTIME_EXPLOIT_CORRELATED{border-color:#c0392b;color:#c0392b}.RUNTIME_OBSERVED{border-color:#1e8449;color:#1e8449}'
+  + '.note{border-left:4px solid #8888;padding:4px 12px;margin:12px 0}nav a{margin-right:12px}code{font-size:12px}';
 
-const LANGUAGE_ANALYSIS_FILE = 'language-analysis.json';
-const LANGUAGE_BOM_FILE = 'language-bom.json';
-const LANGUAGE_ARTIFACT_SCHEMA = 'agentic-security/language-analysis@1';
+function renderRuntimeExplorer({ graph, edgeStates, correlation, observations = [], absent = { candidates: [] }, title = 'Runtime twin' }) {
+  const nodes = new Map(arr(graph?.nodes).map((n) => [n.id, n]));
+  const edges = arr(graph?.edges); const flows = arr(graph?.flows);
+  const dataEls = new Map(arr(graph?.dataElements).map((d) => [d.id, d]));
+  const label = (id) => esc(nodes.get(id)?.label ?? id);
+  const stateOf = (eid) => edgeStates?.byEdge?.[eid];
+  const obsByEdge = new Map();
+  for (const o of arr(observations)) for (const eid of arr(o.matchedEdgeIds)) { const a = obsByEdge.get(eid) ?? []; a.push(o); obsByEdge.set(eid, a); }
+  const chips = (states) => arr(states).map((s) => `<span class="s ${esc(s)}">${esc(s)}</span>`).join('');
+  const flowClasses = (f) => arr(f.dataElementIds).flatMap((id) => arr(dataEls.get(id)?.dataClasses));
+  const observedEdge = (eid) => stateOf(eid)?.states?.includes('RUNTIME_OBSERVED');
 
-const sha256 = (s) => node_crypto__WEBPACK_IMPORTED_MODULE_0__.createHash('sha256').update(s).digest('hex');
-function canonical(v) {
-  if (Array.isArray(v)) return `[${v.map(canonical).join(',')}]`;
-  if (v && typeof v === 'object') return `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${canonical(v[k])}`).join(',')}}`;
-  return JSON.stringify(v === undefined ? null : v);
-}
+  const staticRows = edges.map((e) => `<tr><td>${label(e.from)} &rarr; ${label(e.to)}</td><td><code>${esc(e.id)}</code></td><td>${esc(e.protocol?.name ?? e.protocol?.kind ?? '')}</td><td>${esc(arr(e.boundaryCrossings).join(', '))}</td></tr>`).join('');
+  const runtimeRows = edges.map((e) => { const s = stateOf(e.id); return `<tr><td>${label(e.from)} &rarr; ${label(e.to)}</td><td>${chips(s?.states)}</td><td>${s?.observations ?? 0}</td><td>${esc(s?.identityTokens?.length ?? 0)}</td></tr>`; }).join('');
+  const bothRows = edges.map((e) => { const s = stateOf(e.id); return `<tr><td>${label(e.from)} &rarr; ${label(e.to)}</td><td>${esc(arr(e.boundaryCrossings).length ? 'crosses a boundary' : 'internal')}, ${esc(e.provenance ?? '')}</td><td>${chips(s?.states)}${s?.uncertainObservations ? ` <small>(${s.uncertainObservations} uncertain, not counted)</small>` : ''}</td></tr>`; }).join('');
 
-/** True when the scan has anything Haskell/Nix to record. */
-function hasLanguageContent(scan) {
-  const lc = scan && scan.scanHealth && scan.scanHealth.languageCoverage;
-  const files = lc && lc.totals && Number(lc.totals.files || lc.totals.analyzed || 0);
-  return !!((lc && (files > 0 || (lc.capabilities && Object.keys(lc.capabilities).length))) || (scan && scan.languageBom && (scan.languageBom.components || []).length));
-}
+  const detail = (e) => {
+    const s = stateOf(e.id); const obs = obsByEdge.get(e.id) ?? [];
+    const o = obs.map((x) => `<li>${esc(x.adapter)} / ${esc(x.environment ?? 'no environment')}: ${esc(x.firstObservedAt)} to ${esc(x.lastObservedAt)}, count band ${esc(x.eventCountBand)}, match ${esc(x.matchMethod)} (${esc(x.matchConfidence)})${x.attributes?.['network.securityDecision'] ? `, decision ${esc(x.attributes['network.securityDecision'])}` : ''}${x.attributes?.['identity.token'] ? `, identity <code>${esc(x.attributes['identity.token'])}</code>` : ''}</li>`).join('');
+    return `<details><summary>${label(e.from)} &rarr; ${label(e.to)} ${chips(s?.states)}</summary>`
+      + `<h4>Static evidence</h4><p><code>${esc(e.id)}</code>, provenance ${esc(e.provenance)}, coverage ${esc(e.coverageStatus)}; boundaries: ${esc(arr(e.boundaryCrossings).join(', ') || 'none')}; evidence: ${esc(arr(e.evidenceRefs).join(', ') || 'none')}</p>`
+      + `<h4>Runtime evidence</h4>${obs.length ? `<ul>${o}</ul>` : `<p>${esc(s?.note || 'none')}</p>`}</details>`;
+  };
 
-/**
- * The analysis record for `scan`, plus the BOM body. `inputs` is [{path, sha256}] over the Haskell/Nix sources and
- * manifests (digests only). Pure: no I/O.
- */
-function buildLanguageArtifacts(scan, inputs = []) {
-  const lc = (scan && scan.scanHealth && scan.scanHealth.languageCoverage) || null;
-  const bom = (scan && scan.languageBom) || null;
-  const bridges = (scan && scan.languageBridges) || null;
-  const bomBody = bom ? JSON.stringify(bom, null, 2) : null;
-  const record = {
-    schema: LANGUAGE_ARTIFACT_SCHEMA,
-    classification: { class: 'scan-metadata', containsSourceText: false, containsSecrets: false },
-    inputs: inputs.map((i) => ({ path: String(i.path), sha256: String(i.sha256) })).sort((a, b) => (a.path < b.path ? -1 : 1)),
-    analysis: lc ? { totals: lc.totals, byKind: lc.byKind, conditions: lc.conditions, limitations: lc.limitations, capabilities: lc.capabilities, optionalModes: lc.optionalModes } : null,
-    bom: bom ? { file: LANGUAGE_BOM_FILE, sha256: sha256(bomBody), components: (bom.components || []).length } : null,
-    bridges: bridges ? { sha256: sha256(canonical(bridges)) } : null,
+  const pathRow = (f) => {
+    const hops = arr(f.edgeIds).map((eid) => { const e = edges.find((x) => x.id === eid); return e ? `${label(e.from)} &rarr; ${label(e.to)} ${chips(stateOf(eid)?.states)}` : esc(eid); });
+    return `<tr><td>${esc(arr(f.dataElementIds).map((id) => dataEls.get(id)?.label ?? id).join(', '))}<br><small>${esc(flowClasses(f).join(', '))}</small></td><td>${hops.join('<br>') || '(no modelled hops)'}</td><td>${esc(f.policyVerdict)}</td></tr>`;
   };
-  return { record, bomBody };
+  const highRisk = flows.filter((f) => arr(f.edgeIds).some(observedEdge) && (flowClasses(f).some((c) => SENSITIVE.has(c)) || f.policyVerdict === 'prohibited' || arr(f.edgeIds).some((eid) => arr(edges.find((e) => e.id === eid)?.boundaryCrossings).length)));
+  const blockedNodes = Object.entries(edgeStates?.byNode ?? {});
+  const unexpected = [
+    ...arr(absent.candidates).map((c) => `<tr><td>${esc(c.destination)}</td><td>observed, not placed on any static node</td><td>${esc(c.firstObservedAt)} to ${esc(c.lastObservedAt)}</td></tr>`),
+    ...blockedNodes.filter(([, n]) => n.states.includes('RUNTIME_BLOCKED')).map(([id, n]) => `<tr><td>${label(id)}</td><td>attempted and refused (${n.denied} denied)</td><td></td></tr>`),
+  ];
+  const section = (id, h, body) => `<section id="${id}"><h2>${h}</h2>${body}</section>`;
+  const table = (head, rows, empty) => (rows.length ? `<table><tr>${head.map((h) => `<th>${h}</th>`).join('')}</tr>${rows.join('')}</table>` : `<p>${esc(empty)}</p>`);
+  const body = [
+    `<h1>${esc(title)}</h1>`,
+    `<div class="note">${edgeStates?.evaluated ? 'Telemetry was consulted.' : '<strong>No telemetry was consulted:</strong> every edge is STATIC_ONLY. That is not evidence that nothing happens at runtime.'} <strong>Not observed does not mean unreachable or safe.</strong> Only high- and medium-confidence mappings are counted. Telemetry values shown are metadata only; identities appear only as keyed-hash tokens.</div>`,
+    '<nav><a href="#static">Static</a><a href="#runtime">Runtime</a><a href="#both">Static vs Runtime</a><a href="#risk">Observed high-risk paths</a><a href="#unexpected">Unexpected runtime paths</a><a href="#paths">Flow paths</a><a href="#edges">Edge detail</a></nav>',
+    section('static', 'Static', table(['Edge', 'Id', 'Protocol', 'Boundaries'], staticRows ? [staticRows] : [], 'No static edges.')),
+    section('runtime', 'Runtime', table(['Edge', 'State', 'Trusted observations', 'Identity tokens'], runtimeRows ? [runtimeRows] : [], 'No edges.')),
+    section('both', 'Static vs Runtime', table(['Edge', 'Static', 'Runtime'], bothRows ? [bothRows] : [], 'No edges.')),
+    section('risk', 'Observed high-risk paths', table(['Data', 'Path and state per hop', 'Policy'], highRisk.map(pathRow), 'No observed flow is sensitive, policy-prohibited or boundary-crossing. This is a statement about the telemetry window, not about the system.')),
+    section('unexpected', 'Unexpected runtime paths', table(['Destination or node', 'What was seen', 'When'], unexpected, 'Nothing unplaced or refused. Unplaced observations are candidates, not proof static analysis missed a path.')),
+    section('paths', 'Flow paths', table(['Data', 'Path and state per hop', 'Policy'], flows.map(pathRow), 'No flows.')),
+    section('edges', 'Edge detail (expand an edge for its static and runtime evidence)', edges.map(detail).join('') || '<p>No edges.</p>'),
+  ].join('\n');
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'"><title>${esc(title)}</title><style>${CSS}</style></head><body>${body}</body></html>\n`;
 }
 
-/**
- * Writes the artifacts under the project's state directory, each with a `.sig`. Returns {written:[{name, sha256}], skipped}.
- * Never throws and never blocks a scan; a project that disallows state writes gets `skipped: 'state-writes-disabled'`.
- */
-function persistLanguageArtifacts(root, scan) {
-  if (!hasLanguageContent(scan)) return { written: [], skipped: 'no-language-content' };
-  let inputs = [];
-  try {
-    const proj = (0,_context_js__WEBPACK_IMPORTED_MODULE_3__.loadLanguageProject)(root);
-    inputs = [...Object.entries(proj.files), ...Object.entries(proj.manifests)].map(([path, text]) => ({ path, sha256: sha256(text) }));
-  } catch { /* the record then says it has no input digests */ }
-  const { record, bomBody } = buildLanguageArtifacts(scan, inputs);
-  const out = [];
-  const put = (name, body) => {
-    const fp = (0,_posture_state_dir_js__WEBPACK_IMPORTED_MODULE_1__.statePath)(root, name);
-    if (!(0,_posture_state_dir_js__WEBPACK_IMPORTED_MODULE_1__.safeWriteState)(fp, body)) return false;
-    try { (0,_posture_state_dir_js__WEBPACK_IMPORTED_MODULE_1__.safeWriteState)(`${fp}.sig`, (0,_posture_integrity_js__WEBPACK_IMPORTED_MODULE_2__/* .signLastScan */ .lU)(body)); } catch { /* the signature is best effort, as for last-scan.json */ }
-    out.push({ name, sha256: sha256(body) });
-    return true;
-  };
-  const body = JSON.stringify(record, null, 2);
-  if (!put(LANGUAGE_ANALYSIS_FILE, body)) return { written: [], skipped: 'state-writes-disabled' };
-  if (bomBody) put(LANGUAGE_BOM_FILE, bomBody);
-  return { written: out, skipped: null };
+/** "Show vulnerable functions actually exercised in production": scan findings whose own path appears in the runtime trace. Expects findings already
+ * annotated by `posture/runtime-correlation.js`; it adds no matching of its own. */
+function vulnerableFunctionsInProduction(findings) {
+  const list = arr(findings).filter((f) => f && typeof f === 'object');
+  const withEvidence = list.filter((f) => f.runtimeEvidence);
+  if (!withEvidence.some((f) => f.runtimeEvidence.state !== 'unknown')) return { evaluated: false, reason: 'no runtime trace could be evaluated (none present, or it says nothing about any finding): put one at .agentic-security/runtime-trace.jsonl (or set AGENTIC_SECURITY_RUNTIME_TRACE_PATH). This is not "no vulnerable function ran".' };
+  const observed = withEvidence.filter((f) => f.runtimeEvidence.state === 'observed').map((f) => ({ id: f.id, severity: f.severity, vuln: f.vuln, file: f.file, line: f.line, cwe: f.cwe, basis: f.runtimeEvidence.basis, sampling: f.runtimeEvidence.sampling?.state ?? null }));
+  const counts = { observed: observed.length, notObservedInWindow: withEvidence.filter((f) => f.runtimeEvidence.state === 'not_observed_in_window').length, unknown: withEvidence.filter((f) => f.runtimeEvidence.state === 'unknown').length };
+  return { evaluated: true, findings: observed, counts, note: 'A finding listed here has a function, line or route on its path in the trace. A finding not listed may still run: counts show how many were not observed or unknown. Absence of observation is a statement about the window and the instrumentation, not about reachability.' };
 }