arkgate 4.8.24 → 4.8.26

package/bin/lib/resolved-candidate-facts.mjs

@@ -58,7 +58,7 @@ import {
   normalize,
 } from './scan-files.mjs';
 
-export const RESOLVED_FACTS_RESOLVER_IDENTITY = 'arkgate-typescript-resolver@1';
+const RESOLVED_FACTS_RESOLVER_IDENTITY = 'arkgate-typescript-resolver@1';
 
 const IN_MEMORY_STORES = new Set([
   'InMemoryAuditStore',
@@ -995,7 +995,8 @@ function objectLiteralHasProperty(ts, object, name) {
   );
 }
 
-function tsSuppressionPositions(sourceFile, source) {
+/** Start offsets of `@ts-ignore` directives and `@ts-nocheck` pragmas in a parsed file. */
+export function tsSuppressionPositions(sourceFile, source) {
   const positions = new Set();
   for (const directive of sourceFile.commentDirectives ?? []) {
     const start = directive.range?.pos;
@@ -1012,28 +1013,21 @@ function tsSuppressionPositions(sourceFile, source) {
   return [...positions];
 }
 
-function collectSafetyUses(ts, sourceFile, relativePath, source, dependencies) {
-  const facts = tsSuppressionPositions(sourceFile, source).map((position) => ({
-    file: relativePath,
-    line: lineOf(sourceFile, position),
-    kind: 'ts-suppression',
-  }));
-  for (const dependency of dependencies) {
-    if (!dependency.unresolved) continue;
-    facts.push({
-      file: relativePath,
-      line: dependency.line,
-      kind: dependency.kind === 'require' ? 'dynamic-require' : 'dynamic-import',
-    });
-  }
+const ARKGATE_RUNTIME_SPECIFIER = /^arkgate(?:\/runtime)?$/;
 
+/**
+ * Local bindings of the arkgate kernel factories whose omitted options fall back
+ * to in-memory stores: named imports (local name → factory) plus namespace
+ * imports of `arkgate` / `arkgate/runtime`.
+ */
+export function arkInMemoryFactoryBindings(ts, sourceFile) {
   const importedFactories = new Map();
   const arkNamespaces = new Set();
   for (const statement of sourceFile.statements) {
     if (!ts.isImportDeclaration(statement) || !ts.isStringLiteralLike(statement.moduleSpecifier)) {
       continue;
     }
-    if (!/^arkgate(?:\/runtime)?$/.test(statement.moduleSpecifier.text)) continue;
+    if (!ARKGATE_RUNTIME_SPECIFIER.test(statement.moduleSpecifier.text)) continue;
     const bindings = statement.importClause?.namedBindings;
     if (bindings && ts.isNamespaceImport(bindings)) arkNamespaces.add(bindings.name.text);
     if (!bindings || !ts.isNamedImports(bindings)) continue;
@@ -1043,6 +1037,71 @@ function collectSafetyUses(ts, sourceFile, relativePath, source, dependencies) {
       if (requirements) importedFactories.set(element.name.text, { imported, requirements });
     }
   }
+  return { importedFactories, arkNamespaces };
+}
+
+/** Named `InMemory*Store` imports of an arkgate import declaration. */
+export function arkInMemoryStoreImports(ts, node) {
+  const specifier = node.moduleSpecifier;
+  if (!ts.isStringLiteralLike(specifier) || !ARKGATE_RUNTIME_SPECIFIER.test(specifier.text)) {
+    return [];
+  }
+  const elements =
+    node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings)
+      ? node.importClause.namedBindings.elements
+      : [];
+  const out = [];
+  for (const element of elements) {
+    const imported = element.propertyName?.text ?? element.name.text;
+    if (IN_MEMORY_STORES.has(imported)) out.push({ element, imported });
+  }
+  return out;
+}
+
+/**
+ * The factory a call expression invokes when that call definitely takes the
+ * in-memory defaults (no options, `undefined`, or an object literal missing a
+ * required store); otherwise undefined.
+ */
+export function inMemoryDefaultsFactoryCall(ts, node, { importedFactories, arkNamespaces }) {
+  let factory;
+  if (ts.isIdentifier(node.expression)) {
+    factory = importedFactories.get(node.expression.text);
+  } else if (
+    ts.isPropertyAccessExpression(node.expression) &&
+    ts.isIdentifier(node.expression.expression) &&
+    arkNamespaces.has(node.expression.expression.text)
+  ) {
+    const imported = node.expression.name.text;
+    const requirements = IN_MEMORY_DEFAULT_FACTORIES.get(imported);
+    if (requirements) factory = { imported, requirements };
+  }
+  if (!factory) return undefined;
+  const options = node.arguments[0];
+  const definitelyDefaults =
+    !options ||
+    (ts.isIdentifier(options) && options.text === 'undefined') ||
+    (ts.isObjectLiteralExpression(options) &&
+      factory.requirements.some((name) => !objectLiteralHasProperty(ts, options, name)));
+  return definitelyDefaults ? factory : undefined;
+}
+
+function collectSafetyUses(ts, sourceFile, relativePath, source, dependencies) {
+  const facts = tsSuppressionPositions(sourceFile, source).map((position) => ({
+    file: relativePath,
+    line: lineOf(sourceFile, position),
+    kind: 'ts-suppression',
+  }));
+  for (const dependency of dependencies) {
+    if (!dependency.unresolved) continue;
+    facts.push({
+      file: relativePath,
+      line: dependency.line,
+      kind: dependency.kind === 'require' ? 'dynamic-require' : 'dynamic-import',
+    });
+  }
+
+  const factoryBindings = arkInMemoryFactoryBindings(ts, sourceFile);
 
   const visit = (node) => {
     if (
@@ -1057,56 +1116,25 @@ function collectSafetyUses(ts, sourceFile, relativePath, source, dependencies) {
     }
 
     if (ts.isImportDeclaration(node)) {
-      const specifier = node.moduleSpecifier;
-      const fromArk =
-        ts.isStringLiteralLike(specifier) && /^arkgate(?:\/runtime)?$/.test(specifier.text);
-      if (fromArk) {
-        const elements =
-          node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings)
-            ? node.importClause.namedBindings.elements
-            : [];
-        for (const element of elements) {
-          const imported = element.propertyName?.text ?? element.name.text;
-          if (IN_MEMORY_STORES.has(imported)) {
-            facts.push({
-              file: relativePath,
-              line: lineOf(sourceFile, element.getStart(sourceFile)),
-              kind: 'in-memory-store',
-              symbol: imported,
-            });
-          }
-        }
+      for (const { element, imported } of arkInMemoryStoreImports(ts, node)) {
+        facts.push({
+          file: relativePath,
+          line: lineOf(sourceFile, element.getStart(sourceFile)),
+          kind: 'in-memory-store',
+          symbol: imported,
+        });
       }
     }
 
     if (ts.isCallExpression(node)) {
-      let factory;
-      if (ts.isIdentifier(node.expression)) {
-        factory = importedFactories.get(node.expression.text);
-      } else if (
-        ts.isPropertyAccessExpression(node.expression) &&
-        ts.isIdentifier(node.expression.expression) &&
-        arkNamespaces.has(node.expression.expression.text)
-      ) {
-        const imported = node.expression.name.text;
-        const requirements = IN_MEMORY_DEFAULT_FACTORIES.get(imported);
-        if (requirements) factory = { imported, requirements };
-      }
+      const factory = inMemoryDefaultsFactoryCall(ts, node, factoryBindings);
       if (factory) {
-        const options = node.arguments[0];
-        const definitelyDefaults =
-          !options ||
-          (ts.isIdentifier(options) && options.text === 'undefined') ||
-          (ts.isObjectLiteralExpression(options) &&
-            factory.requirements.some((name) => !objectLiteralHasProperty(ts, options, name)));
-        if (definitelyDefaults) {
-          facts.push({
-            file: relativePath,
-            line: lineOf(sourceFile, node.getStart(sourceFile)),
-            kind: 'in-memory-store',
-            symbol: `${factory.imported} defaults`,
-          });
-        }
+        facts.push({
+          file: relativePath,
+          line: lineOf(sourceFile, node.getStart(sourceFile)),
+          kind: 'in-memory-store',
+          symbol: `${factory.imported} defaults`,
+        });
       }
     }
     ts.forEachChild(node, visit);

package/bin/lib/rules-under-contract.mjs

@@ -16,8 +16,8 @@ import {
   invariantIdsFromCatalog,
   loadInvariantCoverageInputs,
 } from './invariant-coverage-io.mjs';
+import { formatProbeStatusLines, probeStatusSection } from './invariant-probe-io.mjs';
 import {
-  EXTRA_MERGE_TEETH_GOVERNED_FLOOR,
   composeMergePlanesHonesty,
   demoteExtraPlaneTeethUnderClassificationFloor,
 } from './extra-merge-teeth.mjs';
@@ -39,8 +39,6 @@ const COVERED_SAMPLE_MAX = 24;
 const STRUCTURE_CATALOG_MAX = 40;
 const UNCOVERED_CATALOG_MAX = 30;
 
-export { EXTRA_MERGE_TEETH_GOVERNED_FLOOR };
-
 /** Doctor walk often hands absolute paths; layer globs are project-relative. */
 function projectRelativePath(root, filePath) {
   const posix = String(filePath).replace(/\\/g, '/');
@@ -100,6 +98,39 @@ function arkOrderMergeInput(config, residualCount = 0) {
   };
 }
 
+function rulesBySlice(arkRules) {
+  const groups = new Map();
+  const rows = [...(arkRules?.structure ?? []), ...(arkRules?.invariants ?? [])];
+  for (const entry of rows) {
+    const childId = entry?.provenance?.childId;
+    const sourceFile = entry?.provenance?.sourceFile;
+    if (typeof childId !== 'string' || typeof sourceFile !== 'string') continue;
+    const key = `${childId}\0${sourceFile}`;
+    let group = groups.get(key);
+    if (!group) {
+      group = {
+        slice: childId,
+        layer: entry.provenance?.layer ?? null,
+        sourceFile,
+        ids: [],
+        appliesTo: [],
+      };
+      groups.set(key, group);
+    }
+    if (typeof entry.id === 'string' && !group.ids.includes(entry.id)) group.ids.push(entry.id);
+    for (const pattern of entry.appliesTo ?? []) {
+      if (typeof pattern === 'string' && !group.appliesTo.includes(pattern)) group.appliesTo.push(pattern);
+    }
+  }
+  return [...groups.values()]
+    .map((group) => ({
+      ...group,
+      ids: [...group.ids].sort(),
+      appliesTo: [...group.appliesTo].sort(),
+    }))
+    .sort((left, right) => left.slice.localeCompare(right.slice) || left.sourceFile.localeCompare(right.sourceFile));
+}
+
 /** ADR 0012 D2 drift: arkrules/*.json no arkRules entry references (advisory). */
 function unreferencedArkRulesFiles(loaded) {
   const files = (loaded?.warnings ?? []).map((w) => w.path).filter(Boolean);
@@ -110,11 +141,32 @@ function unreferencedArkRulesFiles(loaded) {
  * @param {{ rulesMigration?: boolean }} [options] rulesMigration:false skips the
  *   migration counts (the inventory payload computes them itself).
  */
+function governedPathsFromFacts(root, facts) {
+  const rows = facts?.files;
+  if (!Array.isArray(rows) || rows.length === 0) return undefined;
+  const base = String(root).replace(/\\/g, '/').replace(/\/+$/, '');
+  const prefix = `${base}/`;
+  const out = [];
+  for (const entry of rows) {
+    const raw = typeof entry === 'string' ? entry : entry?.path;
+    if (typeof raw !== 'string' || raw.length === 0) continue;
+    const norm = raw.replace(/\\/g, '/');
+    const rel = norm.startsWith(prefix)
+      ? norm.slice(prefix.length)
+      : norm.replace(/^\.\//, '');
+    if (!rel || rel.startsWith('..') || rel.startsWith('/')) continue;
+    out.push(rel);
+  }
+  return out.length > 0 ? out : undefined;
+}
+
 export function summarizeRulesUnderContract(root, config, facts, classification, options = {}) {
+  const governedFiles = governedPathsFromFacts(root, facts);
+  const loadOpts = governedFiles ? { files: governedFiles } : {};
   if (!config?.arkRules || Object.keys(config.arkRules).length === 0) {
     let drift = {};
     try {
-      drift = unreferencedArkRulesFiles(loadEffectiveArkRulesFromDisk(root, config));
+      drift = unreferencedArkRulesFiles(loadEffectiveArkRulesFromDisk(root, config, loadOpts));
     } catch {
       drift = {};
     }
@@ -136,7 +188,7 @@ export function summarizeRulesUnderContract(root, config, facts, classification,
     };
   }
   try {
-    const loaded = loadEffectiveArkRulesFromDisk(root, config);
+    const loaded = loadEffectiveArkRulesFromDisk(root, config, loadOpts);
     if (loaded.errors?.length) {
       return {
         active: true,
@@ -167,6 +219,7 @@ export function summarizeRulesUnderContract(root, config, facts, classification,
     const covById = new Map(
       (coverage.coverage ?? []).map((row) => [row.invariantId, row])
     );
+    const probeSection = probeStatusSection(root, loaded.arkRules.invariants);
     const byLayer = loaded.arkRules.byLayer ?? {};
     const layers = Object.keys(byLayer)
       .sort((a, b) => a.localeCompare(b))
@@ -180,6 +233,7 @@ export function summarizeRulesUnderContract(root, config, facts, classification,
         return {
           name,
           sourceFile: part.sourceFile ?? null,
+          ...(Array.isArray(part.sourceFiles) ? { sourceFiles: [...part.sourceFiles] } : {}),
           structureRules: (part.structure ?? []).length,
           invariants: layerInvariants.length,
           coveredInvariants: covered,
@@ -280,6 +334,7 @@ export function summarizeRulesUnderContract(root, config, facts, classification,
       partialCoverage: coverage.partial,
       testFilesScanned: coverageInputs.testFiles.length,
       layers,
+      ...(rulesBySlice(loaded.arkRules).length > 0 ? { bySlice: rulesBySlice(loaded.arkRules) } : {}),
       structure,
       structureTruncated,
       uncovered,
@@ -296,6 +351,8 @@ export function summarizeRulesUnderContract(root, config, facts, classification,
               .rulesMigration,
           }),
       ...(coverageInputs.stats ? { coverageStats: coverageInputs.stats } : {}),
+      // ADR 0039: only when a probe artifact exists — absence stays silent.
+      ...(probeSection ? { probe: probeSection } : {}),
       mergePlanes,
       notAScore: true,
       note: 'ArkRules plane (intra-layer) — counts and catalog, never a score. Green with uncovered residual must say so. Structure sensors are heuristics; invariants are catalog+coverage evidence, not a business runtime.',
@@ -335,6 +392,7 @@ export function formatArkRulesEvidenceLines(section) {
   }
   const discard = formatCoverageDiscards(section.coverageStats);
   if (discard) lines.push(`ArkRules:${discard}`);
+  lines.push(...formatProbeStatusLines(section.probe));
   return lines;
 }
 
@@ -621,7 +679,7 @@ export function formatRulesUnderContractHtml(section, esc) {
   </section>`;
 }
 
-export const RULES_INVENTORY_MAX_FILES = 400;
+const RULES_INVENTORY_MAX_FILES = 400;
 
 /**
  * Brownfield rules migration (AR13/AR15): one code path for `--rules-inventory`,
@@ -633,7 +691,7 @@ export const RULES_INVENTORY_MAX_FILES = 400;
  * @param {{ root: string, config: Record<string, any>, files?: string[], arkRules?: any }} input
  *   `files` defaults to the governed walk; `arkRules` to the catalog on disk.
  */
-export function buildRulesMigration({ root, config, files, arkRules }) {
+function buildRulesMigration({ root, config, files, arkRules }) {
   const governed = Array.isArray(files) ? files : collectGovernedFiles(root, config);
   const fileContents = {};
   const fileLayers = {};
@@ -651,7 +709,12 @@ export function buildRulesMigration({ root, config, files, arkRules }) {
   let catalog = arkRules;
   if (catalog === undefined && config?.arkRules) {
     try {
-      const loaded = loadEffectiveArkRulesFromDisk(root, config);
+      const loaded = loadEffectiveArkRulesFromDisk(root, config, {
+        files: governed.map((file) => {
+          const absolute = path.isAbsolute(file) ? file : path.resolve(root, file);
+          return path.relative(root, absolute).split(path.sep).join('/');
+        }),
+      });
       catalog = loaded.errors.length > 0 ? null : loaded.arkRules;
     } catch {
       catalog = null; // the advisory inventory is still useful
@@ -730,6 +793,7 @@ export function buildRulesInventoryPayload(root, config, files) {
         coverageEvidence = {
           symbolEvidence: section.symbolEvidence ?? [],
           discarded: section.coverageStats?.discarded ?? null,
+          ...(section.probe ? { probe: section.probe } : {}),
         };
       }
     } catch {

package/bin/lib/scan-files.mjs

@@ -8,12 +8,12 @@ import { isScanExcludedRelative, isSkippedSourceDir } from '../ark-shared.mjs';
 
 export { isSkippedSourceDir };
 
-export const SOURCE_FILE_NAME = /\.[cm]?[tj]sx?$/;
+const SOURCE_FILE_NAME = /\.[cm]?[tj]sx?$/;
 
 /** Unit/e2e test files are not architecture surface — agents and Nest put them next
  *  to production code (*.spec.ts). Counting them as ungoverned forces false
  *  CONFIG_UNCLASSIFIED_FILES under --strict-config on every starter. */
-export const TEST_FILE_NAME =
+const TEST_FILE_NAME =
   /(^test(?:[-_.]).*|\.(spec|test)(?:-d)?\.)(tsx?|jsx?|mjsx?|cjsx?|mts|cts)$/i;
 
 export function isGovernableSourceFile(name) {
@@ -123,7 +123,7 @@ export function walk(dir, files = [], options = {}) {
 }
 
 /** Walk include roots then drop codegen / config.exclude (universal scan filter). */
-export function isIncludeMatch(relativePath, include) {
+function isIncludeMatch(relativePath, include) {
   return (include ?? []).some((entry) => {
     const includeRoot = String(entry)
       .replace(/\\/g, '/')
@@ -192,7 +192,7 @@ export function normalize(value) {
 export const UNGOVERNED_PROBE_CAP = 200;
 
 /** Tooling configs (vite.config.ts, eslint.config.js …) are not the product source a contract governs. */
-export const TOOLING_CONFIG_FILE_NAME = /\.config\.[cm]?[jt]sx?$/i;
+const TOOLING_CONFIG_FILE_NAME = /\.config\.[cm]?[jt]sx?$/i;
 
 /**
  * Count governable source files under `root` that the contract's own scope cannot hide.

package/bin/lib/schema-validation.mjs

@@ -0,0 +1,130 @@
+/**
+ * GENERATED FILE — do not edit by hand.
+ *
+ * Canonical algorithm: src/domain/schemaValidation.ts
+ * Regenerate: node scripts/generate-cli-pure.mjs
+ * Drift check: node scripts/generate-cli-pure.mjs --check
+ *
+ * Pure CLI helper (bin/lib/schema-validation.mjs). Zero Node I/O.
+ */
+
+export function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function propertyPath(parent, key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
+        ? `${parent}.${key}`
+        : `${parent}[${JSON.stringify(key)}]`;
+}
+export function valueType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
+function resolveSchemaRef(ref, root) {
+    const prefix = '#/$defs/';
+    if (!ref.startsWith(prefix))
+        return undefined;
+    return root.$defs[ref.slice(prefix.length)];
+}
+/** Walk `value` against `schema`, appending every finding to `issues`. */
+export function validateSchemaNode(value, schema, path, root, issues) {
+    if (schema.$ref) {
+        const referenced = resolveSchemaRef(schema.$ref, root);
+        if (!referenced) {
+            issues.push({ path, message: `schema reference ${schema.$ref} cannot be resolved` });
+            return;
+        }
+        validateSchemaNode(value, referenced, path, root, issues);
+        return;
+    }
+    if (schema.const !== undefined && !Object.is(value, schema.const)) {
+        issues.push({ path, message: `must equal ${JSON.stringify(schema.const)}` });
+        return;
+    }
+    if (schema.enum && !schema.enum.some((candidate) => Object.is(candidate, value))) {
+        issues.push({ path, message: `must be one of ${schema.enum.map(String).join(', ')}` });
+        return;
+    }
+    if (schema.type === 'object') {
+        if (!isObject(value)) {
+            issues.push({ path, message: `must be an object; received ${valueType(value)}` });
+            return;
+        }
+        const properties = schema.properties ?? {};
+        for (const key of schema.required ?? []) {
+            if (value[key] === undefined) {
+                issues.push({ path: propertyPath(path, key), message: 'is required' });
+            }
+        }
+        if (schema.additionalProperties === false) {
+            for (const key of Object.keys(value)) {
+                if (!(key in properties)) {
+                    issues.push({ path: propertyPath(path, key), message: 'unknown field' });
+                }
+            }
+        }
+        else if (schema.additionalProperties !== undefined &&
+            schema.additionalProperties !== true &&
+            typeof schema.additionalProperties === 'object') {
+            const additional = schema.additionalProperties;
+            for (const key of Object.keys(value)) {
+                if (!(key in properties)) {
+                    validateSchemaNode(value[key], additional, propertyPath(path, key), root, issues);
+                }
+            }
+        }
+        for (const [key, childSchema] of Object.entries(properties)) {
+            if (value[key] !== undefined) {
+                validateSchemaNode(value[key], childSchema, propertyPath(path, key), root, issues);
+            }
+        }
+        return;
+    }
+    if (schema.type === 'array') {
+        if (!Array.isArray(value)) {
+            issues.push({ path, message: `must be an array; received ${valueType(value)}` });
+            return;
+        }
+        if (schema.minItems !== undefined && value.length < schema.minItems) {
+            issues.push({ path, message: `must contain at least ${schema.minItems} item(s)` });
+        }
+        if (schema.uniqueItems) {
+            const serialized = value.map((entry) => JSON.stringify(entry));
+            if (new Set(serialized).size !== serialized.length) {
+                issues.push({ path, message: 'must not contain duplicate items' });
+            }
+        }
+        if (schema.items) {
+            value.forEach((entry, index) => validateSchemaNode(entry, schema.items, `${path}[${index}]`, root, issues));
+        }
+        return;
+    }
+    if (schema.type === 'string') {
+        if (typeof value !== 'string') {
+            issues.push({ path, message: `must be a string; received ${valueType(value)}` });
+            return;
+        }
+        if (schema.minLength !== undefined && value.length < schema.minLength) {
+            issues.push({ path, message: `must contain at least ${schema.minLength} character(s)` });
+        }
+        return;
+    }
+    if (schema.type === 'boolean') {
+        if (typeof value !== 'boolean') {
+            issues.push({ path, message: `must be a boolean; received ${valueType(value)}` });
+        }
+        return;
+    }
+    if (schema.type === 'integer') {
+        if (!Number.isInteger(value)) {
+            issues.push({ path, message: `must be an integer; received ${valueType(value)}` });
+            return;
+        }
+        if (schema.minimum !== undefined && value < schema.minimum) {
+            issues.push({ path, message: `must be at least ${schema.minimum}` });
+        }
+    }
+}

package/bin/lib/sensor-promote-cli.mjs

@@ -11,18 +11,9 @@ import path from 'node:path';
 
 import { arkCommand } from '../ark-shared.mjs';
 import { collectGovernedFiles, normalize } from './scan-files.mjs';
+// Same palette and TTY test as the entry's stderr output.
+import { color } from './violations.mjs';
 
-// Same shape and the same TTY test as the entry's own `color`: this module is
-// the only other writer to that terminal, and a second copy is cheaper than
-// exporting the entry's internals into a cycle.
-const useColor = process.stderr.isTTY && !process.env.NO_COLOR;
-const color = {
-  red: (s) => (useColor ? `\x1b[31m${s}\x1b[0m` : s),
-  yellow: (s) => (useColor ? `\x1b[33m${s}\x1b[0m` : s),
-  green: (s) => (useColor ? `\x1b[32m${s}\x1b[0m` : s),
-  dim: (s) => (useColor ? `\x1b[2m${s}\x1b[0m` : s),
-  bold: (s) => (useColor ? `\x1b[1m${s}\x1b[0m` : s),
-};
 
 /**
  * A rule id or a source path comes out of the project's own ArkRules JSON and

package/bin/lib/sensor-promote-io.mjs

@@ -16,6 +16,7 @@ import {
   invariantIdsFromCatalog,
   loadInvariantCoverageInputs,
 } from './invariant-coverage-io.mjs';
+import { attachProbeEvidence } from './invariant-probe-io.mjs';
 
 /**
  * The root as the filesystem sees it. Comparing a realpath against a lexical
@@ -79,28 +80,11 @@ export function loadSensorMap(root, config, facts) {
   }));
 
   const catalogued = loaded.arkRules.invariants ?? [];
-  let coverageRows = [];
-  let partial = false;
-  if (catalogued.length > 0) {
-    const inputs = loadInvariantCoverageInputs(root, facts ?? { files: [] }, {
-      invariantIds: invariantIdsFromCatalog(loaded.arkRules),
-      ...coverageOptionsFromConfig(config),
-    });
-    const coverage = evaluateInvariantCoverage({
-      arkRules: loaded.arkRules,
-      fileContents: inputs.fileContents,
-      testFiles: inputs.testFiles,
-      testGlobsMissing: inputs.testGlobsMissing,
-      coverageBudgetExhausted: inputs.coverageBudgetExhausted === true,
-      ...(inputs.stats ? { coverageStats: inputs.stats } : {}),
-      // The declared roots decide `outsideDeclaredRoots`, which is one of the
-      // four reasons canPromoteInvariant refuses. Dropping them here would make
-      // this surface promise a promotion the gate then denies.
-      ...(inputs.coverageRoots ? { coverageRoots: inputs.coverageRoots } : {}),
-    });
-    coverageRows = coverage.coverage ?? [];
-    partial = coverage.partial === true;
-  }
+  const evaluated = evaluateCatalogCoverage(root, config, facts, loaded.arkRules);
+  // ADR 0039: a committed probe artifact can only subtract promotability.
+  // Read-only here — this path never runs a test.
+  const coverageRows = attachProbeEvidence(root, evaluated.rows, catalogued).rows;
+  const partial = evaluated.partial;
   const evidenceById = new Map(coverageRows.map((row) => [row.invariantId, row]));
 
   const invariants = catalogued.map((entry) => ({
@@ -120,6 +104,33 @@ export function loadSensorMap(root, config, facts) {
   };
 }
 
+/**
+ * Invariant coverage rows for a loaded catalog, evaluated the way the
+ * promotion judge needs them (declared `coverageRoots` included). `inputs` is
+ * the loaded file set, reused by the probe to pick covering tests.
+ */
+export function evaluateCatalogCoverage(root, config, facts, arkRules) {
+  const catalogued = arkRules?.invariants ?? [];
+  if (catalogued.length === 0) return { rows: [], partial: false, inputs: null };
+  const inputs = loadInvariantCoverageInputs(root, facts ?? { files: [] }, {
+    invariantIds: invariantIdsFromCatalog(arkRules),
+    ...coverageOptionsFromConfig(config),
+  });
+  const coverage = evaluateInvariantCoverage({
+    arkRules,
+    fileContents: inputs.fileContents,
+    testFiles: inputs.testFiles,
+    testGlobsMissing: inputs.testGlobsMissing,
+    coverageBudgetExhausted: inputs.coverageBudgetExhausted === true,
+    ...(inputs.stats ? { coverageStats: inputs.stats } : {}),
+    // The declared roots decide `outsideDeclaredRoots`, which is one of the
+    // four reasons canPromoteInvariant refuses. Dropping them here would make
+    // this surface promise a promotion the gate then denies.
+    ...(inputs.coverageRoots ? { coverageRoots: inputs.coverageRoots } : {}),
+  });
+  return { rows: coverage.coverage ?? [], partial: coverage.partial === true, inputs };
+}
+
 /**
  * Count the findings each declared rule produced in an analysis that already
  * ran. One run answers for every rule: the loop this replaces was one full

package/bin/lib/sensor-promotion.mjs

@@ -188,7 +188,7 @@ export function buildSensorMap(input) {
             sourceFile,
             description: nullable(rule.description),
             promotable: verdict.ok,
-            blocker: verdict.ok ? null : 'no-coverage-evidence',
+            blocker: verdict.ok ? null : verdict.blocker ?? 'no-coverage-evidence',
             reason: `${locate(rule.id, sourceFile)}: ${verdict.reason}`,
             coverageEvaluated: rule.coverage != null,
             ...ambiguity(rule.id),

package/bin/lib/skill-catalog-apply.mjs

@@ -19,7 +19,7 @@ function skillName(skill) {
   return Array.isArray(skill) ? skill[0] : skill?.name || skill;
 }
 
-export function projectCatalogReady(root, skillNames) {
+function projectCatalogReady(root, skillNames) {
   return skillNames.some((name) => fs.existsSync(path.join(root, canonicalSkillPath(name))));
 }