@vantageos/mcp-doctor 0.2.0 → 0.3.1

package/dist/doctor.js

@@ -1,31 +1,133 @@
 #!/usr/bin/env node
 
-// src/detectors/d2.ts
-var SESSION_RE = /mcp-session-id/i;
-var d2 = {
-  id: "D2 stateless",
+// src/doctor.ts
+import { readFileSync as readFileSync19, realpathSync } from "fs";
+import { dirname as dirname11, join as join21, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/detectors/c7-artifact-verifiable.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var PIN = "a74a042b53c71a095ab88b3073bd47728eeda814";
+var DOC_FILES = ["README.md", "README.fr.md"];
+var INSTALL_RE = /\b(?:npm\s+(?:install|i)|npx|pnpm\s+add|yarn\s+add)\s+(@?[\w./-]+)/i;
+var PIN_VERSION_RE = /@\d+\.\d+\.\d+/;
+var PROVENANCE_RE = /\b(?:provenance|sha-?256|sha-?512|checksum|gpg\s+signature|sigstore|cosign|--provenance)\b/i;
+var SECOND_CHANNEL_RE = /\bgithub\s+release|releases\/tag|releases\/download\b/i;
+function c7PositiveControls() {
+  const installSample = "npm install @vantageos/mcp-doctor";
+  const pinSample = "npm install @vantageos/mcp-doctor@1.2.3";
+  const bareSample = "npm install @vantageos/mcp-doctor";
+  const provenanceSample = "published with npm publish --provenance";
+  const channelSample = "also available as a GitHub release";
+  return {
+    installMatcher: {
+      pattern: INSTALL_RE.source,
+      sample: installSample,
+      matched: INSTALL_RE.test(installSample)
+    },
+    pinMatcher: {
+      pattern: PIN_VERSION_RE.source,
+      sample: pinSample,
+      matched: PIN_VERSION_RE.test(pinSample),
+      rejectsBare: !PIN_VERSION_RE.test(bareSample)
+    },
+    provenanceMatcher: {
+      pattern: PROVENANCE_RE.source,
+      sample: provenanceSample,
+      matched: PROVENANCE_RE.test(provenanceSample)
+    },
+    channelMatcher: {
+      pattern: SECOND_CHANNEL_RE.source,
+      sample: channelSample,
+      matched: SECOND_CHANNEL_RE.test(channelSample)
+    }
+  };
+}
+function readDocText(root) {
+  for (const name of DOC_FILES) {
+    const path = join(root, name);
+    if (!existsSync(path)) continue;
+    try {
+      return { text: readFileSync(path, "utf8"), file: name };
+    } catch {
+    }
+  }
+  return null;
+}
+var c7ArtifactVerifiable = {
+  id: "C7 artifact-verifiable",
+  rule: "C-7",
+  pin: PIN,
   run(tree) {
-    const hits = [];
-    for (const file of tree.files) {
-      for (const line of file.lines) {
-        if (line.comment) continue;
-        if (SESSION_RE.test(line.raw)) hits.push({ file: file.rel, line: line.n });
-      }
+    const controls = c7PositiveControls();
+    if (!controls.installMatcher.matched) {
+      throw new Error(
+        `C7 install-matcher control FAILED on \`${controls.installMatcher.sample}\` \u2014 matcher broken, verdict untrustworthy`
+      );
     }
-    if (hits.length > 0) {
-      const anchor = `${hits[0].file}:${hits.map((h) => h.line).join(",")}`;
+    if (!controls.pinMatcher.matched || !controls.pinMatcher.rejectsBare) {
+      throw new Error(
+        `C7 pin-matcher control FAILED: accept(\`${controls.pinMatcher.sample}\`)=${controls.pinMatcher.matched} rejectsBare=${controls.pinMatcher.rejectsBare} \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    if (!controls.provenanceMatcher.matched) {
+      throw new Error(
+        `C7 provenance-matcher control FAILED on \`${controls.provenanceMatcher.sample}\` \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    if (!controls.channelMatcher.matched) {
+      throw new Error(
+        `C7 channel-matcher control FAILED on \`${controls.channelMatcher.sample}\` \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    const doc = readDocText(tree.root);
+    if (!doc) {
       return {
         id: this.id,
-        anchor,
+        anchor: tree.root,
         state: "non-conforming",
-        verdict: "session-keyed (mcp-session-id header) -> migrate to stateless"
+        verdict: "no README.md/README.fr.md found -> a trunk rule governs every published object; no install-command surface to read (C-7)"
+      };
+    }
+    const installMatch = doc.text.match(INSTALL_RE);
+    if (!installMatch) {
+      return {
+        id: this.id,
+        anchor: `${doc.file}:1`,
+        state: "non-conforming",
+        verdict: `no one-command install naming a registry found in ${doc.file} -> add \`npm install <pkg>\`/\`npx <pkg>\` naming the registry (C-7a)`
+      };
+    }
+    if (!PIN_VERSION_RE.test(doc.text)) {
+      return {
+        id: this.id,
+        anchor: `${doc.file}:1`,
+        state: "non-conforming",
+        verdict: `install command present but no version-pin shape (\`@<version>\`) found in ${doc.file} -> document that an exact version can be pinned and rolled back (C-7b)`
+      };
+    }
+    if (!SECOND_CHANNEL_RE.test(doc.text)) {
+      return {
+        id: this.id,
+        anchor: `${doc.file}:1`,
+        state: "non-conforming",
+        verdict: `only one obtain channel found in ${doc.file} -> cite a second independent channel (e.g. GitHub release) alongside the registry (C-7d)`
+      };
+    }
+    if (!PROVENANCE_RE.test(doc.text)) {
+      return {
+        id: this.id,
+        anchor: `${doc.file}:1`,
+        state: "non-conforming",
+        verdict: `no provenance/checksum signal cited in ${doc.file} -> cite npm provenance or a published checksum (C-7c)`
       };
     }
     return {
       id: this.id,
-      anchor: "-",
+      anchor: `${doc.file}:1`,
       state: "present",
-      verdict: "stateless (no mcp-session-id session-keying)"
+      verdict: `${doc.file} declares a one-command pinned install, >=2 obtain channels, and a provenance/checksum signal (C-7a/b/c/d complete). Whether the cited signal actually RESOLVES against what the registry serves is the separate gate check at publish time \u2014 this static run asserts the declaration is complete, not that the gate has resolved it.`
     };
   }
 };
@@ -224,6 +326,208 @@ function sdkFirstAnchor(tree) {
   }
   return null;
 }
+var VERB_FIELD_RE = /\bverb\s*:\s*["'`]([A-Za-z][A-Za-z-]*)["'`]/;
+var TABLE_FIELD_RE = /\btable\s*:\s*["'`]([A-Za-z0-9_.-]+)["'`]/;
+var MECHANISM_FIELD_RE = /\b(?:searchMechanism|mechanism)\s*:\s*["'`]([A-Za-z0-9_-]+(?:\([^)]*\))?)["'`]/;
+var AUTH_READ_FIELD_RE = /\bauthRead\s*:\s*["'`]([A-Za-z-]+)["'`]/;
+var AUTH_WRITE_FIELD_RE = /\bauthWrite\s*:\s*["'`]([A-Za-z-]+)["'`]/;
+var AUTH_FOLDED_FIELD_RE = /\bauth\s*:\s*["'`]([A-Za-z-]+)["'`]/;
+var READ_ONLY_HINT_RE = /\breadOnlyHint\s*:\s*(?:true|false)\b/;
+var DESTRUCTIVE_HINT_RE = /\bdestructiveHint\s*:\s*(?:true|false)\b/;
+var IDEMPOTENT_HINT_RE = /\bidempotentHint\s*:\s*(?:true|false)\b/;
+var OPEN_WORLD_HINT_RE = /\bopenWorldHint\s*:\s*(?:true|false)\b/;
+var TOKENS_FIELD_RE = /\btokensEstimeContexte\s*:\s*(\d+)\b/;
+var PAGINATION_CURSOR_RE = /\bpaginationCursor\s*:\s*(?:true|false)\b/;
+var PAGINATION_DEFAULT_RE = /\bpaginationDefault\s*:\s*(\d+)\b/;
+var PAGINATION_MAX_RE = /\bpaginationMax\s*:\s*(\d+)\b/;
+function toolAnnotationFieldControls() {
+  const verbSample = 'annotations: { verb: "create", table: "customers" },';
+  const tableSample = 'annotations: { verb: "create", table: "customers" },';
+  const mechSample = 'annotations: { searchMechanism: "indexed-bm25" },';
+  const authPairSample = 'annotations: { authRead: "public", authWrite: "org-admin" },';
+  const authFoldedSample = 'annotations: { auth: "org-admin" },';
+  const hintsSample = "annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },";
+  const tokensSample = "annotations: { tokensEstimeContexte: 120 },";
+  const paginationSample = "annotations: { paginationCursor: true, paginationDefault: 20, paginationMax: 100 },";
+  const paginationUnboundedSample = "annotations: { paginationMax: Infinity },";
+  return {
+    verb: {
+      pattern: VERB_FIELD_RE.source,
+      sample: verbSample,
+      matched: VERB_FIELD_RE.test(verbSample)
+    },
+    table: {
+      pattern: TABLE_FIELD_RE.source,
+      sample: tableSample,
+      matched: TABLE_FIELD_RE.test(tableSample)
+    },
+    mechanism: {
+      pattern: MECHANISM_FIELD_RE.source,
+      sample: mechSample,
+      matched: MECHANISM_FIELD_RE.test(mechSample)
+    },
+    authRead: {
+      pattern: AUTH_READ_FIELD_RE.source,
+      sample: authPairSample,
+      matched: AUTH_READ_FIELD_RE.test(authPairSample)
+    },
+    authWrite: {
+      pattern: AUTH_WRITE_FIELD_RE.source,
+      sample: authPairSample,
+      matched: AUTH_WRITE_FIELD_RE.test(authPairSample)
+    },
+    authFolded: {
+      pattern: AUTH_FOLDED_FIELD_RE.source,
+      sample: authFoldedSample,
+      matched: AUTH_FOLDED_FIELD_RE.test(authFoldedSample) && !AUTH_READ_FIELD_RE.test(authFoldedSample)
+    },
+    behavioralHints: {
+      pattern: [
+        READ_ONLY_HINT_RE.source,
+        DESTRUCTIVE_HINT_RE.source,
+        IDEMPOTENT_HINT_RE.source,
+        OPEN_WORLD_HINT_RE.source
+      ].join(" & "),
+      sample: hintsSample,
+      matched: READ_ONLY_HINT_RE.test(hintsSample) && DESTRUCTIVE_HINT_RE.test(hintsSample) && IDEMPOTENT_HINT_RE.test(hintsSample) && OPEN_WORLD_HINT_RE.test(hintsSample)
+    },
+    tokensCtx: {
+      pattern: TOKENS_FIELD_RE.source,
+      sample: tokensSample,
+      matched: TOKENS_FIELD_RE.test(tokensSample)
+    },
+    pagination: {
+      pattern: [
+        PAGINATION_CURSOR_RE.source,
+        PAGINATION_DEFAULT_RE.source,
+        PAGINATION_MAX_RE.source
+      ].join(" & "),
+      sample: paginationSample,
+      matched: PAGINATION_CURSOR_RE.test(paginationSample) && PAGINATION_DEFAULT_RE.test(paginationSample) && PAGINATION_MAX_RE.test(paginationSample),
+      rejectsUnbounded: !PAGINATION_MAX_RE.test(paginationUnboundedSample)
+    }
+  };
+}
+var CALL_OPENER_LOOKBACK = 10;
+function callOpenerLine(file, siteLine) {
+  for (let n = siteLine; n >= Math.max(1, siteLine - CALL_OPENER_LOOKBACK); n--) {
+    const line = file.lines[n - 1];
+    if (!line || line.comment) continue;
+    if (TOOL_INLINE_LITERAL_RE.test(line.raw) || TOOL_INLINE_IDENT_RE.test(line.raw) || OPENER_RE.test(line.raw)) {
+      return line.n;
+    }
+  }
+  return siteLine;
+}
+function ownCallEnd(file, siteLine) {
+  const startLine = callOpenerLine(file, siteLine);
+  let depth = 0;
+  for (const line of file.lines) {
+    if (line.n < startLine) continue;
+    if (!line.comment) {
+      depth += (line.raw.match(/\(/g) ?? []).length - (line.raw.match(/\)/g) ?? []).length;
+    }
+    if (line.n >= startLine && depth <= 0 && line.n > startLine) return line.n;
+    if (line.n === startLine && depth <= 0) {
+      return line.n;
+    }
+  }
+  return file.lines.length;
+}
+function findToolAnnotations(tree) {
+  const allSites = findRegisteredTools(tree);
+  const out = [];
+  for (const file of tree.files) {
+    const prefix = `${file.rel}:`;
+    const sitesInFile = allSites.filter((s) => s.anchor.startsWith(prefix)).map((s) => ({ ...s, line: Number.parseInt(s.anchor.slice(prefix.length), 10) })).sort((a, b) => a.line - b.line).map((s) => ({ ...s, ownEnd: ownCallEnd(file, s.line) }));
+    for (let i = 0; i < sitesInFile.length; i++) {
+      const site = sitesInFile[i];
+      const windowStart = i === 0 ? 0 : sitesInFile[i - 1].ownEnd;
+      const windowEnd = site.ownEnd;
+      let verb;
+      let table;
+      let searchMechanism;
+      let authRead;
+      let authWrite;
+      let authFolded = false;
+      let readOnlyHintDeclared = false;
+      let destructiveHintDeclared = false;
+      let idempotentHintDeclared = false;
+      let openWorldHintDeclared = false;
+      let tokensEstimeContexte;
+      let paginationCursorDeclared = false;
+      let paginationDefault;
+      let paginationMax;
+      for (const line of file.lines) {
+        if (line.n <= windowStart || line.n > windowEnd) continue;
+        if (line.comment) continue;
+        const raw = line.raw;
+        if (!verb) {
+          const m = raw.match(VERB_FIELD_RE);
+          if (m) verb = m[1];
+        }
+        if (!table) {
+          const m = raw.match(TABLE_FIELD_RE);
+          if (m) table = m[1];
+        }
+        if (!searchMechanism) {
+          const m = raw.match(MECHANISM_FIELD_RE);
+          if (m) searchMechanism = m[1];
+        }
+        if (!authRead) {
+          const m = raw.match(AUTH_READ_FIELD_RE);
+          if (m) authRead = m[1];
+        }
+        if (!authWrite) {
+          const m = raw.match(AUTH_WRITE_FIELD_RE);
+          if (m) authWrite = m[1];
+        }
+        if (!authFolded && AUTH_FOLDED_FIELD_RE.test(raw) && !/\bauth(?:Read|Write)\s*:/.test(raw)) {
+          authFolded = true;
+        }
+        if (!readOnlyHintDeclared && READ_ONLY_HINT_RE.test(raw)) readOnlyHintDeclared = true;
+        if (!destructiveHintDeclared && DESTRUCTIVE_HINT_RE.test(raw))
+          destructiveHintDeclared = true;
+        if (!idempotentHintDeclared && IDEMPOTENT_HINT_RE.test(raw)) idempotentHintDeclared = true;
+        if (!openWorldHintDeclared && OPEN_WORLD_HINT_RE.test(raw)) openWorldHintDeclared = true;
+        if (tokensEstimeContexte === void 0) {
+          const m = raw.match(TOKENS_FIELD_RE);
+          if (m) tokensEstimeContexte = Number.parseInt(m[1], 10);
+        }
+        if (!paginationCursorDeclared && PAGINATION_CURSOR_RE.test(raw)) {
+          paginationCursorDeclared = true;
+        }
+        if (paginationDefault === void 0) {
+          const m = raw.match(PAGINATION_DEFAULT_RE);
+          if (m) paginationDefault = Number.parseInt(m[1], 10);
+        }
+        if (paginationMax === void 0) {
+          const m = raw.match(PAGINATION_MAX_RE);
+          if (m) paginationMax = Number.parseInt(m[1], 10);
+        }
+      }
+      out.push({
+        name: site.name,
+        anchor: site.anchor,
+        verb,
+        table,
+        searchMechanism,
+        authRead,
+        authWrite,
+        authFolded,
+        readOnlyHintDeclared,
+        destructiveHintDeclared,
+        idempotentHintDeclared,
+        openWorldHintDeclared,
+        tokensEstimeContexte,
+        paginationCursorDeclared,
+        paginationDefault,
+        paginationMax
+      });
+    }
+  }
+  return out;
+}
 function countKeywordInCode(tree, re) {
   let count = 0;
   let firstFile;
@@ -240,8 +544,2180 @@ function countKeywordInCode(tree, re) {
       }
     }
   }
-  return { count, firstFile, firstLine };
-}
+  return { count, firstFile, firstLine };
+}
+
+// src/detectors/c8-authority-declared.ts
+var TIER_SET = /* @__PURE__ */ new Set(["public", "org-member", "org-admin", "fleet-internal", "master"]);
+function c8PositiveControls() {
+  const controls = toolAnnotationFieldControls();
+  return {
+    authReadMatcher: controls.authRead,
+    authWriteMatcher: controls.authWrite,
+    authFoldedMatcher: controls.authFolded,
+    setAcceptsPublic: TIER_SET.has("public"),
+    setRejectsOutOfSet: !TIER_SET.has("superadmin")
+  };
+}
+function isFolded(t) {
+  return t.authFolded === true && t.authRead === void 0 && t.authWrite === void 0;
+}
+var c8AuthorityDeclared = {
+  id: "C8 authority-declared",
+  rule: "C-8",
+  pin: "a74a042b53c71a095ab88b3073bd47728eeda814",
+  run(tree) {
+    const controls = c8PositiveControls();
+    if (!controls.authReadMatcher.matched || !controls.authWriteMatcher.matched || !controls.authFoldedMatcher.matched) {
+      throw new Error(
+        `C8 positive control FAILED: authRead=${controls.authReadMatcher.matched} authWrite=${controls.authWriteMatcher.matched} folded=${controls.authFoldedMatcher.matched} \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    if (!controls.setAcceptsPublic || !controls.setRejectsOutOfSet) {
+      throw new Error(
+        "C8 closed-set control FAILED: TIER_SET must accept a legitimate tier (public) and reject an out-of-set value (superadmin) \u2014 verdict untrustworthy"
+      );
+    }
+    const unresolved = findUnresolvedToolSites(tree);
+    if (unresolved.length > 0) {
+      const reason = `tool name at ${unresolved.length} registration site(s) is computed/imported/template (${unresolved.join(", ")}) \u2014 declared authority unattributable statically (C-8)`;
+      return {
+        id: this.id,
+        anchor: unresolved[0],
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const tools = findToolAnnotations(tree);
+    if (tools.length === 0) {
+      return {
+        id: this.id,
+        anchor: "-",
+        state: "absent",
+        verdict: "no tool registrations found; authority-declared check n/a"
+      };
+    }
+    for (const t of tools) {
+      if (isFolded(t)) {
+        return {
+          id: this.id,
+          anchor: t.anchor,
+          state: "non-conforming",
+          verdict: `tool "${t.name}" declares a single folded "auth" field instead of the (authRead, authWrite) pair \u2014 folding erases the read/write divergence (positive-control OK) -> declare authRead and authWrite separately from the closed 5-tier set (C-8)`
+        };
+      }
+      if (!t.authRead || !t.authWrite) {
+        return {
+          id: this.id,
+          anchor: t.anchor,
+          state: "non-conforming",
+          verdict: `tool "${t.name}" is missing ${!t.authRead ? "authRead" : "authWrite"} (positive-control OK) -> declare the full (authRead, authWrite) pair from public/org-member/org-admin/fleet-internal/master (C-8)`
+        };
+      }
+      if (!TIER_SET.has(t.authRead)) {
+        return {
+          id: this.id,
+          anchor: t.anchor,
+          state: "non-conforming",
+          verdict: `tool "${t.name}" declares authRead "${t.authRead}", outside the closed 5-tier set (positive-control OK) -> use public/org-member/org-admin/fleet-internal/master (C-8)`
+        };
+      }
+      if (!TIER_SET.has(t.authWrite)) {
+        return {
+          id: this.id,
+          anchor: t.anchor,
+          state: "non-conforming",
+          verdict: `tool "${t.name}" declares authWrite "${t.authWrite}", outside the closed 5-tier set (positive-control OK) -> use public/org-member/org-admin/fleet-internal/master (C-8)`
+        };
+      }
+    }
+    return {
+      id: this.id,
+      anchor: tools[0].anchor,
+      state: "present",
+      verdict: `${tools.length} tool(s) each declare a distinct (authRead, authWrite) pair in the closed 5-tier set (positive-control OK)`
+    };
+  }
+};
+
+// src/detectors/c9-verb-declared.ts
+var VERB_SET = /* @__PURE__ */ new Set([
+  "list",
+  "get",
+  "search",
+  "aggregate",
+  "create",
+  "update",
+  "delete",
+  "upsert",
+  "transition",
+  "bulk-write",
+  "pure",
+  "introspect",
+  "external-effect"
+]);
+function c9PositiveControls() {
+  const field = toolAnnotationFieldControls().verb;
+  return {
+    fieldMatcher: field,
+    setAcceptsCreate: VERB_SET.has("create"),
+    setRejectsRpc: !VERB_SET.has("rpc")
+  };
+}
+var c9VerbDeclared = {
+  id: "C9 verb-declared",
+  rule: "C-9",
+  pin: "a74a042b53c71a095ab88b3073bd47728eeda814",
+  run(tree) {
+    const controls = c9PositiveControls();
+    if (!controls.fieldMatcher.matched) {
+      throw new Error(
+        `C9 positive control FAILED: pattern /${controls.fieldMatcher.pattern}/ did not match sample \`${controls.fieldMatcher.sample}\` \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    if (!controls.setAcceptsCreate || !controls.setRejectsRpc) {
+      throw new Error(
+        "C9 closed-set control FAILED: VERB_SET must accept a legitimate verb (create) and reject the banned rpc sentinel \u2014 verdict untrustworthy"
+      );
+    }
+    const unresolved = findUnresolvedToolSites(tree);
+    if (unresolved.length > 0) {
+      const reason = `tool name at ${unresolved.length} registration site(s) is computed/imported/template (${unresolved.join(", ")}) \u2014 declared verb unattributable statically (C-9)`;
+      return {
+        id: this.id,
+        anchor: unresolved[0],
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const tools = findToolAnnotations(tree);
+    if (tools.length === 0) {
+      return {
+        id: this.id,
+        anchor: "-",
+        state: "absent",
+        verdict: "no tool registrations found; verb-declared check n/a"
+      };
+    }
+    for (const t of tools) {
+      if (!t.verb) {
+        return {
+          id: this.id,
+          anchor: t.anchor,
+          state: "non-conforming",
+          verdict: `tool "${t.name}" declares no operation verb (positive-control OK) -> add annotations.verb from the closed CRUD-and-beyond set (C-9)`
+        };
+      }
+      if (t.verb === "rpc") {
+        return {
+          id: this.id,
+          anchor: t.anchor,
+          state: "non-conforming",
+          verdict: `tool "${t.name}" declares verb "rpc" \u2014 rpc is the absence of a verb and never publishes (positive-control OK) -> declare a real verb (C-9)`
+        };
+      }
+      if (!VERB_SET.has(t.verb)) {
+        return {
+          id: this.id,
+          anchor: t.anchor,
+          state: "non-conforming",
+          verdict: `tool "${t.name}" declares verb "${t.verb}", outside the closed set (positive-control OK) -> use list/get/search/aggregate/create/update/delete/upsert/transition/bulk-write/pure/introspect/external-effect (C-9)`
+        };
+      }
+    }
+    return {
+      id: this.id,
+      anchor: tools[0].anchor,
+      state: "present",
+      verdict: `${tools.length} tool(s) each declare a verb in the closed set (positive-control OK)`
+    };
+  }
+};
+
+// src/detectors/c10-mechanism-declared.ts
+var MECHANISM_BASE_SET = /* @__PURE__ */ new Set([
+  "indexed-range",
+  "indexed-bm25",
+  "indexed-vector",
+  "indexed-hybrid-rrf"
+]);
+function baseOf(mechanism) {
+  const paren = mechanism.indexOf("(");
+  return paren === -1 ? mechanism : mechanism.slice(0, paren);
+}
+function isListOrSearch(t) {
+  if (t.verb) return t.verb === "list" || t.verb === "search";
+  return /^(list|search)/i.test(t.name);
+}
+function c10PositiveControls() {
+  const field = toolAnnotationFieldControls().mechanism;
+  return {
+    fieldMatcher: field,
+    setAcceptsIndexedBm25: MECHANISM_BASE_SET.has("indexed-bm25"),
+    setRejectsUnindexedScan: !MECHANISM_BASE_SET.has("unindexed-scan"),
+    vectorParamsStripped: baseOf("indexed-vector(cosine, 1536, 20)") === "indexed-vector"
+  };
+}
+var c10MechanismDeclared = {
+  id: "C10 mechanism-declared",
+  rule: "C-10",
+  pin: "a74a042b53c71a095ab88b3073bd47728eeda814",
+  run(tree) {
+    const controls = c10PositiveControls();
+    if (!controls.fieldMatcher.matched) {
+      throw new Error(
+        `C10 positive control FAILED: pattern /${controls.fieldMatcher.pattern}/ did not match sample \`${controls.fieldMatcher.sample}\` \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    if (!controls.setAcceptsIndexedBm25 || !controls.setRejectsUnindexedScan || !controls.vectorParamsStripped) {
+      throw new Error(
+        "C10 closed-set control FAILED: MECHANISM_BASE_SET must accept indexed-bm25, reject unindexed-scan, and strip indexed-vector(...) params \u2014 verdict untrustworthy"
+      );
+    }
+    const unresolved = findUnresolvedToolSites(tree);
+    if (unresolved.length > 0) {
+      const reason = `tool name at ${unresolved.length} registration site(s) is computed/imported/template (${unresolved.join(", ")}) \u2014 declared mechanism unattributable statically (C-10)`;
+      return {
+        id: this.id,
+        anchor: unresolved[0],
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const applicable = findToolAnnotations(tree).filter(isListOrSearch);
+    if (applicable.length === 0) {
+      return {
+        id: this.id,
+        anchor: "-",
+        state: "absent",
+        verdict: "no list/search tool found; mechanism-declared check n/a"
+      };
+    }
+    for (const t of applicable) {
+      if (!t.searchMechanism) {
+        return {
+          id: this.id,
+          anchor: t.anchor,
+          state: "non-conforming",
+          verdict: `list/search tool "${t.name}" declares no search mechanism (positive-control OK) -> add annotations.searchMechanism from the closed indexing-strategy set (C-10)`
+        };
+      }
+      const base = baseOf(t.searchMechanism);
+      if (base === "unindexed-scan") {
+        return {
+          id: this.id,
+          anchor: t.anchor,
+          state: "non-conforming",
+          verdict: `list/search tool "${t.name}" declares "unindexed-scan" \u2014 refused at publication (positive-control OK) -> declare an indexed mechanism (C-10)`
+        };
+      }
+      if (!MECHANISM_BASE_SET.has(base)) {
+        return {
+          id: this.id,
+          anchor: t.anchor,
+          state: "non-conforming",
+          verdict: `list/search tool "${t.name}" declares mechanism "${t.searchMechanism}", outside the closed set (positive-control OK) -> use indexed-range/indexed-bm25/indexed-vector/indexed-hybrid-rrf (C-10)`
+        };
+      }
+    }
+    return {
+      id: this.id,
+      anchor: applicable[0].anchor,
+      state: "present",
+      verdict: `${applicable.length} list/search tool(s) each declare a mechanism in the closed set (positive-control OK)`
+    };
+  }
+};
+
+// src/detectors/c11-pagination.ts
+var PIN2 = "a74a042b53c71a095ab88b3073bd47728eeda814";
+var PAGINABLE_RE = LIST_READ_RE;
+function c11PositiveControls() {
+  const field = toolAnnotationFieldControls().pagination;
+  return { fieldMatcher: field };
+}
+var c11Pagination = {
+  id: "C11 pagination-declared-applied",
+  rule: "C-11",
+  pin: PIN2,
+  run(tree) {
+    const controls = c11PositiveControls();
+    if (!controls.fieldMatcher.matched || !controls.fieldMatcher.rejectsUnbounded) {
+      throw new Error(
+        `C11 positive control FAILED: pattern /${controls.fieldMatcher.pattern}/ matched=${controls.fieldMatcher.matched} rejectsUnbounded=${controls.fieldMatcher.rejectsUnbounded} \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    const unresolved = findUnresolvedToolSites(tree);
+    if (unresolved.length > 0) {
+      const reason = `tool name at ${unresolved.length} registration site(s) is computed/imported/template (${unresolved.join(", ")}) \u2014 paginable-shape unattributable statically (C-11)`;
+      return {
+        id: this.id,
+        anchor: unresolved[0],
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const tools = findToolAnnotations(tree).filter((t) => PAGINABLE_RE.test(t.name));
+    if (tools.length === 0) {
+      return {
+        id: this.id,
+        anchor: "-",
+        state: "absent",
+        verdict: "no list/read/get/search tool registrations found; pagination declaration check n/a"
+      };
+    }
+    for (const t of tools) {
+      const missing = [];
+      if (!t.paginationCursorDeclared) missing.push("paginationCursor");
+      if (t.paginationDefault === void 0) missing.push("paginationDefault");
+      if (t.paginationMax === void 0) missing.push("paginationMax (finite)");
+      if (missing.length > 0) {
+        return {
+          id: this.id,
+          anchor: t.anchor,
+          state: "non-conforming",
+          verdict: `tool "${t.name}" is missing pagination declaration(s): ${missing.join(", ")} (positive-control OK) -> declare annotations.paginationCursor/paginationDefault/paginationMax with a FINITE max \u2014 an unbounded max never publishes (C-11)`
+        };
+      }
+    }
+    return {
+      id: this.id,
+      anchor: tools[0].anchor,
+      state: "present",
+      verdict: `${tools.length} paginable tool(s) each declare cursor + default + finite max (positive-control OK)`
+    };
+  },
+  /**
+   * DYNAMIC — confirms the tool(s) the static shape considers paginable are
+   * genuinely SERVED by the running server (a real runtime fact from the
+   * tools/list snapshot). Does NOT perform the invalid-cursor -> -32602
+   * round trip: the one-shot RuntimeContext snapshot carries no per-tool
+   * schema and no `callTool` verb — that half needs `Session.callTool` with a
+   * cursor argument (documented gap, types.ts `Session`). The verdict names
+   * this explicitly rather than folding it into a silent full "present".
+   */
+  runDynamic(runtime) {
+    if (runtime.launchError) {
+      const reason = `server could not be started/introspected \u2014 runtime pagination applicability unverifiable: ${runtime.launchError} (C-11)`;
+      return {
+        id: this.id,
+        anchor: `${runtime.root} (runtime)`,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const paginable = runtime.tools.filter((t) => PAGINABLE_RE.test(t.name));
+    if (paginable.length === 0) {
+      return {
+        id: this.id,
+        anchor: `${runtime.root} (runtime tools/list)`,
+        state: "absent",
+        verdict: "server advertises no list/read/get/search tool at runtime; pagination check n/a"
+      };
+    }
+    const names = paginable.map((t) => t.name).join(", ");
+    return {
+      id: this.id,
+      anchor: `${runtime.root} (runtime tools/list)`,
+      state: "present",
+      verdict: `runtime confirms paginable tool(s) actually served: ${names}. The invalid-cursor -> -32602 round trip is NOT performed by this snapshot surface (needs Session.callTool with a cursor argument, not yet exposed \u2014 see types.ts Session doc); this dynamic half asserts service reachability, not the full cursor-handling guarantee.`
+    };
+  }
+};
+
+// src/detectors/c12-no-duplicates.ts
+function tripletKey(t) {
+  return `${t.verb}::${t.table}::${t.searchMechanism ?? ""}`;
+}
+function c12PositiveControls() {
+  const a = { name: "get_customer", anchor: "a", verb: "get", table: "customers" };
+  const b = {
+    name: "fetch_customer",
+    anchor: "b",
+    verb: "get",
+    table: "customers"
+  };
+  const c = { name: "get_order", anchor: "c", verb: "get", table: "orders" };
+  return {
+    fieldMatcher: toolAnnotationFieldControls().table,
+    detectsDuplicate: tripletKey(a) === tripletKey(b),
+    clearsDistinctTable: tripletKey(a) !== tripletKey(c)
+  };
+}
+var c12NoDuplicates = {
+  id: "C12 no-duplicates",
+  rule: "C-12",
+  pin: "a74a042b53c71a095ab88b3073bd47728eeda814",
+  run(tree) {
+    const controls = c12PositiveControls();
+    if (!controls.fieldMatcher.matched) {
+      throw new Error(
+        `C12 positive control FAILED: pattern /${controls.fieldMatcher.pattern}/ did not match sample \`${controls.fieldMatcher.sample}\` \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    if (!controls.detectsDuplicate || !controls.clearsDistinctTable) {
+      throw new Error(
+        "C12 dedupe-key control FAILED: must match on an identical (verb, table) pair and differ on a distinct table \u2014 verdict untrustworthy"
+      );
+    }
+    const unresolved = findUnresolvedToolSites(tree);
+    if (unresolved.length > 0) {
+      const reason = `tool name at ${unresolved.length} registration site(s) is computed/imported/template (${unresolved.join(", ")}) \u2014 triplet unattributable statically (C-12)`;
+      return {
+        id: this.id,
+        anchor: unresolved[0],
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const tools = findToolAnnotations(tree);
+    if (tools.length === 0) {
+      return {
+        id: this.id,
+        anchor: "-",
+        state: "absent",
+        verdict: "no tool registrations found; no-duplicates check n/a"
+      };
+    }
+    const considered = tools.filter((t) => t.verb && t.table);
+    if (considered.length === 0) {
+      const reason = "no tool declares both a verb and a table \u2014 duplicate-triplet check unverifiable tree-wide (C-12; see C-9 for missing-verb conformance separately)";
+      return {
+        id: this.id,
+        anchor: tools[0].anchor,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const groups = /* @__PURE__ */ new Map();
+    for (const t of considered) {
+      const key = tripletKey(t);
+      const list = groups.get(key) ?? [];
+      list.push(t);
+      groups.set(key, list);
+    }
+    for (const [key, members] of groups) {
+      if (members.length >= 2) {
+        const anchors = members.map((m) => `${m.name}@${m.anchor}`).join(", ");
+        return {
+          id: this.id,
+          anchor: members[0].anchor,
+          state: "non-conforming",
+          verdict: `duplicate triplet (verb::table::mechanism = "${key}") on ${members.length} tools (positive-control OK): ${anchors} -> collapse to one tool, express the other as documentation (C-12)`
+        };
+      }
+    }
+    return {
+      id: this.id,
+      anchor: considered[0].anchor,
+      state: "present",
+      verdict: `${considered.length} tool(s) with a declared (verb, table) checked, no duplicate triplet found (positive-control OK)`
+    };
+  }
+};
+
+// src/detectors/c13-context-ceiling.ts
+var CEILING_GLOBAL_RE = /\b(?:CONTEXT_CEILING|contextCeiling)\b[\s\S]{0,80}?\bglobal\s*:\s*(\d+)\b/;
+var CEILING_PER_TOOL_RE = /\b(?:CONTEXT_CEILING|contextCeiling)\b[\s\S]{0,80}?\bperTool\s*:\s*(\d+)\b/;
+function findCeiling(tree) {
+  for (const file of tree.files) {
+    for (const line of file.lines) {
+      if (line.comment) continue;
+      if (/\b(?:CONTEXT_CEILING|contextCeiling)\b/.test(line.raw)) {
+        const start = line.n - 1;
+        const windowLines = file.lines.slice(start, start + 6).map((l) => l.raw);
+        const window = windowLines.join("\n");
+        const g = window.match(CEILING_GLOBAL_RE);
+        const p = window.match(CEILING_PER_TOOL_RE);
+        if (g && p) {
+          return {
+            global: Number.parseInt(g[1], 10),
+            perTool: Number.parseInt(p[1], 10),
+            anchor: `${file.rel}:${line.n}`
+          };
+        }
+      }
+    }
+  }
+  return null;
+}
+function c13PositiveControls() {
+  const complete = "const CONTEXT_CEILING = { global: 8000, perTool: 800 };";
+  const partial = "const CONTEXT_CEILING = { global: 8000 };";
+  return {
+    tokensMatcher: toolAnnotationFieldControls().tokensCtx,
+    ceilingAcceptsComplete: CEILING_GLOBAL_RE.test(complete) && CEILING_PER_TOOL_RE.test(complete),
+    ceilingRejectsPartial: !(CEILING_GLOBAL_RE.test(partial) && CEILING_PER_TOOL_RE.test(partial))
+  };
+}
+var c13ContextCeiling = {
+  id: "C13 context-ceiling",
+  rule: "C-13",
+  pin: "a74a042b53c71a095ab88b3073bd47728eeda814",
+  run(tree) {
+    const controls = c13PositiveControls();
+    if (!controls.tokensMatcher.matched) {
+      throw new Error(
+        `C13 positive control FAILED: pattern /${controls.tokensMatcher.pattern}/ did not match sample \`${controls.tokensMatcher.sample}\` \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    if (!controls.ceilingAcceptsComplete || !controls.ceilingRejectsPartial) {
+      throw new Error(
+        "C13 ceiling control FAILED: must accept a complete (global, perTool) declaration and reject a partial one \u2014 verdict untrustworthy"
+      );
+    }
+    const unresolved = findUnresolvedToolSites(tree);
+    if (unresolved.length > 0) {
+      const reason = `tool name at ${unresolved.length} registration site(s) is computed/imported/template (${unresolved.join(", ")}) \u2014 declared context cost unattributable statically (C-13)`;
+      return {
+        id: this.id,
+        anchor: unresolved[0],
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const tools = findToolAnnotations(tree);
+    if (tools.length === 0) {
+      return {
+        id: this.id,
+        anchor: "-",
+        state: "absent",
+        verdict: "no tool registrations found; context-ceiling check n/a"
+      };
+    }
+    const ceiling = findCeiling(tree);
+    if (!ceiling) {
+      return {
+        id: this.id,
+        anchor: tools[0].anchor,
+        state: "non-conforming",
+        verdict: `${tools.length} tool(s) registered but no (global, perTool) context ceiling declared anywhere (positive-control OK) -> declare CONTEXT_CEILING = { global, perTool } (C-13)`
+      };
+    }
+    let sum = 0;
+    for (const t of tools) {
+      if (t.tokensEstimeContexte === void 0) {
+        return {
+          id: this.id,
+          anchor: t.anchor,
+          state: "non-conforming",
+          verdict: `tool "${t.name}" declares no tokensEstimeContexte (positive-control OK, ceiling declared at ${ceiling.anchor}) -> declare tokensEstimeContexte on every tool (C-13)`
+        };
+      }
+      if (t.tokensEstimeContexte > ceiling.perTool) {
+        return {
+          id: this.id,
+          anchor: t.anchor,
+          state: "non-conforming",
+          verdict: `tool "${t.name}" declares tokensEstimeContexte=${t.tokensEstimeContexte}, above the declared per-tool ceiling ${ceiling.perTool} (${ceiling.anchor}) -> stage the schema, publish by tiers (C-13)`
+        };
+      }
+      sum += t.tokensEstimeContexte;
+    }
+    if (sum > ceiling.global) {
+      return {
+        id: this.id,
+        anchor: ceiling.anchor,
+        state: "non-conforming",
+        verdict: `declared per-tool costs sum to ${sum}, above the declared global ceiling ${ceiling.global} (${ceiling.anchor}) -> stage publication by tiers (C-13)`
+      };
+    }
+    return {
+      id: this.id,
+      anchor: ceiling.anchor,
+      state: "present",
+      verdict: `${tools.length} tool(s) each declare tokensEstimeContexte within the declared per-tool ceiling (${ceiling.perTool}); sum ${sum} within global ceiling ${ceiling.global} (positive-control OK)`
+    };
+  }
+};
+
+// src/detectors/c14-catalog-registration.ts
+var PIN3 = "a74a042b53c71a095ab88b3073bd47728eeda814";
+var REQUIRED_FIELDS = [
+  "name",
+  "version",
+  "description",
+  "description_fr",
+  "repo_url",
+  "npm_url",
+  "keywords",
+  "auth_type",
+  "transport",
+  "bilingual"
+];
+function readCatalogBlock(tree) {
+  if (!tree.packageJson) return null;
+  const raw = tree.packageJson.json.mcpCatalog;
+  if (!raw || typeof raw !== "object") return null;
+  return { fields: raw, anchor: `${tree.packageJson.path}:mcpCatalog` };
+}
+function c14PositiveControls() {
+  const complete = {
+    name: "x",
+    version: "1.0.0",
+    description: "en",
+    description_fr: "fr",
+    repo_url: "https://github.com/x/y",
+    npm_url: "https://npmjs.com/package/x",
+    keywords: ["mcp"],
+    auth_type: "public",
+    transport: "stdio",
+    bilingual: true
+  };
+  const partial = { ...complete };
+  partial.repo_url = void 0;
+  const missing = (block) => REQUIRED_FIELDS.find((f) => block[f] === void 0 || block[f] === null);
+  return {
+    acceptsComplete: missing(complete) === void 0,
+    rejectsPartial: missing(partial) !== void 0
+  };
+}
+var c14CatalogRegistration = {
+  id: "C14 catalog-registration",
+  rule: "C-14",
+  pin: PIN3,
+  run(tree) {
+    const controls = c14PositiveControls();
+    if (!controls.acceptsComplete || !controls.rejectsPartial) {
+      throw new Error(
+        `C14 positive control FAILED: acceptsComplete=${controls.acceptsComplete} rejectsPartial=${controls.rejectsPartial} \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    const block = readCatalogBlock(tree);
+    if (!block) {
+      return {
+        id: this.id,
+        anchor: tree.packageJson?.path ?? tree.root,
+        state: "absent",
+        verdict: "no mcpCatalog block declared in package.json; this run carries no publication-catalog metadata (C-14 n/a)"
+      };
+    }
+    for (const field of REQUIRED_FIELDS) {
+      const v = block.fields[field];
+      if (v === void 0 || v === null) {
+        return {
+          id: this.id,
+          anchor: block.anchor,
+          state: "non-conforming",
+          verdict: `mcpCatalog block at ${block.anchor} is missing required field "${field}" (positive-control OK) -> declare it before publication (C-14)`
+        };
+      }
+    }
+    if (block.fields.bilingual !== true) {
+      return {
+        id: this.id,
+        anchor: block.anchor,
+        state: "non-conforming",
+        verdict: `mcpCatalog.bilingual at ${block.anchor} is not literally true -> declare bilingual: true (C-14)`
+      };
+    }
+    return {
+      id: this.id,
+      anchor: block.anchor,
+      // C-14 is `gate + dynamique` with NO static half: its `vert` is the entry
+      // being trouvable via `search_components` on the LIVE registry. A complete
+      // static declaration is NOT the rule satisfied — only the rule's precondition.
+      // Returning `present` here would let a tally read "satisfied" from what is
+      // only "declared", the same over-claim a gate rule (C-22) correctly abstains
+      // on. So a complete-but-unresolved declaration is could-not-judge, naming the
+      // gate — never `present` from a static read.
+      state: "could-not-judge",
+      reason: `mcpCatalog block at ${block.anchor} declares all ${REQUIRED_FIELDS.length} required fields, but C-14 is gate+dynamique with no static half: satisfaction is the entry RESOLVING via search_components on the live VantageRegistry, which a static run never performs (C-14).`,
+      verdict: `could not judge: mcpCatalog block at ${block.anchor} declares all ${REQUIRED_FIELDS.length} required fields (positive-control OK), but whether it RESOLVES via search_components on the live registry is the gate+dynamique half a static run cannot reach \u2014 declaration complete, resolution unverified (C-14).`
+    };
+  }
+};
+
+// src/detectors/c15-annotations-untrusted.ts
+var AUTO_APPROVE_ACTION_RE = /\b(?:autoApprove|skipConfirm|autoRun|autoExecute)\w*\s*\(/;
+var HINT_REFERENCE_RE = /\b(?:readOnlyHint|destructiveHint|idempotentHint|openWorldHint)\b/;
+var TRUST_CHECK_RE = /\b(?:isTrustedServer|trustedSource|isPinnedSource|pinnedSource|isTrusted)\b/;
+function c15PositiveControls() {
+  const unpinnedSample = "if (readOnlyHint) autoApprove(tool);";
+  const pinnedSample = "if (readOnlyHint && isTrustedServer(server)) autoApprove(tool);";
+  return {
+    hintsMatcher: toolAnnotationFieldControls().behavioralHints,
+    autoApproveDetectsUnpinned: AUTO_APPROVE_ACTION_RE.test(unpinnedSample) && HINT_REFERENCE_RE.test(unpinnedSample) && !TRUST_CHECK_RE.test(unpinnedSample),
+    autoApproveClearsPinned: AUTO_APPROVE_ACTION_RE.test(pinnedSample) && HINT_REFERENCE_RE.test(pinnedSample) && TRUST_CHECK_RE.test(pinnedSample)
+  };
+}
+function allHintsDeclared(t) {
+  return Boolean(
+    t.readOnlyHintDeclared && t.destructiveHintDeclared && t.idempotentHintDeclared && t.openWorldHintDeclared
+  );
+}
+function missingHints(t) {
+  const missing = [];
+  if (!t.readOnlyHintDeclared) missing.push("readOnlyHint");
+  if (!t.destructiveHintDeclared) missing.push("destructiveHint");
+  if (!t.idempotentHintDeclared) missing.push("idempotentHint");
+  if (!t.openWorldHintDeclared) missing.push("openWorldHint");
+  return missing;
+}
+function findUnpinnedAutoApprovals(tree) {
+  const hits = [];
+  for (const file of tree.files) {
+    for (const line of file.lines) {
+      if (line.comment) continue;
+      const raw = line.raw;
+      if (AUTO_APPROVE_ACTION_RE.test(raw) && HINT_REFERENCE_RE.test(raw) && !TRUST_CHECK_RE.test(raw)) {
+        hits.push({ file, line: line.n });
+      }
+    }
+  }
+  return hits;
+}
+var c15AnnotationsUntrusted = {
+  id: "C15 annotations-untrusted",
+  rule: "C-15",
+  pin: "a74a042b53c71a095ab88b3073bd47728eeda814",
+  run(tree) {
+    const controls = c15PositiveControls();
+    if (!controls.hintsMatcher.matched) {
+      throw new Error(
+        `C15 positive control FAILED: pattern /${controls.hintsMatcher.pattern}/ did not match sample \`${controls.hintsMatcher.sample}\` \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    if (!controls.autoApproveDetectsUnpinned || !controls.autoApproveClearsPinned) {
+      throw new Error(
+        "C15 auto-approval control FAILED: must flag a hint-gated approval with no trust check, and clear one that carries a trust check \u2014 verdict untrustworthy"
+      );
+    }
+    const unresolved = findUnresolvedToolSites(tree);
+    if (unresolved.length > 0) {
+      const reason = `tool name at ${unresolved.length} registration site(s) is computed/imported/template (${unresolved.join(", ")}) \u2014 declared annotations unattributable statically (C-15)`;
+      return {
+        id: this.id,
+        anchor: unresolved[0],
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const unpinned = findUnpinnedAutoApprovals(tree);
+    if (unpinned.length > 0) {
+      const anchor = `${unpinned[0].file.rel}:${unpinned[0].line}`;
+      return {
+        id: this.id,
+        anchor,
+        state: "non-conforming",
+        verdict: `consumer auto-approves an action off a behavioral hint with no trusted-source check at ${anchor} (positive-control OK) -> gate the auto-approval on isTrustedServer/pinned-source in addition to the hint (C-15)`
+      };
+    }
+    const tools = findToolAnnotations(tree);
+    if (tools.length === 0) {
+      return {
+        id: this.id,
+        anchor: "-",
+        state: "absent",
+        verdict: "no tool registrations found; annotations-untrusted check n/a"
+      };
+    }
+    for (const t of tools) {
+      if (!allHintsDeclared(t)) {
+        const missing = missingHints(t).join(", ");
+        return {
+          id: this.id,
+          anchor: t.anchor,
+          state: "non-conforming",
+          verdict: `tool "${t.name}" is missing behavioral annotation(s): ${missing} (positive-control OK) -> declare readOnlyHint/destructiveHint/idempotentHint/openWorldHint (C-15)`
+        };
+      }
+    }
+    return {
+      id: this.id,
+      anchor: tools[0].anchor,
+      state: "present",
+      verdict: `${tools.length} tool(s) each declare all four behavioral annotations, no unpinned auto-approval found (positive-control OK)`
+    };
+  }
+};
+
+// src/detectors/c16-untrusted-output.ts
+var SYSTEM_ROLE_TEMPLATE_INTERP_RE = /role\s*:\s*["'`]system["'`][\s\S]*?(?:content|text)\s*:\s*`[^`]*\$\{/;
+var INSTRUCTION_FIELD_TEMPLATE_INTERP_RE = /\b(?:instruction|systemPrompt|prompt)\s*:\s*`[^`]*\$\{/;
+var BOUNDARY_MARKER_RE = /\b(?:sanitize\w*\s*\(|UNTRUSTED_CONTENT|trustBoundary|provenance\s*:\s*["'`]untrusted["'`])/;
+var WINDOW_RADIUS = 6;
+function c16PositiveControls() {
+  const rawSystemSample = 'messages.push({ role: "system", content: `Context: ${toolOutput}` });';
+  const staticSystemSample = 'messages.push({ role: "system", content: "You are a helpful assistant." });';
+  const sanitizeSample = "content: sanitizeOutput(toolOutput)";
+  const provenanceSample = 'meta: { provenance: "untrusted" }';
+  return {
+    interpolationMatchesRaw: SYSTEM_ROLE_TEMPLATE_INTERP_RE.test(rawSystemSample),
+    interpolationClearsStatic: !SYSTEM_ROLE_TEMPLATE_INTERP_RE.test(staticSystemSample),
+    markerMatchesSanitize: BOUNDARY_MARKER_RE.test(sanitizeSample),
+    markerMatchesProvenance: BOUNDARY_MARKER_RE.test(provenanceSample)
+  };
+}
+function findInterpolationSites(tree) {
+  const hits = [];
+  for (const file of tree.files) {
+    for (const line of file.lines) {
+      if (line.comment) continue;
+      if (SYSTEM_ROLE_TEMPLATE_INTERP_RE.test(line.raw) || INSTRUCTION_FIELD_TEMPLATE_INTERP_RE.test(line.raw)) {
+        hits.push({ file, line: line.n });
+      }
+    }
+  }
+  return hits;
+}
+function windowHasMarker(file, siteLine) {
+  for (const line of file.lines) {
+    if (line.n < siteLine - WINDOW_RADIUS || line.n > siteLine + WINDOW_RADIUS) continue;
+    if (line.comment) continue;
+    if (BOUNDARY_MARKER_RE.test(line.raw)) return true;
+  }
+  return false;
+}
+var c16UntrustedOutput = {
+  id: "C16 untrusted-output",
+  rule: "C-16",
+  pin: "a74a042b53c71a095ab88b3073bd47728eeda814",
+  run(tree) {
+    const controls = c16PositiveControls();
+    if (!controls.interpolationMatchesRaw || !controls.interpolationClearsStatic || !controls.markerMatchesSanitize || !controls.markerMatchesProvenance) {
+      throw new Error(
+        `C16 positive control FAILED: raw=${controls.interpolationMatchesRaw} staticCleared=${controls.interpolationClearsStatic} sanitizeMarker=${controls.markerMatchesSanitize} provenanceMarker=${controls.markerMatchesProvenance} \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    const sites = findInterpolationSites(tree);
+    if (sites.length === 0) {
+      return {
+        id: this.id,
+        anchor: "-",
+        state: "absent",
+        verdict: "no instruction-position template interpolation found; untrusted-output check n/a (C-16)"
+      };
+    }
+    for (const site of sites) {
+      const anchor = `${site.file.rel}:${site.line}`;
+      if (!windowHasMarker(site.file, site.line)) {
+        return {
+          id: this.id,
+          anchor,
+          state: "non-conforming",
+          verdict: `content interpolated into an instruction position at ${anchor} with no trust-boundary marker within ${WINDOW_RADIUS} lines (positive-control OK) -> sanitize the output or mark its provenance before it reaches an instruction field (C-16)`
+        };
+      }
+    }
+    return {
+      id: this.id,
+      anchor: `${sites[0].file.rel}:${sites[0].line}`,
+      state: "present",
+      verdict: `${sites.length} instruction-position interpolation site(s), each carrying a trust-boundary marker in its window (positive-control OK)`
+    };
+  }
+};
+
+// src/detectors/c17-supply-chain.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
+import { join as join2 } from "path";
+var PIN4 = "a74a042b53c71a095ab88b3073bd47728eeda814";
+var LOCKFILES = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb"];
+var WORKFLOW_DIR = join2(".github", "workflows");
+var PROVENANCE_RE2 = /--provenance\b|\bprovenance\s*:\s*true\b|id-token:\s*write/i;
+function c17PositiveControls() {
+  const sample = "npm publish --provenance --access public";
+  const bare = "npm publish --access public";
+  return {
+    provenanceMatcher: {
+      pattern: PROVENANCE_RE2.source,
+      sample,
+      matched: PROVENANCE_RE2.test(sample),
+      rejectsBare: !PROVENANCE_RE2.test(bare)
+    }
+  };
+}
+function findLockfile(root) {
+  for (const name of LOCKFILES) {
+    if (existsSync2(join2(root, name))) return name;
+  }
+  return null;
+}
+function findProvenanceClaim(tree, root) {
+  const pkg = tree.packageJson;
+  if (pkg) {
+    const publishConfig = pkg.json.publishConfig;
+    if (publishConfig && publishConfig.provenance === true) {
+      return { site: `${pkg.path}:publishConfig.provenance`, text: "provenance: true" };
+    }
+  }
+  const workflowsDir = join2(root, WORKFLOW_DIR);
+  if (!existsSync2(workflowsDir)) return null;
+  let entries = [];
+  try {
+    entries = readdirSync(workflowsDir);
+  } catch {
+    return null;
+  }
+  for (const name of entries) {
+    if (!/\.ya?ml$/.test(name)) continue;
+    const path = join2(workflowsDir, name);
+    let text;
+    try {
+      text = readFileSync2(path, "utf8");
+    } catch {
+      continue;
+    }
+    if (PROVENANCE_RE2.test(text)) {
+      const line = text.split("\n").findIndex((l) => PROVENANCE_RE2.test(l)) + 1;
+      return { site: `${WORKFLOW_DIR}/${name}:${line}`, text };
+    }
+  }
+  return null;
+}
+var c17SupplyChain = {
+  id: "C17 supply-chain",
+  rule: "C-17",
+  pin: PIN4,
+  run(tree) {
+    const controls = c17PositiveControls();
+    if (!controls.provenanceMatcher.matched || !controls.provenanceMatcher.rejectsBare) {
+      throw new Error(
+        `C17 provenance-matcher control FAILED: accept(\`${controls.provenanceMatcher.sample}\`)=${controls.provenanceMatcher.matched} rejectsBare=${controls.provenanceMatcher.rejectsBare} \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    const lockfile = findLockfile(tree.root);
+    if (!lockfile) {
+      return {
+        id: this.id,
+        anchor: tree.root,
+        state: "non-conforming",
+        verdict: "no committed lockfile (package-lock.json/pnpm-lock.yaml/yarn.lock/bun.lock) found -> dependencies are not pinned; commit a lockfile (C-17a)"
+      };
+    }
+    const claim = findProvenanceClaim(tree, tree.root);
+    if (!claim) {
+      return {
+        id: this.id,
+        anchor: `${lockfile}:1`,
+        state: "non-conforming",
+        verdict: `lockfile ${lockfile} present, but no provenance attestation claim found in package.json publishConfig or ${WORKFLOW_DIR}/*.yml -> add \`npm publish --provenance\` or \`publishConfig.provenance: true\` (C-17b)`
+      };
+    }
+    return {
+      id: this.id,
+      anchor: claim.site,
+      state: "present",
+      verdict: `lockfile ${lockfile} pinned + provenance attestation claim at ${claim.site} (C-17a/b complete). Whether the attestation record actually RESOLVES against the published artifact at the registry is a separate gate check at publish time \u2014 this static run asserts the declaration is complete, not that the gate has resolved it.`
+    };
+  }
+};
+
+// src/detectors/c18-structure-manifest.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+var PIN5 = "a74a042b53c71a095ab88b3073bd47728eeda814";
+function manifestPath(root) {
+  const extPath = join3(root, "extension.json");
+  if (existsSync3(extPath)) return { kind: "extension", path: extPath };
+  return { kind: "server", path: join3(root, "mcp.json") };
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function c18PositiveControls() {
+  const equalCheck = (a, b) => a === b;
+  return {
+    versionParity: {
+      matched: equalCheck("0.1.0", "0.1.0"),
+      rejectsMismatch: !equalCheck("0.1.0", "0.2.0")
+    }
+  };
+}
+var c18StructureManifest = {
+  id: "C18 structure-manifest",
+  rule: "C-18",
+  pin: PIN5,
+  run(tree) {
+    const controls = c18PositiveControls();
+    if (!controls.versionParity.matched || !controls.versionParity.rejectsMismatch) {
+      throw new Error(
+        "C18 version-parity control FAILED: equal-strings must match and unequal-strings must be rejected \u2014 verdict untrustworthy"
+      );
+    }
+    if (!tree.packageJson) {
+      const reason = "could not locate package.json anywhere above the scanned root (C-18)";
+      return {
+        id: this.id,
+        anchor: tree.root,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const pkgVersion = tree.packageJson.json.version;
+    if (typeof pkgVersion !== "string") {
+      const reason = `no string "version" field in ${tree.packageJson.path} \u2014 manifest version-parity unverifiable (C-18)`;
+      return {
+        id: this.id,
+        anchor: tree.packageJson.path,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const { kind, path } = manifestPath(tree.root);
+    const manifestName = kind === "extension" ? "extension.json" : "mcp.json";
+    if (!existsSync3(path)) {
+      return {
+        id: this.id,
+        anchor: tree.root,
+        state: "non-conforming",
+        verdict: `no ${manifestName} found at the tree root -> the ${kind === "extension" ? "extension" : "server/App"} manifest is required (C-18)`
+      };
+    }
+    const manifest = readJson(path);
+    if (!manifest) {
+      return {
+        id: this.id,
+        anchor: path,
+        state: "non-conforming",
+        verdict: `${manifestName} present but could not be parsed as JSON -> fix the manifest (C-18)`
+      };
+    }
+    if (typeof manifest.name !== "string" || manifest.name.length === 0) {
+      return {
+        id: this.id,
+        anchor: path,
+        state: "non-conforming",
+        verdict: `${manifestName} is missing a required "name" field (C-18)`
+      };
+    }
+    if (kind === "extension") {
+      const missing = [];
+      if (typeof manifest.type !== "string") missing.push("type");
+      if (typeof manifest.lifecycle !== "string") missing.push("lifecycle");
+      if (missing.length > 0) {
+        return {
+          id: this.id,
+          anchor: path,
+          state: "non-conforming",
+          verdict: `extension.json is missing required field(s): ${missing.join(", ")} -> declare type/lifecycle (C-18)`
+        };
+      }
+    } else {
+      const missing = [];
+      if (!manifest.capabilities || typeof manifest.capabilities !== "object" || Array.isArray(manifest.capabilities)) {
+        missing.push("capabilities");
+      }
+      if (!manifest.transport || typeof manifest.transport !== "object" || Array.isArray(manifest.transport)) {
+        missing.push("transport");
+      }
+      if (missing.length > 0) {
+        return {
+          id: this.id,
+          anchor: path,
+          state: "non-conforming",
+          verdict: `mcp.json is missing required field(s): ${missing.join(", ")} not declared -> declare capabilities/transport (C-18)`
+        };
+      }
+    }
+    if (typeof manifest.version !== "string") {
+      return {
+        id: this.id,
+        anchor: path,
+        state: "non-conforming",
+        verdict: `${manifestName} is missing a required "version" field (C-18)`
+      };
+    }
+    if (manifest.version !== pkgVersion) {
+      return {
+        id: this.id,
+        anchor: path,
+        state: "non-conforming",
+        verdict: `${manifestName} version "${manifest.version}" does not equal package.json version "${pkgVersion}" -> keep the manifest version in sync (C-18)`
+      };
+    }
+    return {
+      id: this.id,
+      anchor: path,
+      state: "present",
+      verdict: `${manifestName} present, required fields declared, version "${manifest.version}" parity with package.json (C-18)`
+    };
+  }
+};
+
+// src/scan.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync } from "fs";
+import { dirname, join as join4, relative } from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".git",
+  "tests",
+  "__tests__",
+  "coverage",
+  // Test material, not a target's served surface: deliberately-malformed
+  // servers and foreign copies live here. Scanning them makes the instrument
+  // trip its own fail-closed detectors when pointed at its own tree, and lints
+  // inputs that are meant to be broken. A real target's fixtures are equally
+  // test inputs, not its product surface.
+  "fixtures"
+]);
+function isCommentLine(raw) {
+  const t = raw.trim();
+  if (t === "") return false;
+  return t.startsWith("*") || t.startsWith("//") || t.startsWith("/*") || t.startsWith("*/");
+}
+function walk(dir, out) {
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const full = join4(dir, name);
+    let st;
+    try {
+      st = statSync(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) {
+      if (SKIP_DIRS.has(name)) continue;
+      walk(full, out);
+    } else if (name.endsWith(".ts") || name.endsWith(".tsx")) {
+      if (name.endsWith(".d.ts") || name.endsWith(".test.ts")) continue;
+      out.push(full);
+    }
+  }
+}
+function loadFile(path, root) {
+  const raw = readFileSync4(path, "utf8");
+  const lines = raw.split("\n").map((r, i) => ({ n: i + 1, raw: r, comment: isCommentLine(r) }));
+  return { path, rel: relative(root, path) || path, lines };
+}
+function findPackageJson(startDir) {
+  let dir = startDir;
+  for (let depth = 0; depth < 8; depth++) {
+    const candidate = join4(dir, "package.json");
+    if (existsSync4(candidate)) {
+      try {
+        return { path: candidate, json: JSON.parse(readFileSync4(candidate, "utf8")) };
+      } catch {
+        return { path: candidate, json: {} };
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function loadTree(root) {
+  const st = statSync(root);
+  const baseDir = st.isDirectory() ? root : dirname(root);
+  const filePaths = [];
+  if (st.isDirectory()) walk(root, filePaths);
+  else if (root.endsWith(".ts") || root.endsWith(".tsx")) filePaths.push(root);
+  const files = filePaths.map((p) => loadFile(p, baseDir));
+  return { root, files, packageJson: findPackageJson(baseDir) };
+}
+
+// src/detectors/c19-served-descriptions.ts
+var PIN6 = "a74a042b53c71a095ab88b3073bd47728eeda814";
+var TOOL_DESC_INLINE_RE = /\b(?:s\.tool|\.tool|registerTool)\s*\(\s*(?:["'`][^"'`]+["'`]|[A-Za-z_$][\w$]*)\s*,\s*["'`]([^"'`]+)["'`]/;
+var DESCRIPTOR_DESC_RE = /\bdescription\s*:\s*["'`]([^"'`]+)["'`]/;
+var BARE_STRING_RE = /^\s*["'`]([^"'`]+)["'`]\s*,?\s*$/;
+var BACKWARD_LOOKBACK = 10;
+var FORWARD_LOOKAHEAD = 6;
+function findInlineDescription(tree, siteAnchor, toolName) {
+  const [rel, lineStr] = siteAnchor.split(":");
+  const file = tree.files.find((f) => f.rel === rel);
+  if (!file) return void 0;
+  const siteLine = Number.parseInt(lineStr, 10);
+  const start = Math.max(1, siteLine - BACKWARD_LOOKBACK);
+  const end = Math.min(siteLine + FORWARD_LOOKAHEAD, file.lines.length + 1);
+  for (let n = start; n < end; n++) {
+    const line = file.lines[n - 1];
+    if (!line || line.comment) continue;
+    const inline = line.raw.match(TOOL_DESC_INLINE_RE);
+    if (inline) return inline[1];
+    const desc = line.raw.match(DESCRIPTOR_DESC_RE);
+    if (desc) return desc[1];
+    if (n >= siteLine) {
+      const bare = line.raw.match(BARE_STRING_RE);
+      if (bare && bare[1] !== toolName) return bare[1];
+    }
+  }
+  return void 0;
+}
+var TRIGGER_LIST_RE = /use this whenever/i;
+var TRIGGER_CLOSE_RE = /even if they don'?t say/i;
+var BILINGUAL_SPLIT_RE = /^(.{10,})\s\/\s(.{10,})$/;
+function c19PositiveControls() {
+  const inlineSample = 's.tool("list_items", "List items", {}, handler)';
+  const triggerSample = "List items. Use this whenever the user says list, show, or enumerate \u2014 even if they don't say 'list_items' explicitly.";
+  const bilingualSample = "List items, use this whenever asked. / Liste les elements, a utiliser des que demande.";
+  const monoSample = "List items only, no second language here at all.";
+  return {
+    inlineDescAccepts: TOOL_DESC_INLINE_RE.test(inlineSample),
+    triggerListAccepts: TRIGGER_LIST_RE.test(triggerSample),
+    triggerCloseAccepts: TRIGGER_CLOSE_RE.test(triggerSample),
+    bilingualAccepts: BILINGUAL_SPLIT_RE.test(bilingualSample),
+    bilingualRejectsMonolingual: !BILINGUAL_SPLIT_RE.test(monoSample)
+  };
+}
+var c19ServedDescriptions = {
+  id: "C19 served-descriptions",
+  rule: "C-19",
+  pin: PIN6,
+  run(tree) {
+    const controls = c19PositiveControls();
+    if (!controls.inlineDescAccepts || !controls.triggerListAccepts || !controls.triggerCloseAccepts || !controls.bilingualAccepts || !controls.bilingualRejectsMonolingual) {
+      throw new Error(
+        `C19 positive control FAILED: ${JSON.stringify(controls)} \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    const sites = findRegisteredTools(tree);
+    if (sites.length === 0) {
+      return {
+        id: this.id,
+        anchor: "-",
+        state: "absent",
+        verdict: "no tool registrations found; served-descriptions check n/a (C-19)"
+      };
+    }
+    for (const site of sites) {
+      const desc = findInlineDescription(tree, site.anchor, site.name);
+      if (!desc) {
+        return {
+          id: this.id,
+          anchor: site.anchor,
+          state: "non-conforming",
+          verdict: `tool "${site.name}" at ${site.anchor} declares no inline description in source (positive-control OK) -> declare one; the SERVED bilingual/budget/trigger-phrase measurement is the dynamic half of C-19, run with a live session`
+        };
+      }
+    }
+    return {
+      id: this.id,
+      anchor: sites[0].anchor,
+      state: "present",
+      verdict: `${sites.length} registered tool(s) each declare a source-level description (positive-control OK). Whether the SERVED text is bilingual, under the C-13 per-tool budget, and carries its trigger phrase is the dynamique half of C-19 \u2014 this static run asserts source-level presence only, run with a live session (--mode=dynamic|both) for the served measurement.`
+    };
+  },
+  runDynamic(runtime) {
+    if (runtime.launchError) {
+      const reason = `server could not be launched/introspected: ${runtime.launchError} \u2014 served descriptions unreadable (C-19)`;
+      return {
+        id: this.id,
+        anchor: runtime.root,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    if (runtime.tools.length === 0) {
+      return {
+        id: this.id,
+        anchor: runtime.root,
+        state: "absent",
+        verdict: "server serves no tools over tools/list; served-descriptions check n/a (C-19)"
+      };
+    }
+    const ceiling = findCeiling(loadTree(runtime.root));
+    for (const t of runtime.tools) {
+      if (!t.description) {
+        return {
+          id: this.id,
+          anchor: t.name,
+          state: "non-conforming",
+          verdict: `tool "${t.name}" serves NO description over tools/list -> C-19 requires one, in both languages, with its trigger phrase`
+        };
+      }
+      if (ceiling) {
+        const estTokens = Math.ceil(t.description.length / 4);
+        if (estTokens > ceiling.perTool) {
+          return {
+            id: this.id,
+            anchor: t.name,
+            state: "non-conforming",
+            verdict: `tool "${t.name}" serves a description estimated at ${estTokens} tokens, above the declared per-tool ceiling ${ceiling.perTool} (${ceiling.anchor}) -> shorten it (C-19/C-13)`
+          };
+        }
+      }
+      if (!BILINGUAL_SPLIT_RE.test(t.description)) {
+        return {
+          id: this.id,
+          anchor: t.name,
+          state: "non-conforming",
+          verdict: `tool "${t.name}" serves a description with no "<en> / <fr>" bilingual split -> serve both languages (C-19)`
+        };
+      }
+      if (!TRIGGER_LIST_RE.test(t.description) || !TRIGGER_CLOSE_RE.test(t.description)) {
+        return {
+          id: this.id,
+          anchor: t.name,
+          state: "non-conforming",
+          verdict: `tool "${t.name}" serves a description with no trigger-phrase clause ("use this whenever ... even if they don't say") -> add it (C-19)`
+        };
+      }
+    }
+    return {
+      id: this.id,
+      anchor: runtime.tools[0].name,
+      state: "present",
+      verdict: `${runtime.tools.length} served tool description(s) are bilingual, under the declared per-tool budget${ceiling ? ` (${ceiling.perTool})` : " (no ceiling declared)"}, and carry their trigger phrase (C-19). Prose quality beyond this mechanical check remains a human judgment.`
+    };
+  }
+};
+
+// src/detectors/c20-locales-derived.ts
+var I18N_DIR_RE = /^src\/i18n\/([a-z]{2}(?:-[A-Z]{2})?)\.tsx?$/;
+var I18N_PLUMBING = /* @__PURE__ */ new Set(["index", "types", "locale", "locales"]);
+function deriveLocales(tree) {
+  const out = [];
+  for (const file of tree.files) {
+    const m = file.rel.match(I18N_DIR_RE);
+    if (m && !I18N_PLUMBING.has(m[1])) {
+      out.push({ code: m[1], anchor: `${file.rel}:1` });
+    }
+  }
+  return out;
+}
+var HARDCODED_UNION_RE = /\btype\s+Locale\s*=\s*["'`][a-z]{2}["'`](?:\s*\|\s*["'`][a-z]{2}["'`])+/;
+var HARDCODED_ARRAY_RE = /\b(?:const|let)\s+(?:SUPPORTED_LOCALES|LOCALES)\s*(?::[^=]+)?=\s*\[\s*["'`][a-z]{2}["'`](?:\s*,\s*["'`][a-z]{2}["'`])+/;
+var HARDCODED_ENUM_RE = /\benum\s+Locale\s*\{/;
+function c20PositiveControls() {
+  const unionSample = 'type Locale = "en" | "fr";';
+  const arraySample = 'const SUPPORTED_LOCALES = ["en", "fr"];';
+  const derivedSample = 'const LOCALES = readdirSync(join(__dirname, "i18n")).map((f) => f.replace(/\\.ts$/, ""));';
+  return {
+    unionMatcher: {
+      pattern: HARDCODED_UNION_RE.source,
+      sample: unionSample,
+      matched: HARDCODED_UNION_RE.test(unionSample)
+    },
+    arrayMatcher: {
+      pattern: HARDCODED_ARRAY_RE.source,
+      sample: arraySample,
+      matched: HARDCODED_ARRAY_RE.test(arraySample)
+    },
+    arrayClearsDerivedUsage: !HARDCODED_ARRAY_RE.test(derivedSample)
+  };
+}
+function findHardcodedEnumerations(tree) {
+  const hits = [];
+  for (const file of tree.files) {
+    if (I18N_DIR_RE.test(file.rel)) continue;
+    for (const line of file.lines) {
+      if (line.comment) continue;
+      if (HARDCODED_UNION_RE.test(line.raw)) {
+        hits.push({ file: file.rel, line: line.n, kind: "union type" });
+      } else if (HARDCODED_ARRAY_RE.test(line.raw)) {
+        hits.push({ file: file.rel, line: line.n, kind: "literal array" });
+      } else if (HARDCODED_ENUM_RE.test(line.raw)) {
+        hits.push({ file: file.rel, line: line.n, kind: "enum" });
+      }
+    }
+  }
+  return hits;
+}
+var c20LocalesDerived = {
+  id: "C20 locales-derived",
+  rule: "C-20",
+  pin: "a74a042b53c71a095ab88b3073bd47728eeda814",
+  run(tree) {
+    const controls = c20PositiveControls();
+    if (!controls.unionMatcher.matched || !controls.arrayMatcher.matched) {
+      throw new Error(
+        `C20 positive control FAILED: union=${controls.unionMatcher.matched} array=${controls.arrayMatcher.matched} \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    if (!controls.arrayClearsDerivedUsage) {
+      throw new Error(
+        "C20 array-matcher control FAILED: must NOT flag a genuinely derived (readdirSync-built) locales binding \u2014 verdict untrustworthy"
+      );
+    }
+    const locales = deriveLocales(tree);
+    if (locales.length === 0) {
+      return {
+        id: this.id,
+        anchor: "-",
+        state: "absent",
+        verdict: "no src/i18n/ locale files found; locales-derived check n/a"
+      };
+    }
+    const hits = findHardcodedEnumerations(tree);
+    if (hits.length > 0) {
+      const h = hits[0];
+      return {
+        id: this.id,
+        anchor: `${h.file}:${h.line}`,
+        state: "non-conforming",
+        verdict: `hardcoded locale ${h.kind} at ${h.file}:${h.line}, alongside ${locales.length} locale file(s) derived from src/i18n/ (positive-control OK) -> derive the locale set from src/i18n/, never hand-list it (C-20)`
+      };
+    }
+    return {
+      id: this.id,
+      anchor: locales[0].anchor,
+      state: "present",
+      verdict: `${locales.length} locale(s) derived from src/i18n/ (${locales.map((l) => l.code).join(", ")}), no hardcoded enumeration found (positive-control OK; static half only \u2014 the per-locale served-response check is dynamic and out of scope for this run)`
+    };
+  }
+};
+
+// src/detectors/c21-progressive-disclosure.ts
+var PIN7 = "a74a042b53c71a095ab88b3073bd47728eeda814";
+var ESTIMATED_BYTES_PER_TOKEN = 4;
+function c21PositiveControls() {
+  return { ceilingReadable: typeof findCeiling === "function" };
+}
+function estimateHandshakeTokens(runtime) {
+  const payload = JSON.stringify(
+    runtime.tools.map((t) => ({ name: t.name, description: t.description ?? "" }))
+  );
+  return Math.ceil(payload.length / ESTIMATED_BYTES_PER_TOKEN);
+}
+var c21ProgressiveDisclosure = {
+  id: "C21 progressive-disclosure",
+  rule: "C-21",
+  pin: PIN7,
+  run(_tree) {
+    const controls = c21PositiveControls();
+    if (!controls.ceilingReadable) {
+      throw new Error(
+        "C21 control FAILED: C-13 findCeiling not importable \u2014 verdict untrustworthy"
+      );
+    }
+    return {
+      id: this.id,
+      anchor: "-",
+      state: "absent",
+      verdict: "C-21 measures what actually lands in context at connection (handshake), which a static-tree run cannot read \u2014 connect with a live session (--mode=dynamic|both) to measure it against the C-13 declared ceiling (C-21 n/a on a static-only run)"
+    };
+  },
+  runDynamic(runtime) {
+    if (runtime.launchError) {
+      const reason = `server could not be launched/introspected: ${runtime.launchError} \u2014 connection-load unmeasurable (C-21)`;
+      return {
+        id: this.id,
+        anchor: runtime.root,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const ceiling = findCeiling(loadTree(runtime.root));
+    if (!ceiling) {
+      const reason = "no (global, perTool) context ceiling declared anywhere in the tree (C-13) \u2014 C-21 has nothing to measure against";
+      return {
+        id: this.id,
+        anchor: runtime.root,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const measured = estimateHandshakeTokens(runtime);
+    if (measured > ceiling.global) {
+      return {
+        id: this.id,
+        anchor: ceiling.anchor,
+        state: "non-conforming",
+        verdict: `measured connection load ~${measured} tokens (served tools/list payload) exceeds the declared global ceiling ${ceiling.global} (${ceiling.anchor}) -> stage publication by tiers (C-21, the measured half of C-13)`
+      };
+    }
+    return {
+      id: this.id,
+      anchor: ceiling.anchor,
+      state: "present",
+      verdict: `measured connection load ~${measured} tokens, within the declared global ceiling ${ceiling.global} (${ceiling.anchor}) -> C-13's declaration holds under measurement (C-21)`
+    };
+  }
+};
+
+// src/detectors/c22-test-ratio-gate.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
+var DOC_FILES2 = ["README.md", "README.fr.md", "CHANGELOG.md"];
+var RATIO_RE = /\b(?:coverage|ratio de tests?|test ratio|couverture)\b[^\n%]{0,40}?(\d{1,3}(?:\.\d+)?\s?%)/i;
+var IDENTIFIER_RE = /\b(?:run[/#]?\s?\d+|workflow run|gh run|actions\/runs\/\d+|CI#\d+|\b[0-9a-f]{7,40}\b)/i;
+function c22PositiveControls() {
+  const ratioSample = "Coverage: 92%";
+  const idSample = "Coverage: 92% (CI run https://github.com/x/y/actions/runs/123456)";
+  const bareSample = "Coverage: 92%, measured locally.";
+  return {
+    ratioMatcher: {
+      pattern: RATIO_RE.source,
+      sample: ratioSample,
+      matched: RATIO_RE.test(ratioSample)
+    },
+    identifierMatcher: {
+      pattern: IDENTIFIER_RE.source,
+      sample: idSample,
+      matched: IDENTIFIER_RE.test(idSample)
+    },
+    identifierClearsBareRatio: !IDENTIFIER_RE.test(bareSample)
+  };
+}
+function findRatioCitations(root) {
+  const hits = [];
+  for (const name of DOC_FILES2) {
+    const path = join5(root, name);
+    if (!existsSync5(path)) continue;
+    let text;
+    try {
+      text = readFileSync5(path, "utf8");
+    } catch {
+      continue;
+    }
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const raw = lines[i];
+      if (RATIO_RE.test(raw)) {
+        hits.push({ file: name, line: i + 1, raw, hasIdentifier: IDENTIFIER_RE.test(raw) });
+      }
+    }
+  }
+  return hits;
+}
+var c22TestRatioGate = {
+  id: "C22 test-ratio-gate",
+  rule: "C-22",
+  pin: "a74a042b53c71a095ab88b3073bd47728eeda814",
+  run(tree) {
+    const controls = c22PositiveControls();
+    if (!controls.ratioMatcher.matched || !controls.identifierMatcher.matched) {
+      throw new Error(
+        `C22 positive control FAILED: ratio=${controls.ratioMatcher.matched} identifier=${controls.identifierMatcher.matched} \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    if (!controls.identifierClearsBareRatio) {
+      throw new Error(
+        "C22 identifier-matcher control FAILED: must NOT flag a bare ratio with no identifier token \u2014 verdict untrustworthy"
+      );
+    }
+    const hits = findRatioCitations(tree.root);
+    if (hits.length === 0) {
+      return {
+        id: this.id,
+        anchor: "-",
+        state: "absent",
+        verdict: "no test/coverage ratio cited in README/CHANGELOG; test-ratio-gate check n/a"
+      };
+    }
+    const bare = hits.find((h) => !h.hasIdentifier);
+    if (bare) {
+      return {
+        id: this.id,
+        anchor: `${bare.file}:${bare.line}`,
+        state: "non-conforming",
+        verdict: `ratio cited at ${bare.file}:${bare.line} ("${bare.raw.trim()}") carries no passage-identifier token (positive-control OK) -> cite the automatic run/commit identifier the ratio was produced by (C-22)`
+      };
+    }
+    const withId = hits[0];
+    const reason = `ratio cited at ${withId.file}:${withId.line} carries an identifier-shaped token, but whether it RESOLVES against a live CI run is the gate half of C-22 \u2014 this static-only run has no CI query surface and cannot confirm resolution`;
+    return {
+      id: this.id,
+      anchor: `${withId.file}:${withId.line}`,
+      state: "could-not-judge",
+      reason,
+      verdict: `could not judge: ${reason}`
+    };
+  }
+};
+
+// src/detectors/c25-build-identity.ts
+var PIN8 = "20136b50";
+var IDENTITY_KEY_NAMES = [
+  "buildId",
+  "buildID",
+  "buildSha",
+  "buildHash",
+  "commitHash",
+  "commitSha",
+  "gitSha",
+  "gitCommit",
+  "gitRevision"
+];
+var CONSTRUCTOR_RE = /\bnew\s+(?:McpServer|Server)\s*\(/;
+var IDENTITY_KEY_LINE_RE = new RegExp(
+  `\\b(${IDENTITY_KEY_NAMES.join("|")})\\s*:\\s*(.+?)\\s*,?\\s*$`
+);
+var IDENTITY_KEY_BARE_RE = new RegExp(`\\b(${IDENTITY_KEY_NAMES.join("|")})\\s*:\\s*$`);
+var LITERAL_SAMPLE = 'commitSha: "a1b2c3d",';
+var DERIVED_SAMPLE = "buildId: process.env.BUILD_SHA,";
+var FULL_COMMIT_ID = /^[0-9a-f]{40}$/;
+function isLiteralValue(expr) {
+  const trimmed = expr.trim().replace(/,$/, "").trim();
+  const m = trimmed.match(/^(["'`])([\s\S]*)\1$/);
+  if (!m) return false;
+  if (m[1] === "`" && /\$\{/.test(m[2])) return false;
+  return true;
+}
+function c25PositiveControls() {
+  const literalMatch = LITERAL_SAMPLE.match(IDENTITY_KEY_LINE_RE);
+  const derivedMatch = DERIVED_SAMPLE.match(IDENTITY_KEY_LINE_RE);
+  return {
+    literalAccepts: literalMatch ? isLiteralValue(literalMatch[2]) : false,
+    derivedRejectsAsLiteral: derivedMatch ? isLiteralValue(derivedMatch[2]) : false
+  };
+}
+function extractConstructorArgs(file, startIdx) {
+  const code = file.lines.filter((l) => !l.comment);
+  const startPos = code.findIndex((l) => l.n === file.lines[startIdx].n);
+  if (startPos < 0) return null;
+  const text = code.slice(startPos).map((l) => l.raw).join("\n");
+  const openIdx = text.indexOf("(");
+  if (openIdx < 0) return null;
+  let depth = 0;
+  let body = "";
+  for (let i = openIdx; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "(") {
+      depth++;
+      if (depth === 1) continue;
+    } else if (ch === ")") {
+      depth--;
+      if (depth === 0) return body;
+    }
+    if (depth >= 1) body += ch;
+  }
+  return null;
+}
+function findConstructorSites(tree) {
+  const sites = [];
+  for (const file of tree.files) {
+    file.lines.forEach((line, idx) => {
+      if (line.comment) return;
+      if (CONSTRUCTOR_RE.test(line.raw)) {
+        sites.push({
+          anchor: `${file.rel}:${line.n}`,
+          args: extractConstructorArgs(file, idx)
+        });
+      }
+    });
+  }
+  return sites;
+}
+function classifyArgs(args, anchor) {
+  for (const raw of args.split("\n")) {
+    const bare = raw.match(IDENTITY_KEY_BARE_RE);
+    if (bare) return { kind: "bare-continuation", key: bare[1], anchor };
+    const m = raw.match(IDENTITY_KEY_LINE_RE);
+    if (m) {
+      const [, key, value] = m;
+      if (isLiteralValue(value)) return { kind: "literal", key, value: value.trim(), anchor };
+      return { kind: "derived", key, anchor };
+    }
+  }
+  return { kind: "none" };
+}
+var c25BuildIdentity = {
+  id: "C25 build-identity",
+  rule: "C-25",
+  pin: PIN8,
+  run(tree) {
+    const controls = c25PositiveControls();
+    if (!controls.literalAccepts || controls.derivedRejectsAsLiteral) {
+      throw new Error(
+        `C25 literal/derived control FAILED: ${JSON.stringify(controls)} \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    const sites = findConstructorSites(tree);
+    if (sites.length === 0) {
+      return {
+        id: this.id,
+        anchor: tree.files.length > 0 ? `${tree.files[0].rel}:1` : tree.root,
+        state: "absent",
+        verdict: "no `new McpServer(...)`/`new Server(...)` construction found; C-25 n/a"
+      };
+    }
+    for (const site of sites) {
+      if (site.args === null) {
+        const reason = `constructor call at ${site.anchor} could not be delimited (unbalanced/EOF) \u2014 the build-identity field could not be searched over its full argument object, scope unestablished`;
+        return {
+          id: this.id,
+          anchor: site.anchor,
+          state: "could-not-judge",
+          reason,
+          verdict: `could not judge: ${reason}`
+        };
+      }
+    }
+    for (const site of sites) {
+      const finding = classifyArgs(site.args, site.anchor);
+      if (finding.kind === "bare-continuation") {
+        const reason = `identity key "${finding.key}" found at ${finding.anchor} but its value continues past the line (not statically joined) \u2014 verdict unreadable`;
+        return {
+          id: this.id,
+          anchor: finding.anchor,
+          state: "could-not-judge",
+          reason,
+          verdict: `could not judge: ${reason}`
+        };
+      }
+      if (finding.kind === "derived") {
+        return {
+          id: this.id,
+          anchor: finding.anchor,
+          state: "present",
+          verdict: `build-identity field "${finding.key}" at ${finding.anchor} is fed by the build (not a literal) \u2014 served alongside version (C-25). Whether the SERVED value equals the expected commit is the dynamique half, run with a live session.`
+        };
+      }
+      if (finding.kind === "literal") {
+        return {
+          id: this.id,
+          anchor: finding.anchor,
+          state: "non-conforming",
+          verdict: `build-identity field "${finding.key}" at ${finding.anchor} is a hand-written literal (${finding.value}) -> a literal never changes on its own and proves nothing about the tree actually served; derive it from the build (env var injected at build time, or a generated file) (C-25)`
+        };
+      }
+    }
+    return {
+      id: this.id,
+      anchor: sites[0].anchor,
+      state: "non-conforming",
+      verdict: `server construction at ${sites[0].anchor} declares no build-identity field (${IDENTITY_KEY_NAMES.join("/")}) alongside version -> a version is a DECLARED value that only changes if someone remembers to bump it; add a build identity derived from the tree actually built (C-25)`
+    };
+  },
+  runDynamic(runtime) {
+    if (runtime.launchError) {
+      const reason = `server could not be launched/introspected: ${runtime.launchError} \u2014 served build-identity unreadable (C-25)`;
+      return {
+        id: this.id,
+        anchor: runtime.root,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const serverInfo = runtime.serverInfo ?? {};
+    let found = null;
+    for (const key of IDENTITY_KEY_NAMES) {
+      const v = serverInfo[key];
+      if (v !== void 0 && v !== null && String(v).trim() !== "") {
+        found = { key, value: String(v) };
+        break;
+      }
+    }
+    if (!found) {
+      const declaredVersion = typeof serverInfo.version === "string" ? serverInfo.version : "?";
+      return {
+        id: this.id,
+        anchor: runtime.root,
+        state: "non-conforming",
+        verdict: `server serves no build-identity field (${IDENTITY_KEY_NAMES.join("/")}) over initialize's serverInfo \u2014 only version="${declaredVersion}" -> a declared version proves nothing about the tree served; C-25 requires one`
+      };
+    }
+    if (!runtime.expectedCommit) {
+      const reason = `identity "${found.key}"="${found.value}" served, but no expected commit was supplied to compare against (target is not a resolvable git checkout, or HEAD did not resolve) \u2014 the static verdict stands; the served-vs-expected comparison is OWED, not a pass`;
+      return {
+        id: this.id,
+        anchor: runtime.root,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const served = found.value.trim().toLowerCase();
+    const expected = runtime.expectedCommit.trim().toLowerCase();
+    if (!FULL_COMMIT_ID.test(expected)) {
+      const reason = `expected commit "${runtime.expectedCommit}" is not a full 40-hex commit id \u2014 the served-vs-expected comparison reasons about length and is only sound against a full id (see deriveExpectedCommit in src/runtime/launch.ts); refusing to judge rather than comparing against a value outside the contract`;
+      return {
+        id: this.id,
+        anchor: runtime.root,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const ABBREVIATED_IDENTITY_FLOOR = 7;
+    if (served !== expected && served.length < ABBREVIATED_IDENTITY_FLOOR) {
+      const reason = `served build-identity "${found.key}"="${found.value}" is ${served.length} character(s) long \u2014 below the ${ABBREVIATED_IDENTITY_FLOOR}-character floor under which an abbreviated commit cannot be told from a coincidence (one hex character matches one expected commit in sixteen); the served-vs-expected comparison against "${runtime.expectedCommit}" is UNDECIDABLE, not a pass`;
+      return {
+        id: this.id,
+        anchor: runtime.root,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    if (served.length > expected.length && served.startsWith(expected)) {
+      const suffix = found.value.trim().slice(expected.length);
+      return {
+        id: this.id,
+        anchor: runtime.root,
+        state: "non-conforming",
+        verdict: `served build-identity "${found.key}"="${found.value}" is the expected commit "${runtime.expectedCommit}" DECORATED with "${suffix}" -> a full commit id carries no suffix, and the suffixes that occur in practice (-dirty, +local) state that the tree served is NOT that commit; the running server is not serving the tree it claims to (C-25)`
+      };
+    }
+    const matches = served === expected || served.length < expected.length && expected.startsWith(served);
+    if (!matches) {
+      return {
+        id: this.id,
+        anchor: runtime.root,
+        state: "non-conforming",
+        verdict: `served build-identity "${found.key}"="${found.value}" DIFFERS from the expected commit "${runtime.expectedCommit}" -> the running server is not serving the tree it claims to (C-25)`
+      };
+    }
+    return {
+      id: this.id,
+      anchor: runtime.root,
+      state: "present",
+      verdict: `served build-identity "${found.key}"="${found.value}" equals the expected commit "${runtime.expectedCommit}" (C-25)`
+    };
+  }
+};
+
+// src/detectors/c26-subpackage-lockfile.ts
+import { spawnSync } from "child_process";
+import {
+  existsSync as existsSync6,
+  mkdtempSync,
+  readFileSync as readFileSync6,
+  readdirSync as readdirSync3,
+  rmSync,
+  statSync as statSync2,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+import { join as join6, relative as relative2 } from "path";
+var PIN9 = "20136b50";
+var DEPLOY_CONFIG_FILES = [
+  "railway.json",
+  "railway.toml",
+  "Dockerfile",
+  "fly.toml",
+  "Procfile",
+  "vercel.json"
+];
+var LOCKFILES2 = [
+  { name: "package-lock.json", command: "npm", args: ["ci"] },
+  { name: "bun.lock", command: "bun", args: ["install", "--frozen-lockfile"] },
+  { name: "bun.lockb", command: "bun", args: ["install", "--frozen-lockfile"] },
+  { name: "pnpm-lock.yaml", command: "pnpm", args: ["install", "--frozen-lockfile"] },
+  { name: "yarn.lock", command: "yarn", args: ["install", "--frozen-lockfile"] }
+];
+var SKIP_WALK_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "coverage"]);
+function walkForConfigs(dir, depth, seen) {
+  if (depth > 8) return;
+  let entries;
+  try {
+    entries = readdirSync3(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const full = join6(dir, name);
+    let st;
+    try {
+      st = statSync2(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) {
+      if (SKIP_WALK_DIRS.has(name)) continue;
+      walkForConfigs(full, depth + 1, seen);
+    } else if (DEPLOY_CONFIG_FILES.includes(name)) {
+      if (!seen.has(dir)) {
+        seen.set(dir, { dir, configFile: name, configPath: full });
+      }
+    }
+  }
+}
+function resolveRailwayRootDirectory(configPath) {
+  let text;
+  try {
+    text = readFileSync6(configPath, "utf8");
+  } catch (err) {
+    return {
+      error: `could not read ${configPath}: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err) {
+    return {
+      error: `could not parse ${configPath} as JSON: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const build = parsed.build;
+  const rootDirectory = typeof parsed.rootDirectory === "string" && parsed.rootDirectory || build && typeof build.rootDirectory === "string" && build.rootDirectory || null;
+  return rootDirectory;
+}
+function c26DeriveScope(root) {
+  const seen = /* @__PURE__ */ new Map();
+  walkForConfigs(root, 0, seen);
+  const sites = [];
+  for (const site of seen.values()) {
+    if (site.configFile === "railway.json") {
+      const resolved = resolveRailwayRootDirectory(site.configPath);
+      if (resolved && typeof resolved === "object" && "error" in resolved) {
+        return { sites: [], unparsable: { path: site.configPath, reason: resolved.error } };
+      }
+      if (typeof resolved === "string" && resolved.trim()) {
+        sites.push({ ...site, dir: join6(site.dir, resolved) });
+        continue;
+      }
+    }
+    if (site.configFile === "vercel.json") {
+      try {
+        JSON.parse(readFileSync6(site.configPath, "utf8"));
+      } catch (err) {
+        return {
+          sites: [],
+          unparsable: {
+            path: site.configPath,
+            reason: `could not parse ${site.configPath} as JSON: ${err instanceof Error ? err.message : String(err)}`
+          }
+        };
+      }
+    }
+    sites.push(site);
+  }
+  return { sites };
+}
+function findLockfile2(dir) {
+  for (const l of LOCKFILES2) {
+    if (existsSync6(join6(dir, l.name))) return l;
+  }
+  return null;
+}
+var NPM_INVALID_RE = /Invalid: lock file's (@?[^\s@]+(?:\/[^\s@]+)?)@(\S+) does not satisfy \1@(\S+)/;
+var NPM_MISSING_RE = /Missing: (@?[^\s@]+(?:\/[^\s@]+)?)@(\S+) from lock file/;
+function parseLenientJson(text) {
+  return JSON.parse(text.replace(/,(\s*[\]}])/g, "$1"));
+}
+function nameBunDrift(manifestText, lockText) {
+  let manifest;
+  let lock;
+  try {
+    manifest = JSON.parse(manifestText);
+    lock = parseLenientJson(lockText);
+  } catch {
+    return [];
+  }
+  const manifestDeps = {
+    ...manifest.dependencies,
+    ...manifest.devDependencies
+  };
+  const workspaces = lock.workspaces;
+  const root = workspaces?.[""];
+  const lockDeps = {
+    ...root?.dependencies,
+    ...root?.devDependencies
+  };
+  const drifted = [];
+  for (const [name, range] of Object.entries(manifestDeps)) {
+    const lockedRange = lockDeps[name];
+    if (lockedRange !== void 0 && lockedRange !== range) {
+      drifted.push(`${name} (package.json wants ${range}, bun.lock recorded ${lockedRange})`);
+    }
+  }
+  return drifted;
+}
+function extractGenericToken(stderr) {
+  const m = stderr.match(/(@?[\w.-]+(?:\/[\w.-]+)?)@[\w.^~><=|| -]+/);
+  return m ? m[1] : null;
+}
+function nameDrift(lockfileName, siteDir, isolatedDir, stderr) {
+  if (lockfileName === "package-lock.json") {
+    const invalid = stderr.match(NPM_INVALID_RE);
+    if (invalid)
+      return `${invalid[1]} (lockfile has ${invalid[2]}, package.json wants ${invalid[3]})`;
+    const missing = stderr.match(NPM_MISSING_RE);
+    if (missing) return `${missing[1]}@${missing[2]} missing from lock file`;
+  }
+  if (lockfileName === "bun.lock" || lockfileName === "bun.lockb") {
+    try {
+      const manifestText = readFileSync6(join6(isolatedDir, "package.json"), "utf8");
+      const lockText = readFileSync6(join6(isolatedDir, lockfileName), "utf8");
+      const drifted = nameBunDrift(manifestText, lockText);
+      if (drifted.length > 0) return drifted.join(", ");
+    } catch {
+    }
+  }
+  const generic = extractGenericToken(stderr);
+  if (generic)
+    return `${generic} (name extracted from raw install output, see verdict for the full line)`;
+  return `dependency name not statically extractable from this manager's output at ${siteDir} \u2014 raw: ${stderr.slice(0, 300).trim()}`;
+}
+function gateSite(site) {
+  const pkgPath = join6(site.dir, "package.json");
+  if (!existsSync6(pkgPath)) {
+    return {
+      site,
+      status: "skipped",
+      reason: `no package.json at ${site.dir} \u2014 not an npm-managed deployable subpackage, C-26 n/a for this site`
+    };
+  }
+  const lock = findLockfile2(site.dir);
+  if (!lock) {
+    return {
+      site,
+      status: "analysed",
+      ok: false,
+      detail: `no lockfile (${LOCKFILES2.map((l) => l.name).join("/")}) present at ${site.dir} while its deployment (${site.configFile}) requires one`
+    };
+  }
+  const isolated = mkdtempSync(join6(tmpdir(), "mcp-doctor-c26-"));
+  try {
+    const manifestText = readFileSync6(pkgPath, "utf8");
+    const lockText = readFileSync6(join6(site.dir, lock.name), "utf8");
+    writeFileSync(join6(isolated, "package.json"), manifestText);
+    writeFileSync(join6(isolated, lock.name), lockText);
+    let proc;
+    try {
+      proc = spawnSync(lock.command, lock.args, {
+        cwd: isolated,
+        encoding: "utf8",
+        timeout: 6e4
+      });
+    } catch (err) {
+      return {
+        site,
+        status: "analysed",
+        ok: false,
+        detail: `could not run "${lock.command} ${lock.args.join(" ")}" in isolation: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    if (proc.error) {
+      return {
+        site,
+        status: "analysed",
+        ok: false,
+        detail: `"${lock.command}" is not available to run the frozen install in isolation: ${proc.error.message}`
+      };
+    }
+    if (proc.status !== 0) {
+      const stderr = (proc.stderr ?? "") + (proc.stdout ?? "");
+      const dep = nameDrift(lock.name, site.dir, isolated, stderr);
+      return {
+        site,
+        status: "analysed",
+        ok: false,
+        detail: `frozen install (${lock.command} ${lock.args.join(" ")}) FAILED in isolation at ${site.dir} -> drifted dependency: ${dep}`
+      };
+    }
+    return {
+      site,
+      status: "analysed",
+      ok: true,
+      detail: `frozen install (${lock.command} ${lock.args.join(" ")}) succeeded in isolation for ${site.dir}`
+    };
+  } finally {
+    rmSync(isolated, { recursive: true, force: true });
+  }
+}
+function renderCoverage(scope, verdicts) {
+  if (verdicts.length !== scope.length) {
+    throw new Error(
+      `mcp-doctor: C26 coverage inventory covers ${verdicts.length} of ${scope.length} derived sites \u2014 the run is not whole and will not report as if it were.`
+    );
+  }
+  const covered = new Set(verdicts.map((v) => v.site.dir));
+  for (const s of scope) {
+    if (!covered.has(s.dir)) {
+      throw new Error(`mcp-doctor: C26 coverage inventory omits derived site ${s.dir}.`);
+    }
+  }
+  return verdicts.map((v) => {
+    const rel = relative2(process.cwd(), v.site.dir) || v.site.dir;
+    if (v.status === "skipped") return `SKIPPED ${rel} (${v.reason})`;
+    return `ANALYSED ${rel} -> ${v.ok ? "GREEN" : "RED"}: ${v.detail}`;
+  }).join(" | ");
+}
+var c26SubpackageLockfile = {
+  id: "C26 subpackage-lockfile",
+  rule: "C-26",
+  pin: PIN9,
+  run(tree) {
+    const scope = c26DeriveScope(tree.root);
+    if (scope.unparsable) {
+      const reason = `deployment configuration ${scope.unparsable.path} could not be parsed: ${scope.unparsable.reason} \u2014 scope unestablished, C-26 cannot derive its targets`;
+      return {
+        id: this.id,
+        anchor: scope.unparsable.path,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    if (scope.sites.length === 0) {
+      return {
+        id: this.id,
+        anchor: tree.root,
+        state: "absent",
+        verdict: `no supported deployment configuration (${DEPLOY_CONFIG_FILES.join("/")}) found; C-26 n/a`
+      };
+    }
+    const verdicts = scope.sites.map(gateSite);
+    const inventory = renderCoverage(scope.sites, verdicts);
+    const analysed = verdicts.filter((v) => v.status === "analysed");
+    if (analysed.length === 0) {
+      return {
+        id: this.id,
+        anchor: tree.root,
+        state: "absent",
+        verdict: `deployment configuration(s) found but every targeted site is SKIPPED (none is npm-managed); C-26 n/a. Coverage: ${inventory}`
+      };
+    }
+    const reds = analysed.filter((v) => v.ok === false);
+    if (reds.length > 0) {
+      return {
+        id: this.id,
+        anchor: reds[0].site.dir,
+        state: "non-conforming",
+        verdict: reds.some((r) => r.detail?.includes("no lockfile")) ? `${reds[0].detail} (C-26). Coverage: ${inventory}` : `${reds.map((r) => r.detail).join(" ; ")} (C-26). Coverage: ${inventory}`
+      };
+    }
+    return {
+      id: this.id,
+      anchor: analysed[0].site.dir,
+      state: "present",
+      verdict: `every analysed deployable subpackage's lockfile is consistent, verified by a frozen install run in the SAME isolation the deployment uses (C-26). Coverage: ${inventory}`
+    };
+  }
+};
+
+// src/detectors/d2.ts
+var SESSION_RE = /mcp-session-id/i;
+var d2 = {
+  id: "D2 stateless",
+  run(tree) {
+    const hits = [];
+    for (const file of tree.files) {
+      for (const line of file.lines) {
+        if (line.comment) continue;
+        if (SESSION_RE.test(line.raw)) hits.push({ file: file.rel, line: line.n });
+      }
+    }
+    if (hits.length > 0) {
+      const anchor = `${hits[0].file}:${hits.map((h) => h.line).join(",")}`;
+      return {
+        id: this.id,
+        anchor,
+        state: "non-conforming",
+        verdict: "session-keyed (mcp-session-id header) -> migrate to stateless"
+      };
+    }
+    return {
+      id: this.id,
+      anchor: "-",
+      state: "present",
+      verdict: "stateless (no mcp-session-id session-keying)"
+    };
+  }
+};
 
 // src/detectors/d3.ts
 var RESULT_TYPE_RE = /\bresultType\b/;
@@ -487,8 +2963,8 @@ var d7 = {
 };
 
 // src/detectors/d8.ts
-import { existsSync, readFileSync, statSync } from "fs";
-import { dirname, join, relative } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
+import { dirname as dirname2, join as join7, relative as relative3 } from "path";
 var POSITIVE_CONTROL2 = 'server.registerTool("list_items", { ... }, handler);';
 function d8PositiveControl() {
   return {
@@ -498,9 +2974,9 @@ function d8PositiveControl() {
   };
 }
 function resolveBaseDir(tree) {
-  if (tree.packageJson) return dirname(tree.packageJson.path);
+  if (tree.packageJson) return dirname2(tree.packageJson.path);
   try {
-    return statSync(tree.root).isDirectory() ? tree.root : dirname(tree.root);
+    return statSync3(tree.root).isDirectory() ? tree.root : dirname2(tree.root);
   } catch {
     return tree.root;
   }
@@ -508,9 +2984,9 @@ function resolveBaseDir(tree) {
 function findEvalsFile(tree) {
   let dir = resolveBaseDir(tree);
   for (let depth = 0; depth < 8; depth++) {
-    const candidate = join(dir, "evals", "evals.json");
-    if (existsSync(candidate)) return candidate;
-    const parent = dirname(dir);
+    const candidate = join7(dir, "evals", "evals.json");
+    if (existsSync7(candidate)) return candidate;
+    const parent = dirname2(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -518,6 +2994,8 @@ function findEvalsFile(tree) {
 }
 var d8 = {
   id: "D8 eval-suite-coverage",
+  rule: "C-5",
+  pin: "a74a042b53c71a095ab88b3073bd47728eeda814",
   run(tree) {
     const control = d8PositiveControl();
     if (!control.matched) {
@@ -555,10 +3033,10 @@ var d8 = {
       };
     }
     const baseDir = resolveBaseDir(tree);
-    const displayPath = relative(baseDir, evalsPath) || evalsPath;
+    const displayPath = relative3(baseDir, evalsPath) || evalsPath;
     let cases;
     try {
-      const raw = readFileSync(evalsPath, "utf8");
+      const raw = readFileSync7(evalsPath, "utf8");
       const parsed = JSON.parse(raw);
       if (!Array.isArray(parsed.cases)) {
         throw new Error("`cases` is not an array");
@@ -642,8 +3120,8 @@ var d8 = {
 };
 
 // src/detectors/d9.ts
-import { existsSync as existsSync2 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { dirname as dirname3, join as join8 } from "path";
 var SEMVER_RE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
 var POSITIVE_CONTROL3 = "1.2.3-beta.1+build.7";
 function d9PositiveControl() {
@@ -655,6 +3133,8 @@ function d9PositiveControl() {
 }
 var d9 = {
   id: "D9 semver+changelog",
+  rule: "C-3",
+  pin: "a74a042b53c71a095ab88b3073bd47728eeda814",
   run(tree) {
     const control = d9PositiveControl();
     if (!control.matched) {
@@ -663,9 +3143,14 @@ var d9 = {
       );
     }
     if (!tree.packageJson) {
-      throw new Error(
-        "D9 could not locate package.json anywhere above the scanned root \u2014 cannot verify SemVer/CHANGELOG"
-      );
+      const reason = "no package.json found anywhere above the scanned root \u2014 cannot verify SemVer/CHANGELOG";
+      return {
+        id: this.id,
+        anchor: "package.json",
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
     }
     const { path: pkgPath, json: pkgJson } = tree.packageJson;
     if (!pkgJson || Object.keys(pkgJson).length === 0) {
@@ -680,9 +3165,9 @@ var d9 = {
         verdict: `no "version" field in ${pkgPath.split("/").pop()} -> set a valid SemVer version`
       };
     }
-    const projectDir = dirname2(pkgPath);
-    const changelogPath = join2(projectDir, "CHANGELOG.md");
-    const hasChangelog = existsSync2(changelogPath);
+    const projectDir = dirname3(pkgPath);
+    const changelogPath = join8(projectDir, "CHANGELOG.md");
+    const hasChangelog = existsSync8(changelogPath);
     const validSemver = SEMVER_RE.test(version);
     if (validSemver && hasChangelog) {
       return {
@@ -710,8 +3195,8 @@ var d9 = {
 };
 
 // src/detectors/d10.ts
-import { existsSync as existsSync3 } from "fs";
-import { dirname as dirname3, join as join3 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { dirname as dirname4, join as join9 } from "path";
 var DESCRIPTION_FR_RE = /"description_fr"\s*:\s*"[^"]+"/;
 var POSITIVE_CONTROL4 = '"description_fr": "Un serveur MCP conforme.",';
 function d10PositiveControl() {
@@ -761,6 +3246,8 @@ function scanSourceDescriptionFr(tree) {
 }
 var d10 = {
   id: "D10 bilingual",
+  rule: "C-1",
+  pin: "a74a042b53c71a095ab88b3073bd47728eeda814",
   run(tree) {
     const control = d10PositiveControl();
     if (!control.matched) {
@@ -784,7 +3271,7 @@ var d10 = {
       };
     }
     const { path: pkgPath, json: pkg } = tree.packageJson;
-    const root = dirname3(pkgPath);
+    const root = dirname4(pkgPath);
     const descriptionFr = typeof pkg.description_fr === "string" ? pkg.description_fr.trim() : "";
     const hasDescriptionFrJson = descriptionFr.length > 0;
     const sourceScan = scanSourceDescriptionFr(tree);
@@ -798,8 +3285,8 @@ var d10 = {
       };
     }
     const hasDescriptionFr = hasDescriptionFrJson || sourceScan.present;
-    const readmeFrPath = join3(root, "README.fr.md");
-    const hasReadmeFr = existsSync3(readmeFrPath);
+    const readmeFrPath = join9(root, "README.fr.md");
+    const hasReadmeFr = existsSync9(readmeFrPath);
     const missing = [];
     if (!hasDescriptionFr) missing.push("description_fr (package.json or source _meta)");
     if (!hasReadmeFr) missing.push("README.fr.md");
@@ -807,8 +3294,8 @@ var d10 = {
       return {
         id: this.id,
         anchor: `${pkgPath}`,
-        state: "absent",
-        verdict: `bilingual release missing: ${missing.join(", ")} -> no release without FR description + README.fr.md`
+        state: "non-conforming",
+        verdict: `bilingual release missing: ${missing.join(", ")} -> no release without FR description + README.fr.md (C-1)`
       };
     }
     const files = Array.isArray(pkg.files) ? pkg.files : null;
@@ -857,6 +3344,8 @@ function d11PositiveControls() {
 }
 var d11 = {
   id: "D11 zod-schemas",
+  rule: "C-4",
+  pin: "a74a042b53c71a095ab88b3073bd47728eeda814",
   run(tree) {
     const controls = d11PositiveControls();
     const failed = Object.entries(controls).find(([, c]) => !c.matched);
@@ -908,8 +3397,8 @@ var d11 = {
       return {
         id: this.id,
         anchor: firstToolAnchor ?? "-",
-        state: "absent",
-        verdict: `${toolCount} tool registration(s) found, 0 outputSchema in tree (positive-control OK) -> add output Zod schemas (Server Rule 4; tree-wide proxy, not per-tool \u2014 see D11 scope note)`
+        state: "non-conforming",
+        verdict: `${toolCount} tool registration(s) found, 0 outputSchema in tree (positive-control OK) -> add output Zod schemas (C-4; tree-wide proxy, not per-tool \u2014 see D11 scope note)`
       };
     }
     return {
@@ -1178,8 +3667,14 @@ var d15 = {
 };
 
 // src/detectors/d16.ts
+import { existsSync as existsSync10, readFileSync as readFileSync8, statSync as statSync4 } from "fs";
+import { dirname as dirname5, join as join10 } from "path";
 var DISCOVER_RE2 = /server\/discover|DiscoverResult|ServerDiscover|handleServerDiscover/;
-var HEALTH_ROUTE_RE = /\b[A-Za-z_$][\w$]*\.(?:get|post|put|patch|delete|all|route|use)\s*\(\s*["'`][^"'`]*\/health/;
+var HEALTH_ROUTE_FRAMEWORK_RE = /\b[A-Za-z_$][\w$]*\.(?:get|post|put|patch|delete|all|route|use)\s*\(\s*["'`][^"'`]*\/health/;
+var HEALTH_ROUTE_RAWPATH_RE = /\bpathname\s*===?\s*["'`][^"'`]*\/health/;
+var HEALTH_ROUTE_RE = new RegExp(
+  `${HEALTH_ROUTE_FRAMEWORK_RE.source}|${HEALTH_ROUTE_RAWPATH_RE.source}`
+);
 var VERSION_FIELD_RE = /\bversion\s*:/;
 var PKG_SOURCE_RE = /(?:pkg|pkgJson|packageJson|pjson|packageInfo)\.version|process\.env\.npm_package_version|["'`][^"'`]*package\.json["'`]/;
 var PKG_IMPORT_IMPORT_RE = /import\s+(?:\*\s+as\s+)?([A-Za-z_$][\w$]*)\s+from\s+["'`][^"'`]*package\.json["'`]/;
@@ -1196,11 +3691,20 @@ var CONTROLS2 = [
     negative: 'method: "tools/list"'
   },
   {
-    key: "health",
+    key: "health-framework",
     re: HEALTH_ROUTE_RE,
     positive: 'app.get("/health", handler)',
     negative: 'app.get("/tools", handler)'
   },
+  {
+    // FORM 2 — the raw-pathname comparison the old matcher was blind to.
+    // Positive is the REAL vantage-registry-mcp:297 shape; negative is the
+    // sibling `/mcp` route on the same server (a near-miss that must NOT match).
+    key: "health-rawpath",
+    re: HEALTH_ROUTE_RE,
+    positive: 'if (req.method === "GET" && url.pathname === "/health") {',
+    negative: 'if (url.pathname === "/mcp") {'
+  },
   {
     key: "pkg-source",
     re: PKG_SOURCE_RE,
@@ -1308,7 +3812,7 @@ var d16 = {
         id: this.id,
         anchor: tree.files.length > 0 ? `${tree.files[0].rel}:1` : tree.root,
         state: "absent",
-        verdict: "no server/discover handler and no /health route (n/a for Server Rule 16)"
+        verdict: "[static read] no server/discover handler and no /health route (n/a for Server Rule 16)"
       };
     }
     const present = surfaces.find((s) => s.kind === "present");
@@ -1317,7 +3821,7 @@ var d16 = {
         id: this.id,
         anchor: present.anchor,
         state: "present",
-        verdict: `version exposed pre-auth at ${present.anchor}, sourced from package.json (Server Rule 16)`
+        verdict: `[static read] version exposed pre-auth at ${present.anchor}, sourced from package.json (Server Rule 16)`
       };
     }
     const decisive = surfaces.find(
@@ -1338,7 +3842,7 @@ var d16 = {
         id: this.id,
         anchor: decisive.anchor,
         state: "non-conforming",
-        verdict: `${fix[decisive.kind]} at ${decisive.anchor} (Server Rule 16)`
+        verdict: `[static read] ${fix[decisive.kind]} at ${decisive.anchor} (Server Rule 16)`
       };
     }
     const unreadable = surfaces[0];
@@ -1352,7 +3856,7 @@ var d16 = {
     } else {
       detail = "is present but its source is not a resolvable package.json binding in the read window";
     }
-    const reason = `surface at ${unreadable.anchor} ${detail} \u2014 verdict unreadable statically (Server Rule 16)`;
+    const reason = `[static read] surface at ${unreadable.anchor} ${detail} \u2014 verdict unreadable statically (Server Rule 16)`;
     return {
       id: this.id,
       anchor: unreadable.anchor,
@@ -1360,12 +3864,97 @@ var d16 = {
       reason,
       verdict: `could not judge: ${reason}`
     };
+  },
+  /**
+   * DYNAMIC — Rule 16 judged from what the RUNNING server SERVES, its true home.
+   * The MCP `initialize` handshake returns `serverInfo.version` BEFORE any auth
+   * token is presented, so the served version is a pre-auth observable by
+   * construction. The served value is the truth: it is compared to the target's
+   * own package.json version (the canonical source Rule 16 requires).
+   *
+   *   present         — the server serves a version AND it equals package.json
+   *                     (observable pre-auth, sourced from the real version).
+   *   non-conforming  — the server serves NO version, OR serves a version that
+   *                     DRIFTS from package.json (a hardcoded literal is the
+   *                     classic cause; the served value != the package's truth).
+   *   could-not-judge — the server could not be launched/introspected (naming
+   *                     the failure), or its package.json could not be read to
+   *                     establish the canonical version to compare against.
+   *
+   * Every dynamic verdict says out loud it was produced by asking the running
+   * server ("[dynamic]"), so it is NEVER mistaken for the static fallback.
+   */
+  runDynamic(runtime) {
+    if (runtime.launchError) {
+      const reason = `[dynamic] server could not be started/introspected \u2014 served version unobservable: ${runtime.launchError} (Server Rule 16)`;
+      return {
+        id: this.id,
+        anchor: `${runtime.root} (runtime)`,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const servedRaw = runtime.serverInfo?.version;
+    const served = typeof servedRaw === "string" ? servedRaw.trim() : void 0;
+    const anchor = `${runtime.root} (runtime initialize)`;
+    if (!served) {
+      return {
+        id: this.id,
+        anchor,
+        state: "non-conforming",
+        verdict: "[dynamic] the running server serves NO version on the pre-auth initialize handshake -> expose a version sourced from package.json (Server Rule 16)"
+      };
+    }
+    const pkgVersion = readPackageVersion(runtime.root);
+    if (!pkgVersion) {
+      const reason = `[dynamic] the server serves version "${served}" but its package.json version could not be read to compare against \u2014 canonical version unestablished (Server Rule 16)`;
+      return {
+        id: this.id,
+        anchor,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    if (served === pkgVersion) {
+      return {
+        id: this.id,
+        anchor,
+        state: "present",
+        verdict: `[dynamic] running server serves version "${served}" pre-auth on initialize, matching package.json "${pkgVersion}" (Server Rule 16)`
+      };
+    }
+    return {
+      id: this.id,
+      anchor,
+      state: "non-conforming",
+      verdict: `[dynamic] running server serves version "${served}" but package.json is "${pkgVersion}" -> served value drifts from the package (source it from package.json) (Server Rule 16)`
+    };
   }
 };
+function readPackageVersion(root) {
+  try {
+    let dir = statSync4(root).isDirectory() ? root : dirname5(root);
+    for (let depth = 0; depth < 8; depth++) {
+      const candidate = join10(dir, "package.json");
+      if (existsSync10(candidate)) {
+        const pkg = JSON.parse(readFileSync8(candidate, "utf8"));
+        return typeof pkg.version === "string" ? pkg.version : null;
+      }
+      const parent = dirname5(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
 
 // src/detectors/dAppI18n.ts
-import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname4, join as join4 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname6, join as join11 } from "path";
 function flattenKeys(obj, prefix = "") {
   if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
     return prefix ? [prefix] : [];
@@ -1396,9 +3985,9 @@ function dAppI18nPositiveControls() {
     }
   };
 }
-function readJson(path) {
+function readJson2(path) {
   try {
-    return { ok: true, value: JSON.parse(readFileSync2(path, "utf8")) };
+    return { ok: true, value: JSON.parse(readFileSync9(path, "utf8")) };
   } catch {
     return { ok: false };
   }
@@ -1412,12 +4001,12 @@ var dAppI18n = {
         `DAppI18n key-diff control FAILED: detectsGap=${control.detectsGap} detectsComplete=${control.detectsComplete} \u2014 matcher broken, verdict untrustworthy`
       );
     }
-    const root = tree.packageJson ? dirname4(tree.packageJson.path) : tree.root;
-    const i18nDir = join4(root, "i18n");
-    const enPath = join4(i18nDir, "en.json");
-    const frPath = join4(i18nDir, "fr.json");
-    const hasI18n = existsSync4(i18nDir);
-    const hasFr = existsSync4(frPath);
+    const root = tree.packageJson ? dirname6(tree.packageJson.path) : tree.root;
+    const i18nDir = join11(root, "i18n");
+    const enPath = join11(i18nDir, "en.json");
+    const frPath = join11(i18nDir, "fr.json");
+    const hasI18n = existsSync11(i18nDir);
+    const hasFr = existsSync11(frPath);
     if (!hasI18n && !hasFr) {
       return {
         id: this.id,
@@ -1434,7 +4023,7 @@ var dAppI18n = {
         verdict: "i18n/ layer present but i18n/fr.json is missing -> ship the French locale (App Rule 2)"
       };
     }
-    const frRead = readJson(frPath);
+    const frRead = readJson2(frPath);
     if (!frRead.ok) {
       const reason = "i18n/fr.json is not readable JSON \u2014 cannot compare its keys against the source locale (App Rule 2)";
       return {
@@ -1445,7 +4034,7 @@ var dAppI18n = {
         verdict: `could not judge: ${reason}`
       };
     }
-    if (!existsSync4(enPath)) {
+    if (!existsSync11(enPath)) {
       const reason = "i18n/fr.json exists but no source-locale i18n/en.json to compare its keys against (App Rule 2)";
       return {
         id: this.id,
@@ -1455,7 +4044,7 @@ var dAppI18n = {
         verdict: `could not judge: ${reason}`
       };
     }
-    const enRead = readJson(enPath);
+    const enRead = readJson2(enPath);
     if (!enRead.ok) {
       const reason = "i18n/en.json (source locale) is not readable JSON \u2014 cannot derive the reference key set (App Rule 2)";
       return {
@@ -1588,46 +4177,46 @@ var dDebugOptIn = {
 };
 
 // src/detectors/dExt1.ts
-import { readFileSync as readFileSync3, readdirSync, statSync as statSync2 } from "fs";
-import { join as join5 } from "path";
-var IDENTIFIER_RE = /^[a-z0-9]+(\.[a-z0-9-]+)+\/[a-z0-9-]+$/;
+import { readFileSync as readFileSync10, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
+import { join as join12 } from "path";
+var IDENTIFIER_RE2 = /^[a-z0-9]+(\.[a-z0-9-]+)+\/[a-z0-9-]+$/;
 var IDENTIFIER_POSITIVE = "com.elpi/middleware-redact-pii";
 var IDENTIFIER_NEGATIVE = "Com.Elpi/Bad_Id";
 function dExt1PositiveControls() {
   return {
     identifier: {
-      pattern: IDENTIFIER_RE.source,
-      positive: IDENTIFIER_RE.test(IDENTIFIER_POSITIVE),
-      negative: IDENTIFIER_RE.test(IDENTIFIER_NEGATIVE)
+      pattern: IDENTIFIER_RE2.source,
+      positive: IDENTIFIER_RE2.test(IDENTIFIER_POSITIVE),
+      negative: IDENTIFIER_RE2.test(IDENTIFIER_NEGATIVE)
     }
   };
 }
-var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
+var SKIP_DIRS2 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
 function findExtensionManifests(root) {
   const out = [];
   let base;
   try {
-    base = statSync2(root).isDirectory() ? root : join5(root, "..");
+    base = statSync5(root).isDirectory() ? root : join12(root, "..");
   } catch {
     return out;
   }
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = readdirSync(dir);
+      entries = readdirSync4(dir);
     } catch {
       return;
     }
     for (const name of entries) {
-      const full = join5(dir, name);
+      const full = join12(dir, name);
       let st;
       try {
-        st = statSync2(full);
+        st = statSync5(full);
       } catch {
         continue;
       }
       if (st.isDirectory()) {
-        if (SKIP_DIRS.has(name)) continue;
+        if (SKIP_DIRS2.has(name)) continue;
         walk2(full);
       } else if (name === "extension.json") {
         out.push(full);
@@ -1667,11 +4256,11 @@ var dExt1 = {
       );
     }
     const manifests = findExtensionManifests(tree.root);
-    for (const manifestPath of manifests) {
-      const shortPath = manifestPath.split("/").slice(-2).join("/");
+    for (const manifestPath2 of manifests) {
+      const shortPath = manifestPath2.split("/").slice(-2).join("/");
       let parsed;
       try {
-        parsed = JSON.parse(readFileSync3(manifestPath, "utf8"));
+        parsed = JSON.parse(readFileSync10(manifestPath2, "utf8"));
       } catch {
         throw new Error(
           `DExt1 could not parse ${shortPath} as JSON \u2014 a present manifest with an unreadable identifier cannot pass (Extension Rule 1). Fail-closed, not a silent present.`
@@ -1683,7 +4272,7 @@ var dExt1 = {
           `DExt1 found a present manifest ${shortPath} with no string "identifier" field (got ${typeof idValue}) \u2014 Extension Rule 1 requires a reverse-DNS identifier. Fail-closed, not a silent present.`
         );
       }
-      if (!IDENTIFIER_RE.test(idValue)) {
+      if (!IDENTIFIER_RE2.test(idValue)) {
         return {
           id: this.id,
           anchor: shortPath,
@@ -1699,7 +4288,7 @@ var dExt1 = {
       );
     }
     for (const site of sites) {
-      if (!IDENTIFIER_RE.test(site.value)) {
+      if (!IDENTIFIER_RE2.test(site.value)) {
         return {
           id: this.id,
           anchor: site.anchor,
@@ -1727,8 +4316,8 @@ var dExt1 = {
 };
 
 // src/detectors/dExt2.ts
-import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync11, readdirSync as readdirSync5, statSync as statSync6 } from "fs";
+import { join as join13 } from "path";
 var TS_GD_TRUE_RE = /\bgracefulDegradation:\s*true\b/;
 var TS_GD_FALSE_RE = /\bgracefulDegradation:\s*false\b/;
 var TS_GD_KEY_RE = /\bgracefulDegradation:\s*([^\s,}]+)/;
@@ -1743,32 +4332,32 @@ function dExt2PositiveControls() {
     }
   };
 }
-var SKIP_DIRS2 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
+var SKIP_DIRS3 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
 function findExtensionManifests2(root) {
   const out = [];
   let base;
   try {
-    base = statSync3(root).isDirectory() ? root : join6(root, "..");
+    base = statSync6(root).isDirectory() ? root : join13(root, "..");
   } catch {
     return out;
   }
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = readdirSync2(dir);
+      entries = readdirSync5(dir);
     } catch {
       return;
     }
     for (const name of entries) {
-      const full = join6(dir, name);
+      const full = join13(dir, name);
       let st;
       try {
-        st = statSync3(full);
+        st = statSync6(full);
       } catch {
         continue;
       }
       if (st.isDirectory()) {
-        if (SKIP_DIRS2.has(name)) continue;
+        if (SKIP_DIRS3.has(name)) continue;
         walk2(full);
       } else if (name === "extension.json") {
         out.push(full);
@@ -1828,11 +4417,11 @@ var dExt2 = {
       );
     }
     const manifests = findExtensionManifests2(tree.root);
-    for (const manifestPath of manifests) {
-      const shortPath = manifestPath.split("/").slice(-2).join("/");
+    for (const manifestPath2 of manifests) {
+      const shortPath = manifestPath2.split("/").slice(-2).join("/");
       let parsed;
       try {
-        parsed = JSON.parse(readFileSync4(manifestPath, "utf8"));
+        parsed = JSON.parse(readFileSync11(manifestPath2, "utf8"));
       } catch {
         throw new Error(
           `DExt2 could not parse ${shortPath} as JSON \u2014 a present manifest silent on graceful degradation cannot pass (Extension Rule 2). Fail-closed, not a silent present.`
@@ -1896,8 +4485,8 @@ var dExt2 = {
 };
 
 // src/detectors/dExt3.ts
-import { readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync12, readdirSync as readdirSync6, statSync as statSync7 } from "fs";
+import { join as join14 } from "path";
 var TYPE_MATCHERS = [
   { type: "middleware", re: /\bmiddleware\b/ },
   { type: "tool-extension", re: /\btool-ext(?:ension)?\b/ },
@@ -1920,32 +4509,32 @@ function dExt3PositiveControls() {
     }
   };
 }
-var SKIP_DIRS3 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
+var SKIP_DIRS4 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
 function findExtensionManifests3(root) {
   const out = [];
   let base;
   try {
-    base = statSync4(root).isDirectory() ? root : join7(root, "..");
+    base = statSync7(root).isDirectory() ? root : join14(root, "..");
   } catch {
     return out;
   }
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = readdirSync3(dir);
+      entries = readdirSync6(dir);
     } catch {
       return;
     }
     for (const name of entries) {
-      const full = join7(dir, name);
+      const full = join14(dir, name);
       let st;
       try {
-        st = statSync4(full);
+        st = statSync7(full);
       } catch {
         continue;
       }
       if (st.isDirectory()) {
-        if (SKIP_DIRS3.has(name)) continue;
+        if (SKIP_DIRS4.has(name)) continue;
         walk2(full);
       } else if (name === "extension.json") {
         out.push(full);
@@ -2013,11 +4602,11 @@ var dExt3 = {
     const declared = /* @__PURE__ */ new Set();
     let firstAnchor2 = null;
     const manifests = findExtensionManifests3(tree.root);
-    for (const manifestPath of manifests) {
-      const shortPath = manifestPath.split("/").slice(-2).join("/");
+    for (const manifestPath2 of manifests) {
+      const shortPath = manifestPath2.split("/").slice(-2).join("/");
       let parsed;
       try {
-        parsed = JSON.parse(readFileSync5(manifestPath, "utf8"));
+        parsed = JSON.parse(readFileSync12(manifestPath2, "utf8"));
       } catch {
         throw new Error(
           `DExt3 could not parse ${shortPath} as JSON \u2014 a present manifest with an unreadable type cannot pass (Extension Rule 3). Fail-closed, not a silent present.`
@@ -2103,8 +4692,8 @@ var dExt3 = {
 };
 
 // src/detectors/dExt4.ts
-import { readFileSync as readFileSync6, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
-import { join as join8 } from "path";
+import { readFileSync as readFileSync13, readdirSync as readdirSync7, statSync as statSync8 } from "fs";
+import { join as join15 } from "path";
 function canonical(name) {
   return name.replace(/[-_]/g, "").toLowerCase();
 }
@@ -2123,32 +4712,32 @@ function dExt4PositiveControls() {
     }
   };
 }
-var SKIP_DIRS4 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
+var SKIP_DIRS5 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
 function findExtensionManifests4(root) {
   const out = [];
   let base;
   try {
-    base = statSync5(root).isDirectory() ? root : join8(root, "..");
+    base = statSync8(root).isDirectory() ? root : join15(root, "..");
   } catch {
     return out;
   }
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = readdirSync4(dir);
+      entries = readdirSync7(dir);
     } catch {
       return;
     }
     for (const name of entries) {
-      const full = join8(dir, name);
+      const full = join15(dir, name);
       let st;
       try {
-        st = statSync5(full);
+        st = statSync8(full);
       } catch {
         continue;
       }
       if (st.isDirectory()) {
-        if (SKIP_DIRS4.has(name)) continue;
+        if (SKIP_DIRS5.has(name)) continue;
         walk2(full);
       } else if (name === "extension.json") {
         out.push(full);
@@ -2162,32 +4751,32 @@ function findHooksDirs(root) {
   const out = [];
   let base;
   try {
-    base = statSync5(root).isDirectory() ? root : join8(root, "..");
+    base = statSync8(root).isDirectory() ? root : join15(root, "..");
   } catch {
     return out;
   }
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = readdirSync4(dir);
+      entries = readdirSync7(dir);
     } catch {
       return;
     }
     for (const name of entries) {
-      const full = join8(dir, name);
+      const full = join15(dir, name);
       let st;
       try {
-        st = statSync5(full);
+        st = statSync8(full);
       } catch {
         continue;
       }
       if (!st.isDirectory()) continue;
-      if (SKIP_DIRS4.has(name)) continue;
+      if (SKIP_DIRS5.has(name)) continue;
       if (name === "hooks") {
         const tokens = /* @__PURE__ */ new Set();
         let files;
         try {
-          files = readdirSync4(full);
+          files = readdirSync7(full);
         } catch {
           files = [];
         }
@@ -2276,11 +4865,11 @@ var dExt4 = {
     const implSurfacePresent = hooksDirs.length > 0 || sites.length > 0;
     const manifests = findExtensionManifests4(tree.root);
     let declaredAnyLifecycle = false;
-    for (const manifestPath of manifests) {
-      const shortPath = manifestPath.split("/").slice(-2).join("/");
+    for (const manifestPath2 of manifests) {
+      const shortPath = manifestPath2.split("/").slice(-2).join("/");
       let parsed;
       try {
-        parsed = JSON.parse(readFileSync6(manifestPath, "utf8"));
+        parsed = JSON.parse(readFileSync13(manifestPath2, "utf8"));
       } catch {
         throw new Error(
           `DExt4 could not parse ${shortPath} as JSON \u2014 a present manifest whose lifecycle cannot be read cannot pass (Extension Rule 4). Fail-closed, not a silent present.`
@@ -2338,8 +4927,8 @@ var dExt4 = {
 };
 
 // src/detectors/dExt5.ts
-import { existsSync as existsSync5, readFileSync as readFileSync7, readdirSync as readdirSync5, statSync as statSync6 } from "fs";
-import { dirname as dirname5, join as join9 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync14, readdirSync as readdirSync8, statSync as statSync9 } from "fs";
+import { dirname as dirname7, join as join16 } from "path";
 function nonEmptyString(v) {
   return typeof v === "string" && v.trim().length > 0;
 }
@@ -2353,32 +4942,32 @@ function dExt5PositiveControls() {
     }
   };
 }
-var SKIP_DIRS5 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
+var SKIP_DIRS6 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
 function findExtensionManifests5(root) {
   const out = [];
   let base;
   try {
-    base = statSync6(root).isDirectory() ? root : join9(root, "..");
+    base = statSync9(root).isDirectory() ? root : join16(root, "..");
   } catch {
     return out;
   }
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = readdirSync5(dir);
+      entries = readdirSync8(dir);
     } catch {
       return;
     }
     for (const name of entries) {
-      const full = join9(dir, name);
+      const full = join16(dir, name);
       let st;
       try {
-        st = statSync6(full);
+        st = statSync9(full);
       } catch {
         continue;
       }
       if (st.isDirectory()) {
-        if (SKIP_DIRS5.has(name)) continue;
+        if (SKIP_DIRS6.has(name)) continue;
         walk2(full);
       } else if (name === "extension.json") {
         out.push(full);
@@ -2409,9 +4998,9 @@ var dExt5 = {
         verdict: "no extension.json manifest found -> declare a bilingual extension with description_fr + README.fr.md (Extension Rule 5)"
       };
     }
-    for (const manifestPath of manifests) {
-      const shortPath = manifestPath.split("/").slice(-2).join("/");
-      const root = dirname5(manifestPath);
+    for (const manifestPath2 of manifests) {
+      const shortPath = manifestPath2.split("/").slice(-2).join("/");
+      const root = dirname7(manifestPath2);
       const cannotRead = (reason) => ({
         id: this.id,
         anchor: shortPath,
@@ -2421,7 +5010,7 @@ var dExt5 = {
       });
       let parsed;
       try {
-        parsed = JSON.parse(readFileSync7(manifestPath, "utf8"));
+        parsed = JSON.parse(readFileSync14(manifestPath2, "utf8"));
       } catch {
         return cannotRead(
           `${shortPath} does not parse as JSON \u2014 the FR surface of a present manifest cannot be read (Extension Rule 5)`
@@ -2436,7 +5025,7 @@ var dExt5 = {
       if (!nonEmptyString(parsed.description_fr)) {
         missing.push("description_fr (extension.json)");
       }
-      if (!existsSync5(join9(root, "README.fr.md"))) {
+      if (!existsSync12(join16(root, "README.fr.md"))) {
         missing.push("README.fr.md");
       }
       if (isToolExtension(parsed.type) && "tools" in parsed) {
@@ -2479,8 +5068,8 @@ var dExt5 = {
 };
 
 // src/detectors/dExt7.ts
-import { existsSync as existsSync6, readFileSync as readFileSync8, readdirSync as readdirSync6, statSync as statSync7 } from "fs";
-import { dirname as dirname6, join as join10 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync15, readdirSync as readdirSync9, statSync as statSync10 } from "fs";
+import { dirname as dirname8, join as join17 } from "path";
 var ABSENCE_FLAG_FIELDS = [
   "extensionAbsent",
   "extension_absent",
@@ -2523,32 +5112,32 @@ function dExt7PositiveControls() {
     negative: isAbsenceCase(ABSENCE_NEGATIVE)
   };
 }
-var SKIP_DIRS6 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
+var SKIP_DIRS7 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
 function findExtensionManifests6(root) {
   const out = [];
   let base;
   try {
-    base = statSync7(root).isDirectory() ? root : join10(root, "..");
+    base = statSync10(root).isDirectory() ? root : join17(root, "..");
   } catch {
     return out;
   }
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = readdirSync6(dir);
+      entries = readdirSync9(dir);
     } catch {
       return;
     }
     for (const name of entries) {
-      const full = join10(dir, name);
+      const full = join17(dir, name);
       let st;
       try {
-        st = statSync7(full);
+        st = statSync10(full);
       } catch {
         continue;
       }
       if (st.isDirectory()) {
-        if (SKIP_DIRS6.has(name)) continue;
+        if (SKIP_DIRS7.has(name)) continue;
         walk2(full);
       } else if (name === "extension.json") {
         out.push(full);
@@ -2576,12 +5165,12 @@ var dExt7 = {
         verdict: "no extension.json manifest found -> declare an extension with an eval suite (>=3 cases incl. 1 'extension absente') (Extension Rule 7)"
       };
     }
-    for (const manifestPath of manifests) {
-      const extDir = dirname6(manifestPath);
+    for (const manifestPath2 of manifests) {
+      const extDir = dirname8(manifestPath2);
       const extLabel = extDir.split("/").pop() ?? extDir;
-      const evalsPath = join10(extDir, "evals", "evals.json");
+      const evalsPath = join17(extDir, "evals", "evals.json");
       const shortPath = `${extLabel}/evals/evals.json`;
-      if (!existsSync6(evalsPath)) {
+      if (!existsSync13(evalsPath)) {
         return {
           id: this.id,
           anchor: `${extLabel}/extension.json`,
@@ -2591,7 +5180,7 @@ var dExt7 = {
       }
       let cases;
       try {
-        const raw = readFileSync8(evalsPath, "utf8");
+        const raw = readFileSync15(evalsPath, "utf8");
         const parsed = JSON.parse(raw);
         if (!Array.isArray(parsed.cases)) {
           throw new Error("`cases` is not an array");
@@ -2634,8 +5223,8 @@ var dExt7 = {
 };
 
 // src/detectors/dExt8.ts
-import { existsSync as existsSync7, readFileSync as readFileSync9, readdirSync as readdirSync7, statSync as statSync8 } from "fs";
-import { dirname as dirname7, join as join11 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync16, readdirSync as readdirSync10, statSync as statSync11 } from "fs";
+import { dirname as dirname9, join as join18 } from "path";
 var SEMVER_RE2 = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
 var POSITIVE_CONTROL5 = "1.2.3-beta.1+build.7";
 function dExt8PositiveControl() {
@@ -2645,32 +5234,32 @@ function dExt8PositiveControl() {
     matched: SEMVER_RE2.test(POSITIVE_CONTROL5)
   };
 }
-var SKIP_DIRS7 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
+var SKIP_DIRS8 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
 function findExtensionManifests7(root) {
   const out = [];
   let base;
   try {
-    base = statSync8(root).isDirectory() ? root : join11(root, "..");
+    base = statSync11(root).isDirectory() ? root : join18(root, "..");
   } catch {
     return out;
   }
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = readdirSync7(dir);
+      entries = readdirSync10(dir);
     } catch {
       return;
     }
     for (const name of entries) {
-      const full = join11(dir, name);
+      const full = join18(dir, name);
       let st;
       try {
-        st = statSync8(full);
+        st = statSync11(full);
       } catch {
         continue;
       }
       if (st.isDirectory()) {
-        if (SKIP_DIRS7.has(name)) continue;
+        if (SKIP_DIRS8.has(name)) continue;
         walk2(full);
       } else if (name === "extension.json") {
         out.push(full);
@@ -2698,19 +5287,19 @@ var dExt8 = {
         verdict: "no extension.json manifest found -> declare an extension with a valid SemVer version + CHANGELOG.md (Extension Rule 8)"
       };
     }
-    for (const manifestPath of manifests) {
-      const extDir = dirname7(manifestPath);
+    for (const manifestPath2 of manifests) {
+      const extDir = dirname9(manifestPath2);
       const extLabel = extDir.split("/").pop() ?? extDir;
-      const pkgPath = join11(extDir, "package.json");
+      const pkgPath = join18(extDir, "package.json");
       const shortPkgPath = `${extLabel}/package.json`;
-      if (!existsSync7(pkgPath)) {
+      if (!existsSync14(pkgPath)) {
         throw new Error(
           `DExt8 could not locate ${shortPkgPath} for extension "${extLabel}" \u2014 cannot verify SemVer/CHANGELOG (Extension Rule 8). Fail-closed, not a silent present.`
         );
       }
       let pkgJson;
       try {
-        pkgJson = JSON.parse(readFileSync9(pkgPath, "utf8"));
+        pkgJson = JSON.parse(readFileSync16(pkgPath, "utf8"));
       } catch {
         throw new Error(
           `DExt8 could not parse ${shortPkgPath} as JSON for extension "${extLabel}" \u2014 cannot verify SemVer/CHANGELOG (Extension Rule 8). Fail-closed, not a silent present.`
@@ -2731,8 +5320,8 @@ var dExt8 = {
         };
       }
       const validSemver = SEMVER_RE2.test(version);
-      const changelogPath = join11(extDir, "CHANGELOG.md");
-      const hasChangelog = existsSync7(changelogPath);
+      const changelogPath = join18(extDir, "CHANGELOG.md");
+      const hasChangelog = existsSync14(changelogPath);
       if (!validSemver) {
         return {
           id: this.id,
@@ -2761,38 +5350,38 @@ var dExt8 = {
 };
 
 // src/detectors/dExt9.ts
-import { readFileSync as readFileSync10, readdirSync as readdirSync8, statSync as statSync9 } from "fs";
-import { join as join12 } from "path";
-var SKIP_DIRS8 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
+import { readFileSync as readFileSync17, readdirSync as readdirSync11, statSync as statSync12 } from "fs";
+import { join as join19 } from "path";
+var SKIP_DIRS9 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", "coverage"]);
 function collectHooksDirSources(root) {
   const out = [];
   let base;
   try {
-    base = statSync9(root).isDirectory() ? root : join12(root, "..");
+    base = statSync12(root).isDirectory() ? root : join19(root, "..");
   } catch {
     return out;
   }
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = readdirSync8(dir);
+      entries = readdirSync11(dir);
     } catch {
       return;
     }
     for (const name of entries) {
-      const full = join12(dir, name);
+      const full = join19(dir, name);
       let st;
       try {
-        st = statSync9(full);
+        st = statSync12(full);
       } catch {
         continue;
       }
       if (!st.isDirectory()) continue;
-      if (SKIP_DIRS8.has(name)) continue;
+      if (SKIP_DIRS9.has(name)) continue;
       if (name === "hooks") {
         let files;
         try {
-          files = readdirSync8(full);
+          files = readdirSync11(full);
         } catch {
           files = [];
         }
@@ -2800,10 +5389,10 @@ function collectHooksDirSources(root) {
           if (!f.endsWith(".ts") || f.endsWith(".d.ts")) continue;
           const stem = f.replace(/\.ts$/, "");
           if (stem === "index") continue;
-          const filePath = join12(full, f);
+          const filePath = join19(full, f);
           let body;
           try {
-            body = readFileSync10(filePath, "utf8");
+            body = readFileSync17(filePath, "utf8");
           } catch {
             throw new Error(
               `DExt9 could not read hook implementation ${filePath.split("/").slice(-2).join("/")} \u2014 timeout guard undeterminable for hook "${stem}" (Extension Rule 9). Fail-closed, not a silent absent.`
@@ -2910,11 +5499,11 @@ var dExt9 = {
     }
     const manifests = findExtensionManifests4(tree.root);
     let declaredAnyLifecycle = false;
-    for (const manifestPath of manifests) {
-      const shortPath = manifestPath.split("/").slice(-2).join("/");
+    for (const manifestPath2 of manifests) {
+      const shortPath = manifestPath2.split("/").slice(-2).join("/");
       let parsed;
       try {
-        parsed = JSON.parse(readFileSync10(manifestPath, "utf8"));
+        parsed = JSON.parse(readFileSync17(manifestPath2, "utf8"));
       } catch {
         throw new Error(
           `DExt9 could not parse ${shortPath} as JSON \u2014 timeout guards undeterminable (Extension Rule 9). Fail-closed, not a silent absent.`
@@ -2992,6 +5581,8 @@ function unscopePackageName(name) {
 }
 var dServer2 = {
   id: "DServer2 naming",
+  rule: "C-2",
+  pin: "a74a042b53c71a095ab88b3073bd47728eeda814",
   run(tree) {
     const controls = dServer2PositiveControls();
     if (!controls.toolSnake.positive || controls.toolSnake.negative) {
@@ -3123,11 +5714,17 @@ var dServer2 = {
 // src/detectors/dServer6.ts
 var LOG_OPENER_RE = /\b(?:console|logger|log)\.(?:log|info|warn|error|debug|trace)\s*\(/;
 var SECRET_RE = /\b(?:api[_-]?key|token|secret|passwd|password|authorization|auth[_-]?token|bearer|access[_-]?key|client[_-]?secret|private[_-]?key)\b/i;
+var PII_RE = /\b(?:email|e[_-]?mail|ip[_-]?address|full[_-]?name|phone[_-]?number|ssn|social[_-]?security)\b/i;
+var INTERNAL_RE = /\b(?:hostname|host[_-]?name|absolute[_-]?path|internal[_-]?path|infra[_-]?version|server[_-]?version|__dirname|__filename)\b/;
 var STACK_RE = /\b(?:error|err|e|ex|exception)\.stack\b/;
 var CLIENT_SINK_RE = /\b(?:content|text|message|body)\s*:|(?:\breturn\b|\bthrow\b|JSON\.stringify)/;
 var SPREAD_RE = /\.\.\.[A-Za-z_$]/;
 var SECRET_POSITIVE = "apiKey";
 var SECRET_NEGATIVE = "customerId";
+var PII_POSITIVE = "email";
+var PII_NEGATIVE = "customerId";
+var INTERNAL_POSITIVE = "hostname";
+var INTERNAL_NEGATIVE = "toolName";
 var STACK_POSITIVE = "error.stack";
 var STACK_NEGATIVE = "error.message";
 function dServer6PositiveControls() {
@@ -3137,6 +5734,16 @@ function dServer6PositiveControls() {
       positive: SECRET_RE.test(SECRET_POSITIVE),
       negative: SECRET_RE.test(SECRET_NEGATIVE)
     },
+    pii: {
+      pattern: PII_RE.source,
+      positive: PII_RE.test(PII_POSITIVE),
+      negative: PII_RE.test(PII_NEGATIVE)
+    },
+    internal: {
+      pattern: INTERNAL_RE.source,
+      positive: INTERNAL_RE.test(INTERNAL_POSITIVE),
+      negative: INTERNAL_RE.test(INTERNAL_NEGATIVE)
+    },
     stack: {
       pattern: STACK_RE.source,
       positive: STACK_RE.test(STACK_POSITIVE),
@@ -3186,8 +5793,11 @@ function collectLogCalls(file) {
   }
   return { calls, unbalanced };
 }
+var PIN10 = "a74a042b53c71a095ab88b3073bd47728eeda814";
 var dServer6 = {
   id: "DServer6 secret-hygiene",
+  rule: "C-6",
+  pin: PIN10,
   run(tree) {
     const controls = dServer6PositiveControls();
     if (!controls.secret.positive || controls.secret.negative) {
@@ -3195,6 +5805,16 @@ var dServer6 = {
         `DServer6 secret control FAILED: /${controls.secret.pattern}/ accept(\`${SECRET_POSITIVE}\`)=${controls.secret.positive} reject(\`${SECRET_NEGATIVE}\`)=${!controls.secret.negative} \u2014 matcher broken, verdict untrustworthy`
       );
     }
+    if (!controls.pii.positive || controls.pii.negative) {
+      throw new Error(
+        `DServer6 PII control FAILED: /${controls.pii.pattern}/ accept(\`${PII_POSITIVE}\`)=${controls.pii.positive} reject(\`${PII_NEGATIVE}\`)=${!controls.pii.negative} \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    if (!controls.internal.positive || controls.internal.negative) {
+      throw new Error(
+        `DServer6 internal-detail control FAILED: /${controls.internal.pattern}/ accept(\`${INTERNAL_POSITIVE}\`)=${controls.internal.positive} reject(\`${INTERNAL_NEGATIVE}\`)=${!controls.internal.negative} \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
     if (!controls.stack.positive || controls.stack.negative) {
       throw new Error(
         `DServer6 stack control FAILED: /${controls.stack.pattern}/ accept(\`${STACK_POSITIVE}\`)=${controls.stack.positive} reject(\`${STACK_NEGATIVE}\`)=${!controls.stack.negative} \u2014 matcher broken, verdict untrustworthy`
@@ -3204,21 +5824,38 @@ var dServer6 = {
       const { calls, unbalanced } = collectLogCalls(file);
       if (unbalanced.length > 0) {
         throw new Error(
-          `DServer6 could not read the argument list of ${unbalanced.length} log call(s): ${unbalanced.join(", ")} \u2014 parentheses never balance, secret content unverifiable (Server Rule 6). Fail-closed, not a silent present.`
+          `DServer6 could not read the argument list of ${unbalanced.length} log call(s): ${unbalanced.join(", ")} \u2014 parentheses never balance, secret/PII content unverifiable (C-6). Fail-closed, not a silent present.`
         );
       }
       for (const call of calls) {
         if (SPREAD_RE.test(call.argText)) {
           throw new Error(
-            `DServer6 cannot inspect the spread argument of the log call at ${call.anchor} \u2014 a spread hides arbitrary content, secret presence unverifiable (Server Rule 6). Fail-closed, not a silent present.`
+            `DServer6 cannot inspect the spread argument of the log call at ${call.anchor} \u2014 a spread hides arbitrary content, secret/PII presence unverifiable (C-6). Fail-closed, not a silent present.`
           );
         }
-        if (SECRET_RE.test(referencedIdentifiers(call.argText))) {
+        const refs = referencedIdentifiers(call.argText);
+        if (SECRET_RE.test(refs)) {
+          return {
+            id: this.id,
+            anchor: call.anchor,
+            state: "non-conforming",
+            verdict: "Form A \u2014 log call references a secret-like identifier (positive-control OK) -> never log secrets; redact before logging (C-6)"
+          };
+        }
+        if (PII_RE.test(refs)) {
+          return {
+            id: this.id,
+            anchor: call.anchor,
+            state: "non-conforming",
+            verdict: "Form C \u2014 log call references a PII-shaped identifier (positive-control OK) -> never log PII; redact before logging (C-6)"
+          };
+        }
+        if (INTERNAL_RE.test(refs)) {
           return {
             id: this.id,
             anchor: call.anchor,
             state: "non-conforming",
-            verdict: "Form A \u2014 log call references a secret-like identifier (positive-control OK) -> never log secrets; redact before logging (Server Rule 6)"
+            verdict: "Form D \u2014 log call references an internal-infrastructure identifier (positive-control OK) -> never log internal system detail; redact before logging (C-6)"
           };
         }
       }
@@ -3231,7 +5868,7 @@ var dServer6 = {
             id: this.id,
             anchor: `${file.rel}:${line.n}`,
             state: "non-conforming",
-            verdict: "Form B \u2014 raw error.stack serialized into a client-facing response (positive-control OK) -> return an McpError message, never the raw stack (Server Rule 6)"
+            verdict: "Form B \u2014 raw error.stack serialized into a client-facing response (positive-control OK) -> return an McpError message, never the raw stack (C-6)"
           };
         }
       }
@@ -3240,7 +5877,7 @@ var dServer6 = {
       id: this.id,
       anchor: tree.files.length > 0 ? `${tree.files[0].rel}:1` : tree.root,
       state: "present",
-      verdict: "no secret referenced in any log call; no raw error.stack exposed to the client (both positive-controls OK)"
+      verdict: "no secret/PII/internal-detail referenced in any log call; no raw error.stack exposed to the client (all positive-controls OK). Logging-sink configuration and explicit-activation-only diagnostic mode are the gate/runtime half, out of static scope (declared)."
     };
   }
 };
@@ -3568,6 +6205,24 @@ var detectors = [
   d12,
   d15,
   d16,
+  c7ArtifactVerifiable,
+  c8AuthorityDeclared,
+  c9VerbDeclared,
+  c10MechanismDeclared,
+  c11Pagination,
+  c12NoDuplicates,
+  c13ContextCeiling,
+  c14CatalogRegistration,
+  c15AnnotationsUntrusted,
+  c16UntrustedOutput,
+  c17SupplyChain,
+  c18StructureManifest,
+  c19ServedDescriptions,
+  c20LocalesDerived,
+  c21ProgressiveDisclosure,
+  c22TestRatioGate,
+  c25BuildIdentity,
+  c26SubpackageLockfile,
   dServer2,
   dServer6,
   dDebugOptIn,
@@ -3585,19 +6240,19 @@ var detectors = [
 ];
 
 // src/runtime/launch.ts
-import { spawnSync } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync11, statSync as statSync10 } from "fs";
-import { dirname as dirname8, isAbsolute, join as join13, resolve } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync15, readFileSync as readFileSync18, statSync as statSync13 } from "fs";
+import { dirname as dirname10, isAbsolute, join as join20, resolve } from "path";
 function findPackageDir(target) {
   let dir;
   try {
-    dir = statSync10(target).isDirectory() ? target : dirname8(target);
+    dir = statSync13(target).isDirectory() ? target : dirname10(target);
   } catch {
     return null;
   }
   for (let depth = 0; depth < 8; depth++) {
-    if (existsSync8(join13(dir, "package.json"))) return dir;
-    const parent = dirname8(dir);
+    if (existsSync15(join20(dir, "package.json"))) return dir;
+    const parent = dirname10(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -3621,10 +6276,10 @@ function deriveLaunchPlan(target) {
   }
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync11(join13(pkgDir, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync18(join20(pkgDir, "package.json"), "utf8"));
   } catch (err) {
     return {
-      error: `could not parse ${join13(pkgDir, "package.json")}: ${err instanceof Error ? err.message : String(err)}`
+      error: `could not parse ${join20(pkgDir, "package.json")}: ${err instanceof Error ? err.message : String(err)}`
     };
   }
   const bin = firstBinEntry(pkg.bin);
@@ -3663,6 +6318,7 @@ try {
   done({ launchError: "spawn failed: " + (e && e.message ? e.message : String(e)) });
 }
 let settled = false;
+let serverInfo;
 const fail = (msg) => { if (settled) return; settled = true; try { child.kill(); } catch {} done({ launchError: msg }); };
 const to = setTimeout(() => fail("timeout: server did not answer initialize+tools/list within the deadline"), 12000);
 child.on("error", (e) => fail("spawn error: " + (e && e.message ? e.message : String(e))));
@@ -3677,13 +6333,19 @@ child.stdout.on("data", (d) => {
     if (!line.trim()) continue;
     let msg; try { msg = JSON.parse(line); } catch { continue; }
     if (msg.id === 1) {
+      // The initialize response's serverInfo is the SAME non-authenticated
+      // discovery surface a client reads version from (S-7); captured here
+      // so C-25's dynamic half can read a served build-identity field
+      // alongside it, additively -- every existing consumer of the
+      // tools-only introspector output is unaffected.
+      serverInfo = msg.result && msg.result.serverInfo;
       send({ jsonrpc: "2.0", method: "notifications/initialized" });
       send({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} });
     } else if (msg.id === 2) {
       if (settled) return; settled = true; clearTimeout(to);
-      const tools = (msg.result && Array.isArray(msg.result.tools) ? msg.result.tools : []).map((t) => ({ name: String(t && t.name) }));
+      const tools = (msg.result && Array.isArray(msg.result.tools) ? msg.result.tools : []).map((t) => ({ name: String(t && t.name), description: t && typeof t.description === "string" ? t.description : undefined }));
       try { child.kill(); } catch {}
-      done({ tools });
+      done({ tools, serverInfo });
     }
   }
 });
@@ -3695,10 +6357,10 @@ function readEvalCounts(target) {
   if (!pkgDir) return counts;
   let dir = pkgDir;
   for (let depth = 0; depth < 8; depth++) {
-    const candidate = join13(dir, "evals", "evals.json");
-    if (existsSync8(candidate)) {
+    const candidate = join20(dir, "evals", "evals.json");
+    if (existsSync15(candidate)) {
       try {
-        const parsed = JSON.parse(readFileSync11(candidate, "utf8"));
+        const parsed = JSON.parse(readFileSync18(candidate, "utf8"));
         for (const c of parsed.cases ?? []) {
           if (c && typeof c.tool === "string") counts.set(c.tool, (counts.get(c.tool) ?? 0) + 1);
         }
@@ -3706,7 +6368,7 @@ function readEvalCounts(target) {
       }
       return counts;
     }
-    const parent = dirname8(dir);
+    const parent = dirname10(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -3714,17 +6376,32 @@ function readEvalCounts(target) {
 }
 function statSyncSafe(p) {
   try {
-    return statSync10(p).isDirectory();
+    return statSync13(p).isDirectory();
   } catch {
     return false;
   }
 }
+function deriveExpectedCommit(cwd) {
+  try {
+    const out = spawnSync2("git", ["rev-parse", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    if (out.status === 0 && typeof out.stdout === "string") {
+      const sha = out.stdout.trim();
+      if (/^[0-9a-f]{40}$/i.test(sha)) return sha;
+    }
+  } catch {
+  }
+  return void 0;
+}
 function launchAndIntrospect(target) {
   const plan = deriveLaunchPlan(target);
   if ("error" in plan) {
     return { root: target, tools: [], launchError: plan.error };
   }
-  const proc = spawnSync(process.execPath, ["--input-type=module", "-e", INTROSPECTOR], {
+  const proc = spawnSync2(process.execPath, ["--input-type=module", "-e", INTROSPECTOR], {
     env: { ...process.env, MCP_DOCTOR_PLAN: JSON.stringify(plan) },
     encoding: "utf8",
     timeout: 2e4,
@@ -3763,82 +6440,16 @@ function launchAndIntrospect(target) {
   const tools = (parsed.tools ?? []).map((t) => {
     const name = t.name;
     const count = evalCounts.get(name);
-    return count === void 0 ? { name } : { name, evalCaseCount: count };
+    const base = t.description ? { name, description: t.description } : { name };
+    return count === void 0 ? base : { ...base, evalCaseCount: count };
   });
-  return { root: target, tools };
-}
-
-// src/scan.ts
-import { existsSync as existsSync9, readFileSync as readFileSync12, readdirSync as readdirSync9, statSync as statSync11 } from "fs";
-import { dirname as dirname9, join as join14, relative as relative2 } from "path";
-var SKIP_DIRS9 = /* @__PURE__ */ new Set([
-  "node_modules",
-  "dist",
-  "build",
-  ".git",
-  "tests",
-  "__tests__",
-  "coverage"
-]);
-function isCommentLine(raw) {
-  const t = raw.trim();
-  if (t === "") return false;
-  return t.startsWith("*") || t.startsWith("//") || t.startsWith("/*") || t.startsWith("*/");
-}
-function walk(dir, out) {
-  let entries;
-  try {
-    entries = readdirSync9(dir);
-  } catch {
-    return;
-  }
-  for (const name of entries) {
-    const full = join14(dir, name);
-    let st;
-    try {
-      st = statSync11(full);
-    } catch {
-      continue;
-    }
-    if (st.isDirectory()) {
-      if (SKIP_DIRS9.has(name)) continue;
-      walk(full, out);
-    } else if (name.endsWith(".ts") || name.endsWith(".tsx")) {
-      if (name.endsWith(".d.ts") || name.endsWith(".test.ts")) continue;
-      out.push(full);
-    }
-  }
-}
-function loadFile(path, root) {
-  const raw = readFileSync12(path, "utf8");
-  const lines = raw.split("\n").map((r, i) => ({ n: i + 1, raw: r, comment: isCommentLine(r) }));
-  return { path, rel: relative2(root, path) || path, lines };
-}
-function findPackageJson(startDir) {
-  let dir = startDir;
-  for (let depth = 0; depth < 8; depth++) {
-    const candidate = join14(dir, "package.json");
-    if (existsSync9(candidate)) {
-      try {
-        return { path: candidate, json: JSON.parse(readFileSync12(candidate, "utf8")) };
-      } catch {
-        return { path: candidate, json: {} };
-      }
-    }
-    const parent = dirname9(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-function loadTree(root) {
-  const st = statSync11(root);
-  const baseDir = st.isDirectory() ? root : dirname9(root);
-  const filePaths = [];
-  if (st.isDirectory()) walk(root, filePaths);
-  else if (root.endsWith(".ts") || root.endsWith(".tsx")) filePaths.push(root);
-  const files = filePaths.map((p) => loadFile(p, baseDir));
-  return { root, files, packageJson: findPackageJson(baseDir) };
+  const expectedCommit = deriveExpectedCommit(plan.cwd);
+  return {
+    root: target,
+    tools,
+    ...parsed.serverInfo ? { serverInfo: parsed.serverInfo } : {},
+    ...expectedCommit ? { expectedCommit } : {}
+  };
 }
 
 // src/types.ts
@@ -3995,12 +6606,45 @@ function computeExitCode(results) {
   if (results.some((r) => r.state === "could-not-judge")) return 2;
   return 0;
 }
+var USAGE = [
+  "usage: mcp-doctor <source-tree-path> [--mode=static|dynamic|both]",
+  "",
+  "  --mode=static   read the tree only (default)",
+  "  --mode=dynamic  launch the server and judge what it serves",
+  "  --mode=both     both, dynamic findings taking precedence",
+  "  --version       print the version and exit",
+  "  --help          print this and exit",
+  "",
+  "exit: 0 clean, 1 a violation, 2 an abstention with no violation"
+].join("\n");
+function readVersion() {
+  try {
+    const here = dirname11(fileURLToPath(import.meta.url));
+    const manifest = JSON.parse(readFileSync19(join21(here, "..", "package.json"), "utf8"));
+    return manifest.version ?? null;
+  } catch {
+    return null;
+  }
+}
 function main() {
   const args = process.argv.slice(2);
+  if (args.includes("--version") || args.includes("-V")) {
+    const version = readVersion();
+    if (!version) {
+      console.error("mcp-doctor: could not read its own version from package.json");
+      process.exit(1);
+    }
+    console.log(version);
+    return;
+  }
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(USAGE);
+    return;
+  }
   const modeArg = args.find((a) => a.startsWith("--mode="));
   const target = args.find((a) => !a.startsWith("--"));
   if (!target) {
-    console.error("usage: tsx src/doctor.ts <source-tree-path> [--mode=static|dynamic|both]");
+    console.error(USAGE);
     process.exit(1);
   }
   const mode = modeArg ? modeArg.slice("--mode=".length) : "static";
@@ -4012,7 +6656,22 @@ function main() {
   console.log(renderTable(target, results));
   process.exitCode = computeExitCode(results);
 }
-if (import.meta.url === `file://${process.argv[1]}`) main();
+function isDirectInvocation() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  let selfReal;
+  try {
+    selfReal = realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+  try {
+    return realpathSync(resolve2(entry)) === selfReal;
+  } catch {
+    return false;
+  }
+}
+if (isDirectInvocation()) main();
 export {
   computeExitCode,
   isLiveDetector,