@clear-capabilities/agentic-security-scanner 0.195.21 → 0.195.23

package/dist/7838.index.js

@@ -34,11 +34,15 @@ function toRuntimeRule(ir) {
 
 const EXT = { javascript: 'x.js', typescript: 'x.ts', python: 'x.py', go: 'x.go', ruby: 'x.rb', java: 'x.java', rust: 'x.rs', csharp: 'x.cs', php: 'x.php', any: 'x.txt' };
 
-function buildCorpus(ir, { originalCode, patchedCode = null, nearbyCleanCode = [], protectedVariantsCode = [] } = {}) {
+function buildCorpus(ir, { originalCode, patchedCode = null, nearbyCleanCode = [], protectedVariantsCode = [], independentVulnerableCode = [], independentCleanCode = [] } = {}) {
   const positives = [{ label: 'original', code: originalCode }];
   for (const v of (0,_mutation_js__WEBPACK_IMPORTED_MODULE_0__/* .generateVariants */ .G4)(originalCode)) positives.push({ label: `sibling:${v.mutator}`, code: v.code });
+  // Independent examples (GA-07): vulnerable and safe code that is NOT the source finding and NOT a mutation of it, supplied by the
+  // reviewer from other places. They are never mutated, so they score as what they are: evidence from outside the rule's own material.
+  independentVulnerableCode.forEach((code, i) => positives.push({ label: `independent-vulnerable-${i}`, code }));
 
   const negatives = [];
+  independentCleanCode.forEach((code, i) => negatives.push({ label: `independent-clean-${i}`, code }));
   if (patchedCode) {
     negatives.push({ label: 'patched', code: patchedCode });
     for (const v of (0,_mutation_js__WEBPACK_IMPORTED_MODULE_0__/* .generateVariants */ .G4)(patchedCode)) negatives.push({ label: `patched-sibling:${v.mutator}`, code: v.code });
@@ -74,8 +78,12 @@ function scoreRule(ir, corpus) {
   const recall = corpus.positives.length === 0 ? null : tp / corpus.positives.length;
   // "Protected negative failures" per PRD 3: a rule firing on a sanitizer/guard-carrying variant specifically.
   const protectedFailures = negResults.filter((n) => n.label.startsWith('protected-') && n.fired).length;
+  // Independent evidence, counted apart: how many examples from outside the finding's own material there were, and how they scored.
+  const indPos = posResults.filter((p) => p.label.startsWith('independent-vulnerable-'));
+  const indNeg = negResults.filter((n) => n.label.startsWith('independent-clean-'));
+  const independent = { positives: indPos.length, negatives: indNeg.length, detected: indPos.filter((p) => p.fired).length, falseAlarms: indNeg.filter((n) => n.fired).length };
 
-  return { precision, recall, tp, fp, tn, fn, protectedFailures, positives: posResults, negatives: negResults };
+  return { precision, recall, tp, fp, tn, fn, protectedFailures, independent, positives: posResults, negatives: negResults };
 }
 
 
@@ -169,9 +177,18 @@ function validateRuleIR(ir) {
   return errs;
 }
 
+/** JSON with every object's keys sorted at every depth, so the digest does not depend on insertion order. */
+function stableStringify(v) {
+  if (Array.isArray(v)) return `[${v.map(stableStringify).join(',')}]`;
+  if (v && typeof v === 'object') return `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(v[k])}`).join(',')}}`;
+  return JSON.stringify(v);
+}
+
 function ruleIRDigest(ir) {
   const { state: _s, ...rest } = ir;
-  return (0,_proof_fabric_reproducer_js__WEBPACK_IMPORTED_MODULE_0__/* .sha256 */ .sc)(JSON.stringify(rest, Object.keys(rest).sort()));
+  // Until 0.195.23 this passed the TOP-LEVEL key list as the JSON replacer, which also filters nested objects: `match.pattern` and
+  // every structural regex were serialized as `{}`, so the digest never covered the one thing a rule is. Sorted at every depth now.
+  return (0,_proof_fabric_reproducer_js__WEBPACK_IMPORTED_MODULE_0__/* .sha256 */ .sc)(stableStringify(rest));
 }
 
 /** Build a DRAFT rule IR. Caller supplies the candidate pattern — this module never invents one. */
@@ -386,7 +403,11 @@ function mutatorCoverage(code) {
 // actually recorded, and nothing in this module writes to it.
 
 
-const PROMOTION_DEFAULTS = Object.freeze({ minPrecision: 0.95, minRecall: 0.80, maxProtectedFailures: 0 });
+// Since 0.195.23 (GA-07) promotion also needs independent evidence: at least one vulnerable and one safe example that are not the
+// source finding or a mutation of it, and the rule must detect every independent vulnerable example and stay quiet on every
+// independent safe one. The synthesis loop still scores attempts without them (`evaluateRule`); only the promotion decision
+// (`gatePromotion`) requires them, so a candidate can be proposed before a reviewer has gathered the outside examples.
+const PROMOTION_DEFAULTS = Object.freeze({ minPrecision: 0.95, minRecall: 0.80, maxProtectedFailures: 0, minIndependentVulnerable: 1, minIndependentClean: 1 });
 
 // Deliberately independent of posture/evaluation/custody.js: that module's term list and guard are reserved for
 // the evaluation custodian's sealed-label boundary (QA-002.AC03), and a test enforces that nothing outside
@@ -441,7 +462,13 @@ function gatePromotion({ ir, corpus, leakageCheck, thresholds } = {}) {
   const evalResult = evaluateRule(ir, corpus, thresholds);
   const reasons = [...evalResult.reasons];
   if (!leakageCheck || leakageCheck.ok !== true) reasons.push(leakageCheck ? `leakage check failed: ${leakageCheck.offendingTerms.join(', ')}` : 'leakage check was not run');
-  return { pass: reasons.length === 0, reasons, evaluation: evalResult };
+  const t = evalResult.thresholds;
+  const ind = evalResult.score.independent ?? { positives: 0, negatives: 0, detected: 0, falseAlarms: 0 };
+  if (ind.positives < t.minIndependentVulnerable) reasons.push(`${ind.positives} independent vulnerable example(s) beyond the source finding and its mutations (min ${t.minIndependentVulnerable}): supply independentVulnerableCode`);
+  else if (ind.detected < ind.positives) reasons.push(`misses ${ind.positives - ind.detected} of ${ind.positives} independent vulnerable example(s)`);
+  if (ind.negatives < t.minIndependentClean) reasons.push(`${ind.negatives} independent safe example(s) (min ${t.minIndependentClean}): supply independentCleanCode`);
+  else if (ind.falseAlarms > 0) reasons.push(`fires on ${ind.falseAlarms} of ${ind.negatives} independent safe example(s)`);
+  return { pass: reasons.length === 0, reasons, evaluation: evalResult, independent: ind };
 }
 
 

package/dist/9441.index.js

@@ -89,7 +89,7 @@ function evidenceConversion(findings) {
   const byState = Object.fromEntries(EVIDENCE_STATES.map((s) => [s, 0]));
   for (const f of list) byState[evidenceStateOf(f)]++;
   const converted = list.length - byState['single-signal'];
-  return { ...rate(converted, list.length), byState, basis: 'findings that reached corroborated or stronger, over all findings' };
+  return { status: list.length ? 'measured' : 'unmeasured', ...rate(converted, list.length), byState, basis: 'findings that reached corroborated or stronger, over all findings of the last scan' };
 }
 
 const strongest = (a) => {
@@ -98,21 +98,52 @@ const strongest = (a) => {
   return disappeared && a.testsRan === true && a.testsOk !== false && a.pocOk === true;
 };
 
+const isoOrNull = (v) => (typeof v === 'string' && !Number.isNaN(Date.parse(v)) ? v : null);
+
+/**
+ * One attempt per finding (GA-11): a fix tried five times is one remediation, not five, so the LATEST recorded attempt for each
+ * finding id is the one counted and the earlier ones are reported as `repeated`. An attempt with no finding id cannot be matched to
+ * another and counts on its own. Order is by `at` where every record has one, else by position in the log.
+ */
+function dedupeAttempts(attempts) {
+  const list = Array.isArray(attempts) ? attempts.filter((a) => a && typeof a === 'object') : [];
+  const latest = new Map();
+  const loose = [];
+  list.forEach((a, i) => {
+    const key = typeof a.stableId === 'string' && a.stableId ? a.stableId : (typeof a.findingId === 'string' && a.findingId ? a.findingId : null);
+    if (!key) { loose.push(a); return; }
+    const prev = latest.get(key);
+    const newer = !prev || (isoOrNull(a.at) && isoOrNull(prev.at) ? Date.parse(a.at) >= Date.parse(prev.at) : i > prev._i);
+    if (newer) latest.set(key, Object.assign(Object.create(null), a, { _i: i }));
+  });
+  const kept = [...latest.values()].map((a) => { const { _i, ...rest } = a; return rest; }).concat(loose);
+  return { attempts: kept, recorded: list.length, repeated: list.length - kept.length };
+}
+
+/** The time span the recorded attempts cover: `from` and `to` are the earliest and latest `at`, or `null` when none carries one. */
+function attemptsWindow(attempts) {
+  const times = (Array.isArray(attempts) ? attempts : []).map((a) => a && isoOrNull(a.at)).filter(Boolean).sort();
+  return { from: times[0] ?? null, to: times[times.length - 1] ?? null };
+}
+
 /** Of the fix attempts, how many reached the strongest verification tier. A lower bound: some classes have no independent proof to run. */
 function verifiedRemediationRate(attempts) {
-  const list = Array.isArray(attempts) ? attempts.filter((a) => a && typeof a === 'object') : [];
+  const { attempts: list, recorded, repeated } = dedupeAttempts(attempts);
   const full = list.filter(strongest).length;
   const disappearedOnly = list.filter((a) => typeof a.verifiedFull !== 'boolean' && (a.rescanOk === true || (a.ok === true && a.rescanOk !== false)) && !(a.testsRan === true && a.testsOk !== false) && a.pocOk !== true).length;
+  const failed = list.filter((a) => a.ok === false || a.verifiedFull === false).length;
   return {
+    status: list.length ? 'measured' : 'unmeasured',
     ...rate(full, list.length),
-    disappearedOnly,
-    basis: 'attempts that passed the re-scan, the project tests and the independent attack replay, over all attempts. A lower bound where a class has no replay',
+    recorded, repeated, failed, disappearedOnly,
+    window: attemptsWindow(attempts),
+    basis: 'the latest attempt per finding that passed the re-scan, the project tests and the independent attack replay, over the latest attempt per finding. A lower bound where a class has no replay',
   };
 }
 
-/** Nothing measures it independently of the rule compiler's own corpus, so it is reported as not measured. */
+/** Nothing measures it independently of the rule compiler's own corpus, so it is reported as unmeasured, with the reason. */
 function securityLearningRate() {
-  return { status: 'not-measured', reason: 'the rule compiler grades its rules against a corpus built from the same finding; no independent measurement of novel weaknesses converted into reusable knowledge exists' };
+  return { status: 'unmeasured', reason: 'the rule compiler grades its rules against a corpus built from the same finding and the reviewer-supplied independent examples; no independent longitudinal measurement of novel weaknesses converted into reusable knowledge exists' };
 }
 
 /**
@@ -121,11 +152,21 @@ function securityLearningRate() {
  * @param {object[]} [o.fixAttempts] fix verification attempts
  */
 function computeStrategicMetrics({ scan = null, fixAttempts = [] } = {}) {
+  const attempts = Array.isArray(fixAttempts) ? fixAttempts : [];
   return {
     schema: STRATEGIC_METRICS_SCHEMA, version: STRATEGIC_METRICS_VERSION,
+    // The scope and time basis (GA-11): these are per-scan figures for ONE scan plus the attempts recorded on this machine, never an
+    // organisation trend. The scan is named by its id and start time; the attempts by the span their timestamps cover.
+    scope: {
+      kind: 'per-scan',
+      scanId: scan && typeof scan.scanId === 'string' ? scan.scanId : null,
+      scanStartedAt: scan ? isoOrNull(scan.startedAt) : null,
+      attempts: { ...attemptsWindow(attempts), recorded: attempts.filter((a) => a && typeof a === 'object').length },
+      trend: 'not a trend: one scan and this machine\'s recorded attempts; compare scans by scanId to see movement',
+    },
     assuranceCoverage: assuranceCoverage(scan && scan.scanHealth),
     evidenceConversion: evidenceConversion(scan && scan.findings),
-    verifiedRemediationRate: verifiedRemediationRate(fixAttempts),
+    verifiedRemediationRate: verifiedRemediationRate(attempts),
     securityLearningRate: securityLearningRate(),
   };
 }
@@ -135,6 +176,7 @@ const pc = (r) => (r && r.percent !== null && r.percent !== undefined ? `${r.per
 function renderStrategicMetrics(m) {
   const ac = m.assuranceCoverage; const ec = m.evidenceConversion; const vr = m.verifiedRemediationRate;
   const L = [];
+  if (m.scope) L.push(`Scope: one scan${m.scope.scanId ? ` (${m.scope.scanId}${m.scope.scanStartedAt ? `, started ${m.scope.scanStartedAt}` : ''})` : ''} and ${m.scope.attempts.recorded} fix attempt(s) recorded on this machine${m.scope.attempts.from ? ` between ${m.scope.attempts.from} and ${m.scope.attempts.to}` : ''}; not a trend`);
   L.push(`Assurance Coverage: ${ac.percent === null ? 'not measurable' : `${ac.percent}% (the lower of the two components)`}${ac.scanStatus ? `; scan ${ac.scanStatus}` : ''}`);
   if (ac.files) L.push(`  files: ${ac.files.numerator} of ${ac.files.denominator} completed (${pc(ac.files)}); ${ac.files.skipped} skipped, ${ac.files.unanalysed} not analysed, ${ac.files.timedOut} timed out`);
   if (ac.analyzers) L.push(`  analyzers: ${ac.analyzers.numerator} of ${ac.analyzers.denominator} completed (${pc(ac.analyzers)}); ${ac.analyzers.failed} failed, ${ac.analyzers.timedOut} timed out`);
@@ -143,6 +185,7 @@ function renderStrategicMetrics(m) {
   L.push(`  ${EVIDENCE_STATES.map((s) => `${s} ${ec.byState[s]}`).join(', ')}`);
   L.push(`Verified Remediation Rate: ${vr.numerator} of ${vr.denominator} fix attempts reached the strongest verification tier (${pc(vr)})${vr.denominator ? '; a lower bound where a class has no attack replay' : ''}`);
   if (vr.disappearedOnly) L.push(`  ${vr.disappearedOnly} satisfied only the re-scan, which is also what deleting the code produces`);
+  if (vr.repeated) L.push(`  ${vr.recorded} attempt(s) recorded; ${vr.repeated} earlier attempt(s) on the same finding counted once, by the latest`);
   L.push(`Security Learning Rate: not measured. ${m.securityLearningRate.reason}`);
   return L.join('\n');
 }

package/dist/9824.index.js

@@ -13,6 +13,8 @@ export const modules = {
 /* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(73024);
 /* harmony import */ var node_path__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(76760);
 /* harmony import */ var _egress_policy_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(45712);
+/* harmony import */ var _egress_transport_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(73785);
+/* harmony import */ var _llm_validator_providers_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(38947);
 // LLM-assisted vulnerable function extraction for SCA findings.
 //
 // For CVEs without OSV ecosystem_specific data or GHSA fix commits,
@@ -26,6 +28,8 @@ export const modules = {
 
 
 
+
+
 const CACHE_DIR = process.env.XDG_CONFIG_HOME
   ? node_path__WEBPACK_IMPORTED_MODULE_2__.join(process.env.XDG_CONFIG_HOME, 'agentic-security', 'llm-sca-cache')
   : node_path__WEBPACK_IMPORTED_MODULE_2__.join(process.env.HOME || '/tmp', '.config', 'agentic-security', 'llm-sca-cache');
@@ -52,24 +56,26 @@ function isLlmScaEnabled() {
   return process.env.AGENTIC_SECURITY_LLM_SCA === '1';
 }
 
-function _endpointConfig() {
-  const endpoint = process.env.AGENTIC_SECURITY_LLM_ENDPOINT;
-  const apiKey = process.env.AGENTIC_SECURITY_LLM_API_KEY;
-  const model = process.env.AGENTIC_SECURITY_LLM_MODEL || 'unknown';
-  return endpoint ? { endpoint, apiKey, model } : null;
+// The provider is resolved the same way the validator resolves it (GA-06.3): the `local` preset refuses a non-loopback endpoint here
+// too, instead of this module reading the raw endpoint variable and calling it regardless. The Ollama provider speaks a different
+// protocol and this extractor does not implement it, so it is treated as not configured.
+function _endpointConfig(env = process.env) {
+  const r = (0,_llm_validator_providers_js__WEBPACK_IMPORTED_MODULE_5__.resolveProvider)({ role: 'validate', env });
+  if (!r.ok || r.config.provider === 'ollama') return null;
+  return { endpoint: r.config.endpoint, apiKey: r.config.apiKey, model: r.config.model || 'unknown', shape: r.config.shape };
 }
 
 async function _askLlm(prompt, config) {
-  const headers = { 'Content-Type': 'application/json' };
-  if (config.apiKey) headers['Authorization'] = `Bearer ${config.apiKey}`;
-  const resp = await fetch(config.endpoint, {
+  const req = (0,_llm_validator_providers_js__WEBPACK_IMPORTED_MODULE_5__/* .buildProviderRequest */ .Z$)(config, prompt, 256);
+  const resp = await (0,_egress_transport_js__WEBPACK_IMPORTED_MODULE_4__/* .modelFetch */ .Ye)(config.endpoint, {
     method: 'POST',
-    headers,
-    body: JSON.stringify({ prompt, model: config.model }),
-    signal: AbortSignal.timeout(15000),
-  });
+    headers: req.headers,
+    body: JSON.stringify(req.body),
+  }, { timeoutMs: 15000 });
   if (!resp.ok) return null;
-  const text = await resp.text();
+  let text = await resp.text();
+  // a vendor shape wraps the model's text in its own envelope; the generic shape's reply is searched as it came
+  try { const t = req.extractText(JSON.parse(text)); if (typeof t === 'string' && t) text = t; } catch { /* not an envelope */ }
   const jsonMatch = text.match(/\{[^{}]*"functions"\s*:\s*\[[^\]]*\][^{}]*\}/);
   if (!jsonMatch) return null;
   try { return JSON.parse(jsonMatch[0]); } catch { return null; }