@clear-capabilities/agentic-security-scanner 0.79.0 → 0.84.1

package/dist/178.index.js

@@ -13,7 +13,7 @@ export const modules = {
 /* harmony import */ var node_child_process__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1421);
 /* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3024);
 /* harmony import */ var node_path__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6760);
-/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6048);
+/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(2271);
 // Time-travel + counterfactual scanning (v0.68).
 //
 // Two new modes that exploit the pure-input shape of runFullScan:

package/dist/333.index.js

@@ -0,0 +1,283 @@
+export const id = 333;
+export const ids = [333];
+export const modules = {
+
+/***/ 5333:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   applyScaUpgrade: () => (/* binding */ applyScaUpgrade),
+/* harmony export */   planScaUpgrade: () => (/* binding */ planScaUpgrade)
+/* harmony export */ });
+/* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3024);
+/* harmony import */ var node_fs_promises__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1455);
+/* harmony import */ var node_path__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6760);
+/* harmony import */ var node_crypto__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(7598);
+/* harmony import */ var node_child_process__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(1421);
+/* harmony import */ var node_util__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(7975);
+/* harmony import */ var _state_dir_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(1174);
+// SCA upgrade engine: dry-run plan + worktree-isolated apply.
+//
+// Phase 3 / Item 5 of the SCA improvement plan. The MCP `apply_fix` path
+// refuses to write manifest files (package.json, *-lock.*, poetry.lock,
+// Cargo.lock, etc.) for safety. SCA findings need a separate path that:
+//   1. Generates an upgrade *plan* via the ecosystem's native dry-run
+//      command (npm install --dry-run, pip install --dry-run, etc.).
+//   2. Applies the upgrade via the package manager itself, with a backup
+//      + test-gate so a peer-dep break or test regression rolls back.
+//
+// Caller pattern: plan first (read-only), inspect the breaking-change
+// flag / peer warnings, then apply with confirm:true.
+
+
+
+
+
+
+
+
+
+const execFileAsync = (0,node_util__WEBPACK_IMPORTED_MODULE_5__.promisify)(node_child_process__WEBPACK_IMPORTED_MODULE_4__.execFile);
+
+// Per-ecosystem command/manifest map. Add ecosystems by extending this
+// table — every other place in the module reads it.
+const ECOSYSTEM = {
+  npm: {
+    manifests: ['package.json', 'package-lock.json'],
+    altManifests: [['yarn.lock'], ['pnpm-lock.yaml']],
+    dryRun: (pkg, ver) => ({ cmd: 'npm', args: ['install', `${pkg}@${ver}`, '--dry-run', '--json'] }),
+    apply:  (pkg, ver) => ({ cmd: 'npm', args: ['install', `${pkg}@${ver}`, '--save'] }),
+    parseDryRun(stdout) {
+      try {
+        const j = JSON.parse(stdout);
+        const peerDeps = Array.isArray(j.warnings) ? j.warnings.filter(w => /peer dep/i.test(w)) : [];
+        const transitiveImpact = (j.added || []).length + (j.updated || []).length + (j.removed || []).length;
+        return { peerDeps, transitiveImpact, rawSummary: { added: (j.added || []).length, updated: (j.updated || []).length, removed: (j.removed || []).length } };
+      } catch { return { peerDeps: [], transitiveImpact: 0, rawSummary: null }; }
+    },
+  },
+  pypi: {
+    manifests: ['requirements.txt', 'pyproject.toml'],
+    altManifests: [['poetry.lock'], ['Pipfile.lock']],
+    dryRun: (pkg, ver) => ({ cmd: 'pip', args: ['install', '--dry-run', `${pkg}==${ver}`] }),
+    apply:  (pkg, ver) => ({ cmd: 'pip', args: ['install', '--upgrade', `${pkg}==${ver}`] }),
+    parseDryRun() {
+      // pip --dry-run output is human-readable; we don't parse it for v1.
+      return { peerDeps: [], transitiveImpact: 0, rawSummary: null };
+    },
+  },
+  cargo: {
+    manifests: ['Cargo.toml', 'Cargo.lock'],
+    altManifests: [],
+    dryRun: (pkg, _ver) => ({ cmd: 'cargo', args: ['update', '--package', pkg, '--dry-run'] }),
+    apply:  (pkg, _ver) => ({ cmd: 'cargo', args: ['update', '--package', pkg] }),
+    parseDryRun() { return { peerDeps: [], transitiveImpact: 0, rawSummary: null }; },
+  },
+  golang: {
+    manifests: ['go.mod', 'go.sum'],
+    altManifests: [],
+    dryRun: (_pkg, _ver) => null,   // `go get` has no dry-run flag; we skip dry-run in v1.
+    apply:  (pkg, ver) => ({ cmd: 'go', args: ['get', `${pkg}@v${ver}`] }),
+    parseDryRun() { return { peerDeps: [], transitiveImpact: 0, rawSummary: null }; },
+  },
+  // Other ecosystems (rubygems, packagist, pub, maven) return a structured
+  // "manual" plan in v1 — no native dry-run + the install side-effects
+  // (gem build artifacts, composer cache) are easier for the user to
+  // confirm interactively.
+};
+
+function _majorVersion(v) {
+  const m = String(v || '').match(/^(\d+)/);
+  return m ? parseInt(m[1], 10) : null;
+}
+
+function _detectTestCommand(scanRoot) {
+  try {
+    const pkg = node_path__WEBPACK_IMPORTED_MODULE_2__.join(scanRoot, 'package.json');
+    if (node_fs__WEBPACK_IMPORTED_MODULE_0__.existsSync(pkg)) {
+      const j = JSON.parse(node_fs__WEBPACK_IMPORTED_MODULE_0__.readFileSync(pkg, 'utf8'));
+      if (j.scripts?.test && !/no test specified/i.test(j.scripts.test)) {
+        return { cmd: 'npm', args: ['test'] };
+      }
+    }
+  } catch {}
+  if (node_fs__WEBPACK_IMPORTED_MODULE_0__.existsSync(node_path__WEBPACK_IMPORTED_MODULE_2__.join(scanRoot, 'Cargo.toml'))) return { cmd: 'cargo', args: ['test'] };
+  if (node_fs__WEBPACK_IMPORTED_MODULE_0__.existsSync(node_path__WEBPACK_IMPORTED_MODULE_2__.join(scanRoot, 'go.mod'))) return { cmd: 'go', args: ['test', './...'] };
+  if (node_fs__WEBPACK_IMPORTED_MODULE_0__.existsSync(node_path__WEBPACK_IMPORTED_MODULE_2__.join(scanRoot, 'pyproject.toml'))) return { cmd: 'pytest', args: [] };
+  return null;
+}
+
+// Produce a structured upgrade plan WITHOUT modifying anything on disk.
+// Safe to call repeatedly; runs the ecosystem's --dry-run command.
+async function planScaUpgrade({ scanRoot, finding }) {
+  if (!finding || finding.type !== 'vulnerable_dep') {
+    return { ok: false, reason: 'not a vulnerable_dep finding' };
+  }
+  const eco = ECOSYSTEM[finding.ecosystem];
+  if (!eco) {
+    return {
+      ok: true,
+      mode: 'manual',
+      reason: `ecosystem '${finding.ecosystem}' has no automated upgrade in v1`,
+      package: finding.name, currentVersion: finding.version,
+      targetVersion: (finding.fixedVersions && finding.fixedVersions[0]) || null,
+      command: null,
+    };
+  }
+  const target = (finding.fixedVersions && finding.fixedVersions[0]) || null;
+  if (!target) {
+    return { ok: false, reason: 'no fixed version in OSV record' };
+  }
+  const isBreaking = (_majorVersion(target) ?? 0) > (_majorVersion(finding.version) ?? 0);
+  const apply = eco.apply(finding.name, target);
+  const dryRunSpec = eco.dryRun(finding.name, target);
+  let peerDeps = [], transitiveImpact = 0, rawSummary = null, dryRunOk = null;
+  if (dryRunSpec) {
+    try {
+      const r = await execFileAsync(dryRunSpec.cmd, dryRunSpec.args, {
+        cwd: scanRoot, timeout: 60_000, maxBuffer: 8 * 1024 * 1024,
+      });
+      const parsed = eco.parseDryRun(r.stdout);
+      peerDeps = parsed.peerDeps;
+      transitiveImpact = parsed.transitiveImpact;
+      rawSummary = parsed.rawSummary;
+      dryRunOk = true;
+    } catch (e) {
+      // Dry-run failed (e.g. peer-dep resolution conflict). Surface the
+      // error structurally so the caller can decide whether to proceed.
+      dryRunOk = false;
+      const stderr = (e && e.stderr) || (e && e.message) || '';
+      peerDeps = /peer dep/i.test(stderr) ? [String(stderr).slice(0, 500)] : [];
+    }
+  }
+  return {
+    ok: true,
+    mode: 'auto',
+    ecosystem: finding.ecosystem,
+    package: finding.name,
+    currentVersion: finding.version,
+    targetVersion: target,
+    isBreaking,
+    command: `${apply.cmd} ${apply.args.join(' ')}`,
+    manifestFiles: eco.manifests,
+    dryRun: { ok: dryRunOk, command: dryRunSpec ? `${dryRunSpec.cmd} ${dryRunSpec.args.join(' ')}` : null, peerDeps, transitiveImpact, rawSummary },
+    testCommand: (() => { const t = _detectTestCommand(scanRoot); return t ? `${t.cmd} ${t.args.join(' ')}` : null; })(),
+  };
+}
+
+// Apply the upgrade. Backs up affected manifests, runs the install, runs
+// the project's test command if detected, and ROLLS BACK on failure.
+// Audit-logged via the MCP audit layer at the call site.
+async function applyScaUpgrade({ scanRoot, finding, runTests = true }) {
+  const plan = await planScaUpgrade({ scanRoot, finding });
+  if (!plan.ok) return { applied: false, reason: plan.reason };
+  if (plan.mode === 'manual') {
+    return { applied: false, reason: plan.reason, plan };
+  }
+  const eco = ECOSYSTEM[finding.ecosystem];
+  const target = plan.targetVersion;
+
+  // Backup pass — record original contents of every relevant manifest so
+  // we can restore on test failure. node_modules / vendor dirs are NOT
+  // backed up (too big); they'll be rebuilt by re-running the install on
+  // restore.
+  const stateDir = (0,_state_dir_js__WEBPACK_IMPORTED_MODULE_6__/* .statePath */ .BQ)(scanRoot, 'sca-upgrade-history');
+  node_fs__WEBPACK_IMPORTED_MODULE_0__.mkdirSync(stateDir, { recursive: true });
+  const upgradeId = node_crypto__WEBPACK_IMPORTED_MODULE_3__.randomBytes(8).toString('hex');
+  const backups = {};
+  for (const mf of eco.manifests) {
+    const abs = node_path__WEBPACK_IMPORTED_MODULE_2__.join(scanRoot, mf);
+    if (!node_fs__WEBPACK_IMPORTED_MODULE_0__.existsSync(abs)) continue;
+    const content = await node_fs_promises__WEBPACK_IMPORTED_MODULE_1__.readFile(abs, 'utf8');
+    const backupPath = node_path__WEBPACK_IMPORTED_MODULE_2__.join(stateDir, `${upgradeId}-${mf.replace(/[\/\\]/g, '_')}.bak`);
+    await node_fs_promises__WEBPACK_IMPORTED_MODULE_1__.writeFile(backupPath, content);
+    backups[mf] = { abs, backupPath };
+  }
+  if (!Object.keys(backups).length) {
+    return { applied: false, reason: `no ${finding.ecosystem} manifest files found in scan root` };
+  }
+
+  // Run the install.
+  const apply = eco.apply(finding.name, target);
+  let installOutput = '';
+  try {
+    const r = await execFileAsync(apply.cmd, apply.args, {
+      cwd: scanRoot, timeout: 300_000, maxBuffer: 16 * 1024 * 1024,
+    });
+    installOutput = (r.stdout || '') + (r.stderr || '');
+  } catch (e) {
+    // Install failed; restore backups (manifests may have been touched).
+    for (const { abs, backupPath } of Object.values(backups)) {
+      try { await node_fs_promises__WEBPACK_IMPORTED_MODULE_1__.copyFile(backupPath, abs); } catch {}
+    }
+    return {
+      applied: false,
+      reason: `install failed: ${(e && e.message) || e}`.slice(0, 600),
+      installOutput: ((e && e.stdout) || '').slice(0, 1500),
+      restored: true,
+      upgradeId,
+    };
+  }
+
+  // Optionally run the project's test command. On failure, restore.
+  let testResult = null;
+  if (runTests) {
+    const test = _detectTestCommand(scanRoot);
+    if (test) {
+      try {
+        const r = await execFileAsync(test.cmd, test.args, {
+          cwd: scanRoot, timeout: 600_000, maxBuffer: 16 * 1024 * 1024,
+        });
+        testResult = { ok: true, command: `${test.cmd} ${test.args.join(' ')}`, output: ((r.stdout || '') + (r.stderr || '')).slice(0, 2000) };
+      } catch (e) {
+        // Tests failed — restore manifests so the working tree is clean.
+        for (const { abs, backupPath } of Object.values(backups)) {
+          try { await node_fs_promises__WEBPACK_IMPORTED_MODULE_1__.copyFile(backupPath, abs); } catch {}
+        }
+        return {
+          applied: false,
+          reason: `tests failed after upgrade: ${(e && e.message) || e}`.slice(0, 300),
+          testOutput: ((e && e.stdout) || '').slice(0, 2000),
+          restored: true,
+          upgradeId,
+        };
+      }
+    }
+  }
+
+  // Success path — write a log entry so the user can audit / undo.
+  const logEntry = {
+    id: upgradeId,
+    timestamp: new Date().toISOString(),
+    ecosystem: finding.ecosystem,
+    package: finding.name,
+    from: finding.version,
+    to: target,
+    backups: Object.fromEntries(Object.entries(backups).map(([k, v]) => [k, v.backupPath])),
+    testResult,
+    isBreaking: plan.isBreaking,
+    finding: { id: finding.id, osvId: finding.osvId, cveAliases: finding.cveAliases },
+  };
+  const logFp = node_path__WEBPACK_IMPORTED_MODULE_2__.join(stateDir, 'log.json');
+  let log = [];
+  try { log = JSON.parse(node_fs__WEBPACK_IMPORTED_MODULE_0__.readFileSync(logFp, 'utf8')); } catch {}
+  log.push(logEntry);
+  node_fs__WEBPACK_IMPORTED_MODULE_0__.writeFileSync(logFp, JSON.stringify(log, null, 2));
+
+  return {
+    applied: true,
+    upgradeId,
+    package: finding.name,
+    from: finding.version,
+    to: target,
+    isBreaking: plan.isBreaking,
+    testResult,
+    installOutput: installOutput.slice(0, 1500),
+  };
+}
+
+
+/***/ })
+
+};

package/dist/384.index.js

@@ -8,7 +8,7 @@ export const modules = {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   scanCredentials: () => (/* reexport safe */ _engine_js__WEBPACK_IMPORTED_MODULE_0__.Sv)
 /* harmony export */ });
-/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6048);
+/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2271);
 // Secrets submodule view of the engine — credential + entropy + TODO scanning.
 
 

package/dist/637.index.js

@@ -10,7 +10,7 @@ export const modules = {
 /* harmony export */   renderPrDeltaText: () => (/* binding */ renderPrDeltaText)
 /* harmony export */ });
 /* harmony import */ var node_child_process__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1421);
-/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6048);
+/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2271);
 // Shadowscan / security-DELTA on PR (v0.72).
 //
 // Most SAST PR-comment integrations show absolute counts — "12 findings

package/dist/838.index.js

@@ -14,7 +14,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var node_child_process__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1421);
 /* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3024);
 /* harmony import */ var node_path__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6760);
-/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6048);
+/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(2271);
 // Closed-loop /fix verification (Sentinel-parity FR-L4-4, FR-L4-5).
 //
 // Given a candidate patch (the new file content + the finding stableId being

package/dist/839.index.js

@@ -0,0 +1,170 @@
+export const id = 839;
+export const ids = [839];
+export const modules = {
+
+/***/ 3839:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   queryFindingsMemory: () => (/* binding */ queryFindingsMemory)
+/* harmony export */ });
+/* unused harmony export _internals */
+/* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3024);
+/* harmony import */ var node_path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6760);
+// Findings memory — natural-language Q&A over the institutional knowledge
+// the scanner has accumulated. Backs the MCP query_findings_memory tool.
+//
+// Sources searched, in this order:
+//
+//   1. .agentic-security/last-scan.json          current findings
+//   2. .agentic-security/triage-memory.jsonl     past wont-fix / FP decisions
+//   3. .agentic-security/scan-history/*.json     prior scans
+//   4. .agentic-security/AGENTS.md               continual-learning narrative
+//
+// Naive keyword matching for v1. Each match has a `score` (count of query
+// terms matched) and a `source` ('finding' | 'triage' | 'history' |
+// 'agents-md'). Returns top-10 by score.
+
+
+
+
+const STATE = '.agentic-security';
+
+function _read(scanRoot, name) {
+  try { return node_fs__WEBPACK_IMPORTED_MODULE_0__.readFileSync(node_path__WEBPACK_IMPORTED_MODULE_1__.join(scanRoot, STATE, name), 'utf8'); } catch { return null; }
+}
+
+function _readJson(scanRoot, name) {
+  const raw = _read(scanRoot, name);
+  if (!raw) return null;
+  try { return JSON.parse(raw); } catch { return null; }
+}
+
+function _terms(query) {
+  return String(query || '').toLowerCase().split(/\s+/).filter(t => t.length >= 2);
+}
+
+function _score(haystack, terms) {
+  const lower = String(haystack || '').toLowerCase();
+  let s = 0;
+  for (const t of terms) if (lower.includes(t)) s++;
+  return s;
+}
+
+function _findingHaystack(f) {
+  return [f.vuln, f.family, f.file, f.severity, f.description, f.cwe, f.id]
+    .filter(Boolean).join(' | ');
+}
+
+function _truncate(s, n = 160) {
+  return String(s || '').replace(/\s+/g, ' ').slice(0, n);
+}
+
+/**
+ * Run a natural-language query over the scanner's accumulated memory.
+ */
+function queryFindingsMemory(scanRoot, query) {
+  const terms = _terms(query);
+  if (!terms.length) return { results: [], count: 0 };
+
+  const results = [];
+
+  // 1. Current findings.
+  const scan = _readJson(scanRoot, 'last-scan.json');
+  if (scan && Array.isArray(scan.findings)) {
+    for (const f of scan.findings) {
+      const hay = _findingHaystack(f);
+      const score = _score(hay, terms);
+      if (!score) continue;
+      results.push({
+        source: 'finding',
+        score,
+        finding_id: f.id || null,
+        severity: f.severity,
+        family: f.family,
+        file: f.file,
+        line: f.line,
+        snippet: _truncate(f.vuln || f.description || f.family),
+      });
+    }
+  }
+
+  // 2. Triage memory (past decisions).
+  const triageRaw = _read(scanRoot, 'triage-memory.jsonl');
+  if (triageRaw) {
+    const lines = triageRaw.split('\n').filter(Boolean);
+    for (const ln of lines) {
+      let entry; try { entry = JSON.parse(ln); } catch { continue; }
+      const hay = [entry.decision, entry.reason, entry.family, entry.vuln, entry.file].join(' ');
+      const score = _score(hay, terms);
+      if (!score) continue;
+      results.push({
+        source: 'triage',
+        score,
+        decision: entry.decision,
+        at: entry.at,
+        family: entry.family,
+        snippet: _truncate(entry.reason || entry.vuln),
+        bucket: entry.bucket,
+      });
+    }
+  }
+
+  // 3. Scan history.
+  try {
+    const histDir = node_path__WEBPACK_IMPORTED_MODULE_1__.join(scanRoot, STATE, 'scan-history');
+    if (node_fs__WEBPACK_IMPORTED_MODULE_0__.existsSync(histDir)) {
+      const files = node_fs__WEBPACK_IMPORTED_MODULE_0__.readdirSync(histDir).filter(f => f.endsWith('.json')).slice(-10);
+      for (const f of files) {
+        try {
+          const hist = JSON.parse(node_fs__WEBPACK_IMPORTED_MODULE_0__.readFileSync(node_path__WEBPACK_IMPORTED_MODULE_1__.join(histDir, f), 'utf8'));
+          if (!Array.isArray(hist.findings)) continue;
+          for (const x of hist.findings.slice(0, 50)) {
+            const hay = _findingHaystack(x);
+            const score = _score(hay, terms);
+            if (!score) continue;
+            results.push({
+              source: 'history',
+              score,
+              from: f.replace(/\.json$/, ''),
+              severity: x.severity,
+              family: x.family,
+              file: x.file,
+              snippet: _truncate(x.vuln || x.description),
+            });
+          }
+        } catch {}
+      }
+    }
+  } catch {}
+
+  // 4. AGENTS.md narrative.
+  const agents = _read(scanRoot, 'AGENTS.md');
+  if (agents) {
+    const sections = agents.split(/^##\s+/m);
+    for (const sec of sections) {
+      const score = _score(sec, terms);
+      if (!score) continue;
+      const title = sec.split('\n')[0] || '';
+      results.push({
+        source: 'agents-md',
+        score,
+        title: _truncate(title, 80),
+        snippet: _truncate(sec.replace(title, ''), 200),
+      });
+    }
+  }
+
+  // Top-10 by score, ties broken by source priority (finding > triage >
+  // history > agents-md so live data wins).
+  const PRI = { finding: 4, triage: 3, history: 2, 'agents-md': 1 };
+  results.sort((a, b) => (b.score - a.score) || (PRI[b.source] - PRI[a.source]));
+  return { results: results.slice(0, 10), count: results.length };
+}
+
+const _internals = { _terms, _score, _findingHaystack };
+
+
+/***/ })
+
+};

package/dist/985.index.js

@@ -613,6 +613,8 @@ function _findById(scan, id) {
   if (!scan) return null;
   return (scan.findings || []).find(f => f.id === id)
       || (scan.secrets || []).find(f => f.id === id)
+      || (scan.supplyChain || []).find(f => f.id === id)
+      || (scan.logicVulns || []).find(f => f.id === id)
       || null;
 }
 
@@ -843,6 +845,19 @@ const explain_finding = {
       confidence: f.confidence ?? null,
       hasReplacementFix: typeof f.fix?.replacement === 'string',
       integrity: status,
+      // Risk-signal passthrough so agents can decide priority without
+      // re-reading last-scan.json or re-fetching OSV/KEV/EPSS. compositeRisk
+      // is the canonical sort key; the other fields are its provenance.
+      compositeRisk: f.compositeRisk ?? null,
+      compositeRiskTier: f.compositeRiskTier ?? null,
+      compositeRiskFactors: Array.isArray(f.compositeRiskFactors) ? f.compositeRiskFactors : [],
+      exploitability: f.exploitability ?? null,
+      exploitabilityTier: f.exploitabilityTier ?? null,
+      mitigationVerdict: f.mitigationVerdict ?? null,
+      kev: !!(f.kev || f.kevListed || f.weaponized),
+      epssScore: typeof f.epssScore === 'number' ? f.epssScore : null,
+      epssPercentile: typeof f.epssPercentile === 'number' ? f.epssPercentile : null,
+      exploitedNow: !!f.exploitedNow,
     };
   },
 };
@@ -1306,6 +1321,56 @@ const read_agents_memory = {
   },
 };
 
+// ─── query_triage_memory ───────────────────────────────────────────────────
+// Natural-language Q&A over past triage decisions (wont-fix / false-positive
+// markings + reasons). Backed by .agentic-security/triage-memory.jsonl, which
+// is auto-populated by triage.transition(). Returns at most 10 most-relevant
+// past decisions.
+
+const query_triage_memory = {
+  name: 'query_triage_memory',
+  description: 'Search past triage decisions (wont-fix / false-positive) by natural-language query. Returns up to 10 most-relevant past decisions with their reasons. Use when you see a new finding and want to know "did we already decide on something like this?" — answers in seconds without re-reading the full AGENTS.md narrative.',
+  inputSchema: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      query: { type: 'string', description: 'Free-text terms to match against past reasons / vuln text / file paths / family names.' },
+    },
+  },
+  async handler({ query }, ctx) {
+    const { queryMemory } = await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, 1905));
+    const results = queryMemory(ctx.sessionRoot, query || '');
+    return {
+      _meta: META,
+      count: results.length,
+      results,
+    };
+  },
+};
+
+// ─── query_findings_memory ─────────────────────────────────────────────────
+// Natural-language Q&A across the scanner's accumulated institutional
+// memory: current findings + past triage decisions + scan history +
+// AGENTS.md narrative. Use to answer "have we seen something like this
+// before?" without reading multiple files.
+
+const query_findings_memory = {
+  name: 'query_findings_memory',
+  description: 'Search the scanner accumulated memory (current scan findings + past wont-fix/false-positive decisions + scan history + AGENTS.md narrative) by natural-language terms. Returns top-10 results scored by term-match count and ranked finding > triage > history > AGENTS.md.',
+  inputSchema: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      query: { type: 'string', description: 'Natural-language search terms (2+ chars each).' },
+    },
+    required: ['query'],
+  },
+  async handler({ query }, ctx) {
+    const { queryFindingsMemory } = await __webpack_require__.e(/* import() */ 839).then(__webpack_require__.bind(__webpack_require__, 3839));
+    return { _meta: META, ...queryFindingsMemory(ctx.sessionRoot, query || '') };
+  },
+};
+
 // ─── lookup_cve ────────────────────────────────────────────────────────────
 // LangChain harness-anatomy #8: bridge the knowledge-cutoff gap by exposing
 // the local OSV / KEV / EPSS cache as a structured tool. Read-only — never
@@ -1327,7 +1392,81 @@ const lookup_cve = {
   },
 };
 
-const ALL_TOOLS = [scan_diff, query_taint, explain_finding, apply_fix, verify_fix, synthesize_fix, find_rule_module, append_scratchpad, read_scratchpad, append_agents_memory, read_agents_memory, lookup_cve];
+// ─── synthesize_sca_upgrade ───────────────────────────────────────────────
+// Phase 3 / Item 5 of the SCA improvement plan. Read-only counterpart to
+// apply_sca_upgrade — produces a structured upgrade plan via the
+// ecosystem's native --dry-run command. Safe to call any number of times.
+let _scaUpgrade;
+async function _getScaUpgrade() {
+  if (!_scaUpgrade) _scaUpgrade = await __webpack_require__.e(/* import() */ 333).then(__webpack_require__.bind(__webpack_require__, 5333));
+  return _scaUpgrade;
+}
+const synthesize_sca_upgrade = {
+  name: 'synthesize_sca_upgrade',
+  description: 'Generate an upgrade plan for a single SCA finding. Runs the ecosystem dry-run (npm install --dry-run, pip install --dry-run, cargo update --dry-run). Returns { ecosystem, package, currentVersion, targetVersion, isBreaking, command, manifestFiles, dryRun, testCommand }. No writes.',
+  inputSchema: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      finding_id: { type: 'string', minLength: 1, maxLength: 256 },
+    },
+    required: ['finding_id'],
+  },
+  async handler({ finding_id }, ctx) {
+    const { scan, status } = _readLastScanVerified(ctx.sessionRoot, { allowUnsigned: true });
+    if (!scan) throw new Error(`No usable scan state (${status}).`);
+    const f = _findById(scan, finding_id);
+    if (!f) throw new Error(`Finding not found: ${finding_id}`);
+    if (f.type !== 'vulnerable_dep') {
+      return { _meta: META, ok: false, reason: 'finding is not an SCA vulnerable_dep — use synthesize_fix for SAST findings' };
+    }
+    const { planScaUpgrade } = await _getScaUpgrade();
+    const plan = await planScaUpgrade({ scanRoot: ctx.sessionRoot, finding: f });
+    return { _meta: META, ...plan };
+  },
+};
+
+// ─── apply_sca_upgrade ────────────────────────────────────────────────────
+// Phase 3 / Item 5 of the SCA improvement plan. The MCP `apply_fix` path
+// refuses every package-manager manifest by design. This tool bypasses
+// that ONLY for the install pathway — it shells out to the ecosystem's
+// native package manager (npm / pip / cargo / go) which is the right
+// surface for safely modifying manifests + lockfiles. Backs up affected
+// manifests before the install; runs the project's test command (if
+// detected); rolls back manifests if tests fail.
+const apply_sca_upgrade = {
+  name: 'apply_sca_upgrade',
+  description: 'Apply a vulnerable_dep upgrade. Backs up manifests, runs the package manager, runs the project test command, restores manifests on test failure. Requires confirm:true. Set run_tests:false to skip the test gate (NOT recommended).',
+  inputSchema: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      finding_id: { type: 'string', minLength: 1, maxLength: 256 },
+      confirm: { type: 'boolean' },
+      run_tests: { type: 'boolean' },
+    },
+    required: ['finding_id', 'confirm'],
+  },
+  async handler({ finding_id, confirm, run_tests = true }, ctx) {
+    if (confirm !== true) {
+      return { _meta: META, applied: false, reason: 'apply_sca_upgrade requires confirm: true.' };
+    }
+    const { scan, status } = _readLastScanVerified(ctx.sessionRoot, { allowUnsigned: false });
+    if (!scan) {
+      return { _meta: META, applied: false, reason: `last-scan.json failed integrity check: ${status}. Run a fresh scan.` };
+    }
+    const f = _findById(scan, finding_id);
+    if (!f) return { _meta: META, applied: false, reason: `Finding not found: ${finding_id}` };
+    if (f.type !== 'vulnerable_dep') {
+      return { _meta: META, applied: false, reason: 'finding is not an SCA vulnerable_dep — use apply_fix for SAST findings' };
+    }
+    const { applyScaUpgrade } = await _getScaUpgrade();
+    const result = await applyScaUpgrade({ scanRoot: ctx.sessionRoot, finding: f, runTests: run_tests });
+    return { _meta: META, ...result };
+  },
+};
+
+const ALL_TOOLS = [scan_diff, query_taint, explain_finding, apply_fix, verify_fix, synthesize_fix, find_rule_module, append_scratchpad, read_scratchpad, append_agents_memory, read_agents_memory, lookup_cve, synthesize_sca_upgrade, apply_sca_upgrade, query_triage_memory, query_findings_memory];
 
 ;// CONCATENATED MODULE: ./src/mcp/validate.js
 // Minimal JSON Schema validator — just the subset our tool schemas use.