magenta-canon 0.6.0 → 0.8.0

package/README.md

@@ -236,6 +236,10 @@ magenta-canon sentinel repository        # invariant-check a git repository
 magenta-canon sentinel artifact <tgz|dir>  # invariant-check a packed artifact
 magenta-canon sentinel pack              # npm pack, then check the result
 magenta-canon sentinel witness --ledger ledger.jsonl  # witness rotation-authority check
+magenta-canon sentinel ledger ledger.jsonl  # ledger truth: sequence, chains, Merkle, checkpoints (new in 0.7.0)
+magenta-canon sentinel execution bundle.json      # authority-bound action evidence (new in 0.8.0)
+magenta-canon sentinel configuration config.json  # one operation, one canonical authority path (new in 0.8.0)
+magenta-canon sentinel mirror records.jsonl       # independent checkpoint observation (new in 0.8.0)
 magenta-canon sentinel invariants        # list the invariant registry
 ```
 
@@ -246,15 +250,52 @@ retired-key resurrection / pre-activation refusal, and keystore↔ledger
 agreement — re-derived independently from the published wire formats, so it
 can disagree with a wrong (or compromised) server.
 
+The **Ledger Sentinel** (MC-LEDGER-001…021, new in 0.7.0) is the independent
+judge of ledger truth: contiguous receipt sequence, hash-chain and issuer
+signatures, RFC 6962 Merkle re-derivation, checkpoint monotonicity and
+equivocation refusal, corruption fail-closed vs bounded crash-tail
+quarantine, writer/lock authority (never auto-stolen), witness agreement,
+and mirror consistency. It reports five distinct outcomes — integrity /
+origin (pinned anchor only) / operational exclusivity (lock metadata only) /
+not-evaluated / violation — and is the contract any future storage backend
+(PostgreSQL, hosted) must satisfy before carrying authority
+([`docs/LEDGER_SENTINEL.md`](docs/LEDGER_SENTINEL.md), ships in the package).
+
+#### Sentinel Mesh V1 — complete in 0.8.0
+
+Magenta Canon 0.8.0 completes the **Sentinel Mesh V1**: eight sentinels plus a
+coordinator, **105 ratified invariants** across twelve domains, every one with
+a named enforcer (the coverage law is a CI gate), zero live reserved entries.
+The three sentinels added in 0.8.0 are:
+
+- **Execution Sentinel** (MC-EXEC-001…014) — binds a governed action to the
+  signature-authenticated receipt's committed `action_hash`, never to operator
+  params; a refused action that appears downstream, or a missing receipt, is
+  caught.
+- **Configuration & Dual-Authority Sentinel** (MC-CONFIG-001…014) — enforces
+  one operation, one canonical authority path; independently enumerates
+  configuration sources, precedence, fallbacks, and reviewed↔effective drift.
+- **Mirror Sentinel** (MC-MIRROR-001…012) — re-derives a `magenta-mirror/1`
+  observation stream independently of the mirror that wrote it: record-hash
+  chain, STH signatures, anti-equivocation across all observed sizes.
+
+Two meta-sentinels close the mesh: the **Anomaly Sentinel** (MC-ANOM-001…004)
+is the Attack KB's regression memory — a ratified attack that stops being
+detected fails the build — and the **Sentinel Coordinator** (MC-COORD-001…003)
+combines per-sentinel findings into one scoped, deterministic, tamper-evident
+`magenta-sentinel-report/1` **without** overriding, downgrading, or suppressing
+any finding, freezing only the affected authority class. Full inventory,
+limitations, and the V1 boundary:
+[`docs/SENTINEL_MESH_V1_COMPLETION.md`](docs/SENTINEL_MESH_V1_COMPLETION.md).
+
 Sentinels are read-only, redacting (paths + fingerprints, never secret
 bodies), deterministic, network-free, and emit `magenta-sentinel-violation/1`
 evidence records; exit codes map to a scoped promotion decision (`eligible` /
 `blocked` / `requires-independent-review`). Records at this layer are
 **unsigned local diagnostics**, and the freeze is a release/build promotion
-gate — **not** a production kill switch, a hosted Sentinel service, or
-complete Mesh coverage (ledger/execution/configuration sentinels are future
-lanes). Honest scope and the full model:
-[`docs/SENTINEL_MESH.md`](docs/SENTINEL_MESH.md).
+gate — **not** a production kill switch, a hosted Sentinel service, continuous
+monitoring, or a probabilistic/unknown-threat detector. Honest scope and the
+full model: [`docs/SENTINEL_MESH.md`](docs/SENTINEL_MESH.md).
 
 ### From the repo vs. as a CLI
 

package/bin/magenta-canon.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 /**
  * magenta-canon — CLI entry point for the open-source reference implementation.
  *

package/dist/MANIFEST.json

@@ -3,7 +3,7 @@
   "scripts/demo-control-plane.js": "3a559f39d17c1a403988e731e053d0d071cbd41ab595fd6246910f852337ab2f",
   "scripts/intake-cli.js": "189014db22d6fccb034ed1a93ec11efe8905be820bc468366c68bb2cabaf8a97",
   "scripts/magenta-mirror.js": "cf701065f7a6e20f7f44a9b815396aeb5fe031c3f003bcd793b8014ea8801b85",
-  "scripts/magenta-sentinel.js": "0280d7584524201551c61a93beb1f2ee4964e76b0e44eb7c9d15a0f5a95cafdc",
+  "scripts/magenta-sentinel.js": "155efd7408d116e3cc100b1dfa406dbabe0107584663e702348fec9106bafb2a",
   "scripts/magenta-verify.js": "0bb65ef6ff1350789eecc4f0434ca94dcf3a89930f8ef1d62cc38100e18094ba",
   "scripts/mcp-gateway.js": "335923004b73511fe42ea0fc6f2e567afe8018dc95464a79027e4c2537e30de1",
   "server/agent-policy.js": "20dd9150f8244c33aaf14ecdf3a09f471210960d246cda9ab8d5abe0e8433518",
@@ -26,7 +26,11 @@
   "server/ledger.js": "9bf8f132e08d636070d2ede568b2eaf75810be245c90ecd5979d2d4de69af934",
   "server/persistence.js": "2e6b1d0b1c74babbd581780b028c2593256c5ec96c2d60f4c25159e3f54e4e3f",
   "server/sentinel/artifact-sentinel.js": "93bae917af313c9247f8062af148e7c25ccfd16d0507fa85e755c64056715f8d",
-  "server/sentinel/promotion.js": "68ac5e54eb8c07d5c75ba0d2325d595b1583557840cc46322b2053dd9924a0be",
+  "server/sentinel/configuration-sentinel.js": "f8dd82c0bed36ba402d3c2fb52c068048f3e87941671b000c233d0f04acbecdb",
+  "server/sentinel/execution-sentinel.js": "644753a33d23e4295809a6d684151848fa7b1a639d54a7782caf11b4a4cf0253",
+  "server/sentinel/ledger-sentinel.js": "37d1c7040ae2506454247d40b42bad6076273b577190eeb3a6571184849b1e71",
+  "server/sentinel/mirror-sentinel.js": "2761d1e3099f600b7346406301b15a4bb256c2655ca4cff77341be907a9d438d",
+  "server/sentinel/promotion.js": "fa91250f59ccbe6f9c4e327dc4cce41fe46aacca38df70835ae1a7bf1833fe9b",
   "server/sentinel/repository-sentinel.js": "722e973c8860cf281b29db8c4a22ec3cf473afcb088247916e8278d5e11638cf",
   "server/sentinel/rules.js": "ab24435df4f6f5b10f8b721fde37fe7fa894453648f17f04923cab56020c459f",
   "server/sentinel/tar-reader.js": "ded811eefebf3e4afa332d1bc0a48318cc22ad824222eb15b2dc08eb51048272",
@@ -39,7 +43,7 @@
   "server/witness.js": "b1a8209d4dae4ffafc3ca4a158474b369250472ba80cef03bd92048282be91a4",
   "shared/canonical.js": "476cee4b5c5702e8a2a198e79c2639cf8ff84000ffb92f68a04433ed2a2f5484",
   "shared/certificates.js": "7844e71a38e1b1324586c7d054b2f5c15222b86446318d1e6dea9bab504a4a73",
-  "shared/invariants.js": "414a2aac034c9b28d0e32fc4afefb9b9ab723ed465b4aba1f8da98dab08363d4",
+  "shared/invariants.js": "be71f2645e96d7c054954c9c99ded8f16e4d6dd2b6afd98b98d34938258555a8",
   "shared/schema.js": "f89190990e3826e44c722d5e8f5b39fd59b4d3fb9ec047229930a17604e4646c",
   "shared/terminating-kernel.js": "8e2aa68d47d6780e4a70822482e3e410924e9d1af843f301a487da0af37ed047"
 }

package/dist/scripts/magenta-sentinel.js

@@ -43,6 +43,10 @@ const path = __importStar(require("node:path"));
 const repository_sentinel_1 = require("../server/sentinel/repository-sentinel");
 const artifact_sentinel_1 = require("../server/sentinel/artifact-sentinel");
 const witness_sentinel_1 = require("../server/sentinel/witness-sentinel");
+const ledger_sentinel_1 = require("../server/sentinel/ledger-sentinel");
+const execution_sentinel_1 = require("../server/sentinel/execution-sentinel");
+const configuration_sentinel_1 = require("../server/sentinel/configuration-sentinel");
+const mirror_sentinel_1 = require("../server/sentinel/mirror-sentinel");
 const promotion_1 = require("../server/sentinel/promotion");
 const invariants_1 = require("../shared/invariants");
 const USAGE = `magenta-sentinel — deterministic invariant evaluation (Sentinel Mesh foundation)
@@ -53,6 +57,12 @@ Usage:
   sentinel pack [--json]
   sentinel witness --ledger <file> [--keystore <file>] [--passphrase-env <VAR>]
                    [--anchor <pubkey-hex>] [--json]
+  sentinel ledger <ledger.jsonl> [--anchor <pubkey-hex>] [--keystore <file>]
+                  [--passphrase-env <VAR>] [--mirror <mirror.jsonl>]
+                  [--no-lock-inspection] [--json]
+  sentinel execution <execution-bundle.json> [--json]
+  sentinel configuration <config-evidence.json> [--json]
+  sentinel mirror <mirror-records.jsonl> [--ledger <f>] [--second-mirror <f>] [--anchor <hex>] [--json]
   sentinel invariants [--json]
 
 Exit: 0 eligible/diagnostic-only · 1 blocked · 2 requires review · 3 usage/unreadable
@@ -169,6 +179,93 @@ try {
         }
         process.exit(exitFor(promo));
     }
+    else if (sub === "ledger") {
+        const target = argv.find((a) => !a.startsWith("-"));
+        if (!target) {
+            console.error("sentinel ledger: missing <ledger.jsonl>\n\n" + USAGE);
+            process.exit(3);
+        }
+        const keystore = option(argv, "--keystore");
+        const mirror = option(argv, "--mirror");
+        const res = (0, ledger_sentinel_1.runLedgerSentinel)({
+            ledgerPath: path.resolve(target),
+            anchorPubkey: option(argv, "--anchor") ?? option(argv, "--expected-witness-key"),
+            keystorePath: keystore ? path.resolve(keystore) : undefined,
+            passphraseEnv: option(argv, "--passphrase-env"),
+            mirrorPath: mirror ? path.resolve(mirror) : undefined,
+            inspectLock: !flag(argv, "--no-lock-inspection"),
+        });
+        const promo = (0, promotion_1.decidePromotion)({ subject: `ledger:${res.subject_identity}`, findings: res.findings, violations: res.violations });
+        if (json)
+            console.log(JSON.stringify({ result: res, promotion: promo }, null, 2));
+        else {
+            printHuman("ledger", `${res.subject_identity.slice(0, 26)}… (${res.record_count} records: ${res.receipt_count} receipts, ${res.checkpoint_count} STH, ${res.rotation_count} rotation(s))`, res, promo);
+            for (const n of res.not_evaluated)
+                console.log(`  [NOT EVALUATED] ${n.invariant_id}: ${n.reason}`);
+            if (res.incomplete_tail_quarantined)
+                console.log("  note: incomplete trailing append quarantined (carries no authority)");
+            if (res.witness_cross_run)
+                console.log(`  witness cross-run: ${res.witness_cross_run.failed.length === 0 ? "agrees" : "DISAGREES"} (tip ${res.witness_cross_run.tip_fingerprint ?? "-"})`);
+        }
+        process.exit(exitFor(promo));
+    }
+    else if (sub === "execution") {
+        const target = argv.find((a) => !a.startsWith("-"));
+        if (!target) {
+            console.error("sentinel execution: missing <execution-bundle.json>\n\n" + USAGE);
+            process.exit(3);
+        }
+        const res = (0, execution_sentinel_1.runExecutionSentinel)(path.resolve(target));
+        const promo = (0, promotion_1.decidePromotion)({ subject: `execution:${res.subject_identity}`, findings: res.findings, violations: res.violations });
+        if (json)
+            console.log(JSON.stringify({ result: res, promotion: promo }, null, 2));
+        else {
+            printHuman("execution", `${res.subject_identity.slice(0, 29)}… (${res.operation_count} op(s): ${res.executed_count} executed, ${res.refused_count} refused)`, res, promo);
+            for (const n of res.not_evaluated)
+                console.log(`  [NOT EVALUATED] ${n.invariant_id}: ${n.reason}`);
+        }
+        process.exit(exitFor(promo));
+    }
+    else if (sub === "configuration" || sub === "config") {
+        const target = argv.find((a) => !a.startsWith("-"));
+        if (!target) {
+            console.error("sentinel configuration: missing <config-evidence.json>\n\n" + USAGE);
+            process.exit(3);
+        }
+        const res = (0, configuration_sentinel_1.runConfigurationSentinel)(path.resolve(target));
+        const promo = (0, promotion_1.decidePromotion)({ subject: `config:${res.subject_identity}`, findings: res.findings, violations: res.violations });
+        if (json)
+            console.log(JSON.stringify({ result: res, promotion: promo }, null, 2));
+        else {
+            printHuman("configuration", `${res.subject_identity.slice(0, 26)}… (${res.setting_count} setting(s))`, res, promo);
+            for (const n of res.not_evaluated)
+                console.log(`  [NOT EVALUATED] ${n.invariant_id}: ${n.reason}`);
+        }
+        process.exit(exitFor(promo));
+    }
+    else if (sub === "mirror") {
+        const target = argv.find((a) => !a.startsWith("-"));
+        if (!target) {
+            console.error("sentinel mirror: missing <mirror-records.jsonl>\n\n" + USAGE);
+            process.exit(3);
+        }
+        const ledger = option(argv, "--ledger");
+        const second = option(argv, "--second-mirror");
+        const res = (0, mirror_sentinel_1.runMirrorSentinel)(path.resolve(target), {
+            ledgerPath: ledger ? path.resolve(ledger) : undefined,
+            secondMirrorPath: second ? path.resolve(second) : undefined,
+            anchorPubkey: option(argv, "--anchor"),
+        });
+        const promo = (0, promotion_1.decidePromotion)({ subject: `mirror:${res.subject_identity}`, findings: res.findings, violations: res.violations });
+        if (json)
+            console.log(JSON.stringify({ result: res, promotion: promo }, null, 2));
+        else {
+            printHuman("mirror", `${res.subject_identity.slice(0, 26)}… (${res.record_count} observation(s), observer: ${res.observer_class})`, res, promo);
+            for (const n of res.not_evaluated)
+                console.log(`  [NOT EVALUATED] ${n.invariant_id}: ${n.reason}`);
+        }
+        process.exit(exitFor(promo));
+    }
     else if (sub === "invariants") {
         if (json)
             console.log(JSON.stringify(invariants_1.INVARIANTS, null, 2));

package/dist/server/sentinel/configuration-sentinel.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectStaleDist = exports.runConfigurationSentinel = exports.CONFIG_EVIDENCE_FORMAT = exports.CONFIG_SENTINEL_VERSION = exports.CONFIG_SENTINEL_TYPE = void 0;
+/**
+ * CONFIGURATION & DUAL-AUTHORITY SENTINEL — deterministic evaluation of
+ * configuration coherence invariants (MC-CONFIG-001…014) over a redacted
+ * configuration-evidence snapshot. Central principle: ONE operation has ONE
+ * canonical authority path.
+ *
+ * Subject: `magenta-config-evidence/1` — a normalized, redacted snapshot the
+ * operator (or a capture helper) assembles. It enumerates the actual
+ * configuration SOURCES and their fingerprints; it never carries secret
+ * values. The sentinel does NOT call the application's configuration loader
+ * and trust its final output — it independently enumerates source
+ * contradictions, precedence, fallbacks, and reviewed↔effective drift.
+ *
+ *   {
+ *     format: "magenta-config-evidence/1",
+ *     subject?: { repository?, tenant?, environment? },
+ *     settings: [{
+ *       key,                          // e.g. "witness.persistence"
+ *       authority_relevance: "witness"|"issuer"|"operator"|"none",
+ *       sources: [{ source, present:boolean, value_fingerprint?, secret?:boolean }],
+ *       precedence?: string[],        // ordered source names; the resolution order
+ *       effective_source?, effective_fingerprint?,
+ *       reviewed_fingerprint?,
+ *       configured_available?: boolean, // a configured backend/signer is reachable
+ *       observed_fallback?: "none"|"memory"|"ephemeral-signer"|"blank-ledger",
+ *     }],
+ *     active_witness_signers?: string[],   // fingerprints
+ *     active_receipt_issuers?: string[],   // fingerprints
+ *     writer_authorities?: string[],
+ *     stale_dist?: { is_checkout:boolean, source_fingerprint?, dist_fingerprint? },
+ *   }
+ *
+ * Read-only, redacting (fingerprints only — never values), deterministic,
+ * network-free. Missing runtime evidence → NOT-EVALUATED, never a pass.
+ */
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const invariants_1 = require("../../shared/invariants");
+const violation_1 = require("./violation");
+exports.CONFIG_SENTINEL_TYPE = "configuration-sentinel";
+exports.CONFIG_SENTINEL_VERSION = "1.0.0";
+exports.CONFIG_EVIDENCE_FORMAT = "magenta-config-evidence/1";
+/** Heartbeat-revival markers in any source name/value fingerprint key. */
+const HEARTBEAT_MARKERS = ["heartbeat-loop", "reality-adapter", "migration-hub", "BRAIN_HUB", "ACCESS_TOKEN"];
+function finding(invId, observed, expected, paths) {
+    const inv = (0, invariants_1.getInvariant)(invId);
+    return {
+        invariant_id: inv.id, invariant_version: inv.version, severity: inv.severity,
+        authority_class: inv.authorityClass, disposition: inv.disposition,
+        observed, expected, paths: paths.sort(),
+    };
+}
+function presentSources(setting) {
+    return (setting.sources ?? []).filter((s) => s.present).map((s) => s.source);
+}
+function runConfigurationSentinel(snapshotPath, opts = {}) {
+    if (!(0, node_fs_1.existsSync)(snapshotPath))
+        throw new Error(`configuration-sentinel: snapshot not found: ${snapshotPath}`);
+    const raw = (0, node_fs_1.readFileSync)(snapshotPath);
+    const subjectIdentity = `config:${(0, node_crypto_1.createHash)("sha256").update(raw).digest("hex")}`;
+    let snap;
+    try {
+        snap = JSON.parse(raw.toString("utf8"));
+    }
+    catch {
+        throw new Error("configuration-sentinel: snapshot is not valid JSON — refusing to guess");
+    }
+    if (snap.format !== exports.CONFIG_EVIDENCE_FORMAT)
+        throw new Error(`configuration-sentinel: unsupported format '${snap.format}'`);
+    const settings = Array.isArray(snap.settings) ? snap.settings : [];
+    const findings = [];
+    const notEvaluated = [];
+    const noteNE = (id, reason) => { if (!notEvaluated.some((n) => n.invariant_id === id))
+        notEvaluated.push({ invariant_id: id, reason }); };
+    const byKey = (k) => settings.find((s) => s.key === k);
+    // ── MC-CONFIG-001 / 006: witness persistence single authority ─────────
+    const witnessPersistence = byKey("witness.persistence") ?? byKey("witness");
+    if (witnessPersistence) {
+        const present = presentSources(witnessPersistence);
+        const hasKeystore = present.some((p) => /keyfile|keystore/i.test(p));
+        const hasEnvKeys = present.some((p) => /witness_secret|witness_public|env-?key/i.test(p));
+        const hasStateFile = present.some((p) => /state_file|state-file/i.test(p));
+        if (hasKeystore && hasEnvKeys) {
+            findings.push(finding("MC-CONFIG-001", `witness keystore AND env witness keys both configured (${present.join(", ")})`, "one witness-persistence authority", ["witness.persistence"]));
+        }
+        if (hasKeystore && hasStateFile) {
+            findings.push(finding("MC-CONFIG-006", `witness keystore AND legacy state file both configured (${present.join(", ")})`, "keystore mode forbids MAGENTA_STATE_FILE", ["witness.persistence"]));
+        }
+    }
+    else
+        noteNE("MC-CONFIG-001", "no witness.persistence setting in the snapshot");
+    // ── MC-CONFIG-002: single evidence authority ──────────────────────────
+    const evidence = byKey("evidence.persistence") ?? byKey("ledger");
+    if (evidence) {
+        const present = presentSources(evidence);
+        const hasLedger = present.some((p) => /ledger_file|ledger-file|file-?ledger/i.test(p));
+        const hasState = present.some((p) => /state_file|state-file/i.test(p));
+        if (hasLedger && hasState)
+            findings.push(finding("MC-CONFIG-002", `file ledger AND legacy state file both claim evidence authority (${present.join(", ")})`, "one evidence authority", ["evidence.persistence"]));
+    }
+    else
+        noteNE("MC-CONFIG-002", "no evidence.persistence setting in the snapshot");
+    // ── MC-CONFIG-003/004/011: single active signer/issuer/writer ─────────
+    const sig = snap.active_witness_signers;
+    if (Array.isArray(sig)) {
+        if (sig.length > 1)
+            findings.push(finding("MC-CONFIG-003", `${sig.length} active witness signers`, "exactly one active witness signer", ["active_witness_signers"]));
+    }
+    else
+        noteNE("MC-CONFIG-003", "no active_witness_signers evidence");
+    const iss = snap.active_receipt_issuers;
+    if (Array.isArray(iss)) {
+        if (iss.length > 1)
+            findings.push(finding("MC-CONFIG-004", `${iss.length} active receipt issuers`, "exactly one active receipt issuer", ["active_receipt_issuers"]));
+    }
+    else
+        noteNE("MC-CONFIG-004", "no active_receipt_issuers evidence");
+    const wr = snap.writer_authorities;
+    if (Array.isArray(wr)) {
+        if (wr.length > 1)
+            findings.push(finding("MC-CONFIG-011", `${wr.length} writer authorities configured`, "exactly one writer authority", ["writer_authorities"]));
+    }
+    else
+        noteNE("MC-CONFIG-011", "no writer_authorities evidence");
+    // ── per-setting checks: precedence / reviewed-drift / fallback / heartbeat ─
+    let anyReviewed = false;
+    let anyAvailability = false;
+    for (const setting of settings) {
+        const key = setting.key;
+        const present = presentSources(setting);
+        // MC-CONFIG-005: defined precedence when >1 source competes
+        if (present.length > 1) {
+            const prec = setting.precedence;
+            const covers = prec && present.every((p) => prec.includes(p)) && new Set(prec).size === prec.length;
+            if (!covers)
+                findings.push(finding("MC-CONFIG-005", `setting '${key}' has ${present.length} competing sources without a complete, non-circular precedence`, "defined precedence over all present sources", [key]));
+        }
+        // MC-CONFIG-007: reviewed == effective
+        if (setting.reviewed_fingerprint !== undefined) {
+            anyReviewed = true;
+            if (setting.effective_fingerprint !== undefined && setting.reviewed_fingerprint !== setting.effective_fingerprint) {
+                findings.push(finding("MC-CONFIG-007", `setting '${key}': reviewed fingerprint != effective runtime fingerprint`, "reviewed configuration equals runtime", [key]));
+            }
+        }
+        // MC-CONFIG-009/010: fallback weakening
+        if (setting.configured_available === false) {
+            anyAvailability = true;
+            const fb = setting.observed_fallback ?? "none";
+            if (fb === "memory" || fb === "blank-ledger")
+                findings.push(finding("MC-CONFIG-009", `setting '${key}': configured durable backend unavailable but fell back to '${fb}'`, "unavailable durability fails closed", [key]));
+            if (fb === "ephemeral-signer")
+                findings.push(finding("MC-CONFIG-010", `setting '${key}': configured signer unavailable but an ephemeral signer was generated`, "unavailable signer fails closed", [key]));
+        }
+        // MC-CONFIG-013: heartbeat revival in any source name
+        for (const src of (setting.sources ?? [])) {
+            if (HEARTBEAT_MARKERS.some((m) => String(src.source).includes(m))) {
+                findings.push(finding("MC-CONFIG-013", `setting '${key}': revived deprecated heartbeat source '${src.source}'`, "no heartbeat configuration", [key]));
+            }
+        }
+    }
+    if (!anyReviewed)
+        noteNE("MC-CONFIG-007", "no reviewed fingerprints supplied");
+    if (!anyAvailability) {
+        noteNE("MC-CONFIG-009", "no backend-availability evidence");
+        noteNE("MC-CONFIG-010", "no signer-availability evidence");
+    }
+    // ── MC-CONFIG-008: mixed environment credentials ──────────────────────
+    const envLabels = new Set();
+    for (const setting of settings)
+        for (const src of (setting.sources ?? []))
+            if (src.present && src.environment)
+                envLabels.add(src.environment);
+    if (envLabels.size === 0)
+        noteNE("MC-CONFIG-008", "no per-source environment labels");
+    else if (envLabels.has("production") && envLabels.has("development")) {
+        findings.push(finding("MC-CONFIG-008", `effective configuration mixes environments: ${Array.from(envLabels).join(", ")}`, "one explicit, consistent environment", ["environment"]));
+    }
+    // ── MC-CONFIG-012: tenant/repo identity coherence ─────────────────────
+    const idValues = new Map();
+    for (const setting of settings) {
+        if (setting.key === "tenant" || setting.key === "repository") {
+            const vals = new Set((setting.sources ?? []).filter((s) => s.present && s.value_fingerprint).map((s) => s.value_fingerprint));
+            if (vals.size > 0)
+                idValues.set(setting.key, vals);
+        }
+    }
+    for (const [k, vals] of Array.from(idValues)) {
+        if (vals.size > 1)
+            findings.push(finding("MC-CONFIG-012", `${k} identity disagrees across sources (${vals.size} distinct fingerprints)`, "coherent tenant/repo identity", [k]));
+    }
+    if (idValues.size === 0)
+        noteNE("MC-CONFIG-012", "no tenant/repository identity evidence");
+    // ── MC-CONFIG-014: stale dist ─────────────────────────────────────────
+    const sd = snap.stale_dist;
+    if (!sd)
+        noteNE("MC-CONFIG-014", "no stale-dist fingerprint evidence");
+    else if (sd.is_checkout === false)
+        noteNE("MC-CONFIG-014", "installed package (compiled-first by design)");
+    else if (sd.source_fingerprint === undefined || sd.dist_fingerprint === undefined) {
+        noteNE("MC-CONFIG-014", "checkout without both source and dist fingerprints");
+    }
+    else if (sd.source_fingerprint !== sd.dist_fingerprint) {
+        findings.push(finding("MC-CONFIG-014", `repository checkout: dist build fingerprint does not match current source — stale compiled code would shadow source`, "dist matches source (or source-first launch)", ["stale_dist"]));
+    }
+    const configInvariants = (0, invariants_1.ratifiedInvariants)().filter((i) => i.domain === "configuration").map((i) => i.id);
+    const notEvalIds = new Set(notEvaluated.map((n) => n.invariant_id));
+    const failed = Array.from(new Set(findings.map((f) => f.invariant_id))).sort();
+    const evaluated = configInvariants.filter((id) => !notEvalIds.has(id) || failed.includes(id)).sort();
+    const passed = evaluated.filter((id) => !failed.includes(id)).sort();
+    const violations = findings.map((f) => (0, violation_1.buildViolationRecord)({
+        sentinelType: exports.CONFIG_SENTINEL_TYPE, sentinelVersion: exports.CONFIG_SENTINEL_VERSION,
+        subjectType: "artifact", subjectIdentity, finding: f,
+        detectedAt: opts.detectedAt, detector: opts.detector,
+    }));
+    return {
+        sentinel_type: exports.CONFIG_SENTINEL_TYPE, sentinel_version: exports.CONFIG_SENTINEL_VERSION,
+        subject_type: "artifact", subject_identity: subjectIdentity,
+        setting_count: settings.length,
+        evaluated_invariants: evaluated, not_evaluated: notEvaluated,
+        passed, failed, findings, violations,
+    };
+}
+exports.runConfigurationSentinel = runConfigurationSentinel;
+/**
+ * Repo-checkout stale-dist guard (runtime helper, repository-only). Computes a
+ * deterministic source fingerprint over the lean closure's .ts sources and
+ * compares it to dist/MANIFEST's recorded source fingerprint. npm consumers
+ * never call this (no dist/MANIFEST source-fingerprint field is required at
+ * runtime; the bin dispatcher remains compiled-first for installs).
+ */
+function detectStaleDist(repoRoot) {
+    const distManifest = `${repoRoot}/dist/MANIFEST.json`;
+    if (!(0, node_fs_1.existsSync)(distManifest))
+        return { is_checkout: true, stale: false, reason: "no dist/ present (source-first)" };
+    // A checkout has source files; an installed package ships only dist/.
+    const hasSource = (0, node_fs_1.existsSync)(`${repoRoot}/scripts/magenta-verify.ts`);
+    if (!hasSource)
+        return { is_checkout: false, stale: false, reason: "installed package (compiled-first)" };
+    return { is_checkout: true, stale: false, reason: "checkout with dist — supply fingerprints to the sentinel for MC-CONFIG-014" };
+}
+exports.detectStaleDist = detectStaleDist;