@clear-capabilities/agentic-security-scanner 0.144.0 → 0.147.0

package/dist/4863.index.js

@@ -0,0 +1,422 @@
+export const id = 4863;
+export const ids = [4863];
+export const modules = {
+
+/***/ 4863:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  loadRemoteGraphExport: () => (/* binding */ loadRemoteGraphExport)
+});
+
+// EXTERNAL MODULE: external "node:fs"
+var external_node_fs_ = __webpack_require__(3024);
+// EXTERNAL MODULE: ./src/lineage/schema.js
+var schema = __webpack_require__(4073);
+// EXTERNAL MODULE: ./src/lineage/protection.js
+var protection = __webpack_require__(965);
+// EXTERNAL MODULE: ./src/lineage/classification.js
+var classification = __webpack_require__(2602);
+;// CONCATENATED MODULE: ./src/lineage/validate.js
+//
+// Structural validator for DataFlowGraph v1 (PRD section 10). Hand-rolled
+// rather than a generic JSON-Schema interpreter + a new `ajv`-style
+// dependency, matching this codebase's existing preference for
+// hand-rolled implementations over new runtime deps (see every parser in
+// scanner/src/ir/). scanner/src/lineage/dataflow-graph.schema.json (Task
+// 6) is the authoritative JSON Schema document for external interop /
+// documentation; this file is what the engine actually calls at graph-
+// build phase 12 (PRD 18.3: "Validate the graph contract and freeze it
+// before rendering").
+//
+// Never throws. A malformed top-level input produces one error and
+// returns early; a malformed nested entity is skipped for further
+// structural checks on ITSELF but does not stop validation of siblings.
+
+
+
+
+
+function _err(errors, path, message) {
+  errors.push({ path, message });
+}
+
+function _requireArray(graph, key, errors) {
+  if (!Array.isArray(graph[key])) _err(errors, `$.${key}`, `${key} must be an array`);
+}
+
+function _requireObject(graph, key, errors) {
+  if (typeof graph[key] !== 'object' || graph[key] === null || Array.isArray(graph[key])) {
+    _err(errors, `$.${key}`, `${key} must be an object`);
+  }
+}
+
+const ID_PREFIXES = {
+  node: /^node:/,
+  edge: /^edge:/,
+  data: /^data:/,
+  flow: /^flow:/,
+  transform: /^transform:/,
+  evidence: /^evidence:/,
+};
+
+function _validateNode(node, idx, errors, seenIds) {
+  const path = (suffix) => `$.nodes[${idx}]${suffix}`;
+  if (!node || typeof node !== 'object') { _err(errors, path(''), 'node must be an object'); return; }
+  if (typeof node.id !== 'string' || !node.id) _err(errors, path('.id'), 'node.id is required');
+  else {
+    if (!ID_PREFIXES.node.test(node.id)) _err(errors, path('.id'), `node.id must start with "node:"`);
+    seenIds.add(node.id);
+  }
+  if (!schema/* NODE_KINDS */.xA.includes(node.kind)) _err(errors, path('.kind'), `unrecognized node kind "${node.kind}"`);
+  // node.subtype is optional and may be `null` — an `unsupported`-coverage
+  // node (e.g. a sink registry decision with `category: null`, PRD 6.4/
+  // DESIGN_REGISTRIES.md §9.0) legitimately carries no subtype at all,
+  // either as an absent field or an explicit `null`; only a present,
+  // non-null, non-string value (a number, object, array, etc.) is invalid.
+  if (Object.prototype.hasOwnProperty.call(node, 'subtype') && node.subtype !== null && typeof node.subtype !== 'string') {
+    _err(errors, path('.subtype'), 'node.subtype must be a string or null');
+  }
+  if (typeof node.label !== 'string' || !node.label) _err(errors, path('.label'), 'node.label is required');
+  if (!Array.isArray(node.aliases)) _err(errors, path('.aliases'), 'node.aliases must be an array');
+  if (!Array.isArray(node.dataElementIds)) _err(errors, path('.dataElementIds'), 'node.dataElementIds must be an array');
+  if (!Array.isArray(node.evidenceRefs)) _err(errors, path('.evidenceRefs'), 'node.evidenceRefs must be an array');
+  if (!schema/* COVERAGE_STATUS_VALUES */.R0.includes(node.coverageStatus)) _err(errors, path('.coverageStatus'), `unrecognized coverageStatus "${node.coverageStatus}"`);
+  if (node.externality && !schema/* EXTERNALITY_VALUES */.TB.includes(node.externality.value)) {
+    _err(errors, path('.externality.value'), `unrecognized externality "${node.externality.value}"`);
+  }
+  // Milestone 2, Sub-project A, increment 1: `node.destination` is `null`
+  // on every node this increment doesn't resolve — only checked when
+  // non-null, mirroring `_validateEdge`'s own `edge.protocol` pattern below.
+  if (node.destination && typeof node.destination === 'object') {
+    if (!schema/* DESTINATION_RESOLUTION_VALUES */.JU.includes(node.destination.resolutionStatus)) {
+      _err(errors, path('.destination.resolutionStatus'), `unrecognized destination.resolutionStatus "${node.destination.resolutionStatus}"`);
+    }
+    if (node.destination.resolutionStatus !== 'literal' && node.destination.literalValue !== null) {
+      _err(errors, path('.destination.literalValue'), 'destination.literalValue must be null unless resolutionStatus is "literal"');
+    }
+  }
+  // Milestone 2, Sub-project E, increment 2: `node.storeDetail` is `null`
+  // on every node this increment doesn't populate — only checked when
+  // non-null, mirroring `node.destination`'s own "only checked when the
+  // parent object is present" shape immediately above.
+  if (node.storeDetail && typeof node.storeDetail === 'object') {
+    if (node.storeDetail.operation !== null && !schema/* STORE_OPERATION_VALUES */.P4.includes(node.storeDetail.operation)) {
+      _err(errors, path('.storeDetail.operation'), `unrecognized storeDetail.operation "${node.storeDetail.operation}"`);
+    }
+    if (Object.prototype.hasOwnProperty.call(node.storeDetail, 'columns') && !Array.isArray(node.storeDetail.columns)) {
+      _err(errors, path('.storeDetail.columns'), 'storeDetail.columns must be an array');
+    } else if (Array.isArray(node.storeDetail.columns)) {
+      node.storeDetail.columns.forEach((c, i) => {
+        if (typeof c !== 'string') _err(errors, path(`.storeDetail.columns[${i}]`), 'storeDetail.columns entries must be strings');
+      });
+    }
+  }
+  // Milestone 2, Sub-project E, increment 3: `node.queueDetail` is `null`
+  // on every node this increment doesn't populate — only checked when
+  // non-null, mirroring `node.storeDetail`'s own "only checked when the
+  // parent object is present" shape immediately above.
+  if (node.queueDetail && typeof node.queueDetail === 'object') {
+    if (node.queueDetail.operation !== null && !schema/* QUEUE_OPERATION_VALUES */.hY.includes(node.queueDetail.operation)) {
+      _err(errors, path('.queueDetail.operation'), `unrecognized queueDetail.operation "${node.queueDetail.operation}"`);
+    }
+    if (node.queueDetail.topic !== null && typeof node.queueDetail.topic !== 'string') {
+      _err(errors, path('.queueDetail.topic'), 'queueDetail.topic must be a string or null');
+    }
+  }
+}
+
+function _validateDataElement(de, idx, errors, seenIds) {
+  const path = (suffix) => `$.dataElements[${idx}]${suffix}`;
+  if (!de || typeof de !== 'object') { _err(errors, path(''), 'dataElement must be an object'); return; }
+  if (typeof de.id !== 'string' || !de.id) _err(errors, path('.id'), 'dataElement.id is required');
+  else {
+    if (!ID_PREFIXES.data.test(de.id)) _err(errors, path('.id'), `dataElement.id must start with "data:"`);
+    seenIds.add(de.id);
+  }
+  if (typeof de.name !== 'string' || !de.name) _err(errors, path('.name'), 'dataElement.name is required');
+  if (!Array.isArray(de.dataClasses)) _err(errors, path('.dataClasses'), 'dataElement.dataClasses must be an array');
+  else {
+    for (let i = 0; i < de.dataClasses.length; i++) {
+      const cls = de.dataClasses[i];
+      if (!classification/* LINEAGE_DATA_CLASSES */.e6.includes(cls)) {
+        _err(errors, path(`.dataClasses[${i}]`), `unrecognized data class "${cls}"`);
+      }
+    }
+  }
+  if (!Array.isArray(de.aiContexts)) _err(errors, path('.aiContexts'), 'dataElement.aiContexts must be an array');
+  else {
+    for (let i = 0; i < de.aiContexts.length; i++) {
+      const ctx = de.aiContexts[i];
+      if (!(0,classification/* isAiContext */.MY)(ctx)) {
+        _err(errors, path(`.aiContexts[${i}]`), `unrecognized AI processing context "${ctx}"`);
+      }
+    }
+  }
+}
+
+function _validateEdge(edge, idx, errors, nodeIds, dataElementIds) {
+  const path = (suffix) => `$.edges[${idx}]${suffix}`;
+  if (!edge || typeof edge !== 'object') { _err(errors, path(''), 'edge must be an object'); return; }
+  if (typeof edge.id !== 'string' || !edge.id) _err(errors, path('.id'), 'edge.id is required');
+  else if (!ID_PREFIXES.edge.test(edge.id)) _err(errors, path('.id'), `edge.id must start with "edge:"`);
+  if (!nodeIds.has(edge.from)) _err(errors, path('.from'), `unknown node id "${edge.from}"`);
+  if (!nodeIds.has(edge.to)) _err(errors, path('.to'), `unknown node id "${edge.to}"`);
+  if (edge.relationship !== 'data_flow') _err(errors, path('.relationship'), `unrecognized relationship "${edge.relationship}"`);
+  if (!Array.isArray(edge.fieldMappings)) _err(errors, path('.fieldMappings'), 'edge.fieldMappings must be an array');
+  else {
+    edge.fieldMappings.forEach((fm, i) => {
+      if (!schema/* MAPPING_TYPES */.$W.includes(fm?.mappingType)) _err(errors, path(`.fieldMappings[${i}].mappingType`), `unrecognized mappingType "${fm?.mappingType}"`);
+      for (const deId of fm?.dataElementIds || []) {
+        if (!dataElementIds.has(deId)) _err(errors, path(`.fieldMappings[${i}].dataElementIds`), `unknown dataElement id "${deId}"`);
+      }
+    });
+  }
+  if (!edge.protection || typeof edge.protection !== 'object') {
+    _err(errors, path('.protection'), 'edge.protection is required');
+  } else {
+    for (const dim of protection/* PROTECTION_DIMENSIONS */.Ai) {
+      if (!(0,protection/* isValidProtectionDimension */.u9)(edge.protection[dim])) _err(errors, path(`.protection.${dim}`), `invalid protection dimension`);
+    }
+  }
+  if (edge.protocol && typeof edge.protocol === 'object') {
+    if (!schema/* DESTINATION_RESOLUTION_VALUES */.JU.includes(edge.protocol.destinationResolution)) {
+      _err(errors, path('.protocol.destinationResolution'), `unrecognized destinationResolution "${edge.protocol.destinationResolution}"`);
+    }
+  }
+  if (!schema/* EDGE_PROVENANCE_VALUES */.L9.includes(edge.provenance)) {
+    _err(errors, path('.provenance'), `unrecognized provenance "${edge.provenance}"`);
+  }
+}
+
+function _validateFlow(flow, idx, errors, nodeIds, dataElementIds, edgeIds) {
+  const path = (suffix) => `$.flows[${idx}]${suffix}`;
+  if (!flow || typeof flow !== 'object') { _err(errors, path(''), 'flow must be an object'); return; }
+  if (typeof flow.id !== 'string' || !flow.id) _err(errors, path('.id'), 'flow.id is required');
+  else if (!ID_PREFIXES.flow.test(flow.id)) _err(errors, path('.id'), `flow.id must start with "flow:"`);
+  if (!nodeIds.has(flow.source)) _err(errors, path('.source'), `unknown node id "${flow.source}"`);
+  if (!nodeIds.has(flow.sink)) _err(errors, path('.sink'), `unknown node id "${flow.sink}"`);
+  for (const deId of flow.dataElementIds || []) {
+    if (!dataElementIds.has(deId)) _err(errors, path('.dataElementIds'), `unknown dataElement id "${deId}"`);
+  }
+  for (const eId of flow.edgeIds || []) {
+    if (!edgeIds.has(eId)) _err(errors, path('.edgeIds'), `unknown edge id "${eId}"`);
+  }
+  if (!schema/* POLICY_STATES */.QA.includes(flow.policyVerdict)) _err(errors, path('.policyVerdict'), `unrecognized policyVerdict "${flow.policyVerdict}"`);
+  if (!schema/* FLOW_SUMMARY_VALUES */.lw.includes(flow.protectionSummary)) _err(errors, path('.protectionSummary'), `unrecognized protectionSummary "${flow.protectionSummary}"`);
+  // Milestone 2, Sub-project D, increment 1: `flow.handling` is `null` on
+  // every flow this increment's own caller chose not to populate — only
+  // checked when non-null, mirroring `_validateNode`'s own `node.destination`
+  // pattern above.
+  if (flow.handling != null && !schema/* HANDLING_VALUES */.DC.includes(flow.handling)) {
+    _err(errors, path('.handling'), `unrecognized handling "${flow.handling}"`);
+  }
+}
+
+function _validateTransformation(t, idx, errors) {
+  const path = (suffix) => `$.transformations[${idx}]${suffix}`;
+  if (!t || typeof t !== 'object') { _err(errors, path(''), 'transformation must be an object'); return; }
+  if (typeof t.id !== 'string' || !t.id) _err(errors, path('.id'), 'transformation.id is required');
+  else if (!ID_PREFIXES.transform.test(t.id)) _err(errors, path('.id'), `transformation.id must start with "transform:"`);
+  if (!schema/* TRANSFORM_KINDS */.DK.includes(t.kind)) _err(errors, path('.kind'), `unrecognized transformation kind "${t.kind}"`);
+  if (!schema/* REVERSIBILITY_VALUES */.vw.includes(t.reversibility)) _err(errors, path('.reversibility'), `unrecognized reversibility "${t.reversibility}"`);
+}
+
+function _validateEvidence(e, idx, errors) {
+  const path = (suffix) => `$.evidence[${idx}]${suffix}`;
+  if (!e || typeof e !== 'object') { _err(errors, path(''), 'evidence must be an object'); return; }
+  if (typeof e.id !== 'string' || !e.id) _err(errors, path('.id'), 'evidence.id is required');
+  else if (!ID_PREFIXES.evidence.test(e.id)) _err(errors, path('.id'), `evidence.id must start with "evidence:"`);
+  if (!schema/* EVIDENCE_TYPES */.il.includes(e.evidenceType)) _err(errors, path('.evidenceType'), `unrecognized evidenceType "${e.evidenceType}"`);
+}
+
+/**
+ * Report a validation error for every duplicate id beyond the first
+ * occurrence in a top-level entity array. Entities with a missing/invalid
+ * id are skipped here — that is already reported by the per-entity
+ * structural check, and treating `undefined` as a colliding "id" would be
+ * noise, not signal.
+ */
+function _checkDuplicateIds(items, key, errors) {
+  const seenAt = new Map();
+  items.forEach((item, idx) => {
+    if (!item || typeof item.id !== 'string' || !item.id) return;
+    if (seenAt.has(item.id)) {
+      _err(errors, `$.${key}[${idx}].id`, `duplicate id "${item.id}" (also used at $.${key}[${seenAt.get(item.id)}])`);
+    } else {
+      seenAt.set(item.id, idx);
+    }
+  });
+}
+
+/**
+ * Structurally validate a DataFlowGraph v1 envelope. Returns
+ * `{valid, errors}` and never throws.
+ */
+function validateGraph(graph) {
+  const errors = [];
+  if (!graph || typeof graph !== 'object' || Array.isArray(graph)) {
+    return { valid: false, errors: [{ path: '$', message: 'graph must be an object' }] };
+  }
+
+  if (graph.schemaVersion !== schema/* SCHEMA_VERSION */.f$) {
+    _err(errors, '$.schemaVersion', `expected "${schema/* SCHEMA_VERSION */.f$}", got "${graph.schemaVersion}"`);
+  }
+  if (typeof graph.graphId !== 'string' || !graph.graphId.startsWith('dfg:')) {
+    _err(errors, '$.graphId', 'graphId must be a string starting with "dfg:"');
+  }
+  for (const key of ['nodes', 'edges', 'dataElements', 'transformations', 'flows', 'controls', 'policies', 'evidence', 'limitations']) {
+    _requireArray(graph, key, errors);
+  }
+  for (const key of ['scope', 'scanHealth', 'taxonomy', 'coverage', 'extensions']) {
+    _requireObject(graph, key, errors);
+  }
+  if (graph.scope && typeof graph.scope === 'object' && !Array.isArray(graph.scope)) {
+    if (!schema/* GRAPH_SCOPE_SOURCES */.nZ.includes(graph.scope.source)) {
+      _err(errors, '$.scope.source', `unrecognized scope.source "${graph.scope.source}"`);
+    }
+  }
+
+  const nodeIds = new Set();
+  const dataElementIds = new Set();
+  const edgeIds = new Set();
+
+  (Array.isArray(graph.nodes) ? graph.nodes : []).forEach((n, i) => _validateNode(n, i, errors, nodeIds));
+  (Array.isArray(graph.dataElements) ? graph.dataElements : []).forEach((d, i) => _validateDataElement(d, i, errors, dataElementIds));
+  (Array.isArray(graph.edges) ? graph.edges : []).forEach((e, i) => {
+    _validateEdge(e, i, errors, nodeIds, dataElementIds);
+    if (e && typeof e.id === 'string') edgeIds.add(e.id);
+  });
+  (Array.isArray(graph.flows) ? graph.flows : []).forEach((f, i) => _validateFlow(f, i, errors, nodeIds, dataElementIds, edgeIds));
+  (Array.isArray(graph.transformations) ? graph.transformations : []).forEach((t, i) => _validateTransformation(t, i, errors));
+  (Array.isArray(graph.evidence) ? graph.evidence : []).forEach((e, i) => _validateEvidence(e, i, errors));
+
+  _checkDuplicateIds(Array.isArray(graph.nodes) ? graph.nodes : [], 'nodes', errors);
+  _checkDuplicateIds(Array.isArray(graph.edges) ? graph.edges : [], 'edges', errors);
+  _checkDuplicateIds(Array.isArray(graph.dataElements) ? graph.dataElements : [], 'dataElements', errors);
+  _checkDuplicateIds(Array.isArray(graph.flows) ? graph.flows : [], 'flows', errors);
+
+  return { valid: errors.length === 0, errors };
+}
+
+// EXTERNAL MODULE: ./src/lineage/export-json.js
+var export_json = __webpack_require__(859);
+;// CONCATENATED MODULE: ./src/lineage/federation-loader.js
+// federation-loader.js — M5 deliverable #8 (FR-304's "declared" half):
+// loadRemoteGraphExport(filePath) reads an exportGraphJSON-shaped file
+// (dataflow export --format json's own artifact) — chosen over the
+// local server's signed-graph reader (`scanner/src/server/`, whose
+// loadSignedGraph is what `agentic-security explore` uses) for the
+// cross-machine reason this deliverable's own scoping investigation
+// found: loadSignedGraph authenticates against a PER-INSTALL HMAC key,
+// which is the wrong trust model for a file that crossed a repo/machine
+// boundary in the common case (two repos scanned on two different
+// machines sign under two different keys by default, so pointing
+// loadSignedGraph at a second repo's checkout would, in the common case,
+// correctly report 'tampered' even though nothing was actually
+// tampered with). exportGraphJSON's portable, embedded-digest artifact
+// is a SELF-CONSISTENCY check instead — never authentication, disclosed
+// as such everywhere this module or its callers describe it.
+//
+// Mirrors that reader's own four-distinct-outcome discipline, with one
+// structural difference: a digest mismatch here is NOT a blocking
+// failure (`ok:false`) the way all four of its reasons are — it is a
+// WARNING the caller must show, never silently swallowed, and does not
+// by itself block a --yes write (the operator is explicitly asserting
+// this file). `ok:true, digestMatches:false` is therefore a real,
+// valid, non-failing outcome; only `missing`/`malformed`/
+// `invalid-graph` set `ok:false`.
+//
+// The self-consistency check recomputes `computeGraphDigest(parsed.graph)`
+// and compares it to the file's own embedded `bodyDigest` (final
+// whole-branch review, M5 deliverable #8, B1 — NOT `digest`, a real bug
+// that survived five clean task-level reviews). `export-json.js`'s
+// `digest` field always identifies the SOURCE graph an export was taken
+// from, regardless of redaction/filtering — comparing it against a
+// recomputation over `parsed.graph` (which IS the redacted/filtered
+// `graph:` body under the CLI's own default settings) fails under the
+// exact common case a self-consistency check exists to pass: an
+// un-tampered, default-redacted export would permanently read
+// `digestMatches: false`, and a genuine tamper would be indistinguishable
+// from routine redaction. `bodyDigest` identifies the exact bytes this
+// file actually contains, which is what a self-consistency check over a
+// received file needs.
+
+
+
+
+
+/**
+ * @param {string} filePath
+ * @returns {{
+ *   ok: boolean,
+ *   graph: object|null,
+ *   digest: string|null,
+ *   digestMatches: boolean|null,
+ *   reason: 'missing'|'malformed'|'invalid-graph'|'digest-mismatch'|null,
+ *   message: string|null,
+ * }}
+ */
+function loadRemoteGraphExport(filePath) {
+  if (!filePath || typeof filePath !== 'string' || !external_node_fs_.existsSync(filePath)) {
+    return {
+      ok: false, graph: null, digest: null, digestMatches: null, reason: 'missing',
+      message: `No remote graph export found at ${filePath}. Run \`dataflow export --format json\` in the remote repository and point --remote-graph at the resulting file.`,
+    };
+  }
+
+  let body;
+  try {
+    body = external_node_fs_.readFileSync(filePath, 'utf8');
+  } catch (e) {
+    return {
+      ok: false, graph: null, digest: null, digestMatches: null, reason: 'missing',
+      message: `Remote graph export found at ${filePath} but could not be read: ${e && e.message ? e.message : e}.`,
+    };
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (e) {
+    return {
+      ok: false, graph: null, digest: null, digestMatches: null, reason: 'malformed',
+      message: `Remote graph export at ${filePath} is not valid JSON (${e && e.message ? e.message : e}).`,
+    };
+  }
+
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)
+    || typeof parsed.bodyDigest !== 'string' || !parsed.bodyDigest
+    || !parsed.graph || typeof parsed.graph !== 'object' || Array.isArray(parsed.graph)) {
+    return {
+      ok: false, graph: null, digest: null, digestMatches: null, reason: 'malformed',
+      message: `Remote graph export at ${filePath} does not look like an \`exportGraphJSON\` artifact — expected top-level "bodyDigest" (string) and "graph" (object) fields. Run \`dataflow export --format json\` to produce a valid one.`,
+    };
+  }
+
+  const { valid, errors } = validateGraph(parsed.graph);
+  if (!valid) {
+    return {
+      ok: false, graph: null, digest: parsed.bodyDigest, digestMatches: null, reason: 'invalid-graph',
+      message: `Remote graph export at ${filePath} does not contain a well-formed DataFlowGraph v1 document: ${errors.map((e) => `${e.path}: ${e.message}`).join('; ')}`,
+    };
+  }
+
+  const recomputed = (0,export_json.computeGraphDigest)(parsed.graph);
+  const digestMatches = recomputed === parsed.bodyDigest;
+  if (!digestMatches) {
+    return {
+      ok: true, graph: parsed.graph, digest: parsed.bodyDigest, digestMatches: false, reason: 'digest-mismatch',
+      message: 'WARNING: the remote export\'s embedded digest does not match its own content (self-consistency check failed) — this is NOT authentication, only a check that the file has not been altered since it was exported. Proceeding is a real trust decision the operator is making explicitly.',
+    };
+  }
+
+  return { ok: true, graph: parsed.graph, digest: parsed.bodyDigest, digestMatches: true, reason: null, message: null };
+}
+
+
+/***/ })
+
+};

package/dist/{970.index.js → 4970.index.js}

@@ -1,5 +1,5 @@
-export const id = 970;
-export const ids = [970];
+export const id = 4970;
+export const ids = [4970];
 export const modules = {
 
 /***/ 4970:
@@ -11,6 +11,7 @@ export const modules = {
 /* harmony export */   evaluateAssuranceMode: () => (/* binding */ evaluateAssuranceMode)
 /* harmony export */ });
 /* unused harmony export _internals */
+/* harmony import */ var _posture_provenance_schema_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4594);
 // Assurance modes (assurance-hardening PRD FR-204).
 //
 // "Add assurance modes: advisory, standard, and strict | Strict mode fails
@@ -55,6 +56,8 @@ export const modules = {
 // mode to behave differently from advisory, that is a deliberate, separate
 // decision -- not something to guess at here.
 
+
+
 const ASSURANCE_MODES = Object.freeze(['advisory', 'standard', 'strict']);
 const DEFAULT_ASSURANCE_MODE = 'standard';
 
@@ -69,7 +72,7 @@ function _isValidMode(mode) {
  *   ok:false only ever happens in strict mode; advisory/standard always ok:true
  *   (they report, they do not gate).
  */
-function evaluateAssuranceMode(mode, scanHealth) {
+function evaluateAssuranceMode(mode, scanHealth, findings = []) {
   const effectiveMode = _isValidMode(mode) ? mode : DEFAULT_ASSURANCE_MODE;
   const conditions = Array.isArray(scanHealth?.conditions) ? scanHealth.conditions : [];
 
@@ -98,6 +101,67 @@ function evaluateAssuranceMode(mode, scanHealth) {
       conditions,
     };
   }
+
+  // M2 §2.5: strict cares about overall scan completeness, which now
+  // explicitly includes PROVENANCE completeness, not just detector/analyzer
+  // completeness. A finding whose findingProvenance status is outside
+  // ['complete','uncommitted'] — including a finding with NO
+  // findingProvenance at all, e.g. --no-provenance was used — means strict
+  // cannot vouch for this scan's provenance the same way it already refuses
+  // to vouch for a scan with a failed analyzer.
+  //
+  // KNOWN INTERACTION: scan.secrets/scan.logicVulns are unconditionally
+  // stamped not_available today (M0+M1 deliberately deferred real origin
+  // resolution for those two channels — see the M2/M3/M4 design spec's
+  // §2.6). Any real secret or logic finding therefore fails strict mode
+  // until that resolution work lands. This is the literal, intended
+  // consequence of "never false certainty" applied to strict's own
+  // definition, not an oversight — a strict-mode operator with secrets
+  // findings should expect this until M3+ closes that gap.
+  //
+  // This list is INCOMPLETE without scan.supplyChain, and the omission
+  // matters more than the secrets/logic one above because it hits nearly
+  // every real project. engine.js stamps every supplyChain entry
+  // not_available too (see the loop over `supplyChain` right after the
+  // `annotateGitProvenance` calls), and that bucket covers three distinct
+  // populations, not one:
+  //
+  //  - transitive `vulnerable_dep` findings: a genuine, if currently
+  //    unresolved, DEFERRAL — same shape as secrets/logicVulns above. The
+  //    vulnerable version was never declared in this repo's own manifests,
+  //    so there is no local commit to walk yet, but one could exist to
+  //    resolve in a later phase.
+  //  - `unpinned_dep` / `no_lockfile` findings: a CATEGORY ERROR, not a
+  //    deferral. These describe an ABSENT state (a version range with no
+  //    pin, a manifest with no lockfile) — there is no "commit that
+  //    introduced a missing lockfile" for any future resolver to find,
+  //    because the finding is about the absence of an event, not an event
+  //    itself. No amount of future engineering work makes these resolvable.
+  //
+  // Direct `vulnerable_dep` findings DO go through real origin resolution
+  // (`resolveDirectSCAOrigin`, gated on `isDirect`) and are not part of this
+  // limitation.
+  //
+  // Net effect: because `unpinned_dep`/`no_lockfile` findings are a category
+  // error rather than a deferral, `--assurance strict` will fail on nearly
+  // any real project that has a `package.json` (or equivalent manifest)
+  // today — an unpinned or unlocked dependency is common, and this check has
+  // no way to ever resolve one. This is a known, disclosed limitation of the
+  // current implementation, not a bug, and it is not something this check
+  // should route around: exempting these finding types from the strict-mode
+  // gate was considered and deliberately deferred to a future milestone
+  // rather than done here, so strict mode keeps refusing to vouch for
+  // provenance it cannot actually speak to.
+  const badProvenance = (Array.isArray(findings) ? findings : []).filter((f) => !(0,_posture_provenance_schema_js__WEBPACK_IMPORTED_MODULE_0__/* .isProvenanceHealthy */ .lL)(f?.findingProvenance));
+  if (badProvenance.length > 0) {
+    return {
+      ok: false,
+      mode: 'strict',
+      reason: `strict mode requires complete finding provenance; ${badProvenance.length} finding(s) have status outside [complete, uncommitted]`,
+      conditions,
+    };
+  }
+
   return { ok: true, mode: 'strict', reason: null, conditions };
 }