@clear-capabilities/agentic-security-scanner 0.195.22 → 0.195.24

package/src/posture/strategic-metrics.js

@@ -63,7 +63,7 @@ export 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) => {
@@ -72,21 +72,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. */
 export 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. */
 export 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' };
 }
 
 /**
@@ -95,11 +126,21 @@ export function securityLearningRate() {
  * @param {object[]} [o.fixAttempts] fix verification attempts
  */
 export 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(),
   };
 }
@@ -109,6 +150,7 @@ const pc = (r) => (r && r.percent !== null && r.percent !== undefined ? `${r.per
 export 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`);
@@ -117,6 +159,7 @@ export 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/src/sca/llm-function-extract.js

@@ -10,6 +10,8 @@ import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { evaluateEgress } from '../egress/policy.js';
+import { modelFetch } from '../egress/transport.js';
+import { resolveProvider, buildProviderRequest } from '../llm-validator/providers.js';
 
 const CACHE_DIR = process.env.XDG_CONFIG_HOME
   ? path.join(process.env.XDG_CONFIG_HOME, 'agentic-security', 'llm-sca-cache')
@@ -37,24 +39,26 @@ export 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 = 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 = buildProviderRequest(config, prompt, 256);
+  const resp = await modelFetch(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; }