@vantageos/mcp-doctor 0.4.0 → 0.6.0

package/dist/doctor.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/doctor.ts
-import { readFileSync as readFileSync12, realpathSync } from "fs";
-import { dirname as dirname11, join as join19, resolve as resolve2 } from "path";
+import { readFileSync as readFileSync13, realpathSync } from "fs";
+import { dirname as dirname13, join as join20, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 
 // src/scan.ts
@@ -114,11 +114,12 @@ function findPackageJson(startDir) {
   }
   return null;
 }
-function loadTree(root) {
+function loadTree(root, backendRoot) {
   const st = statSync(root);
   const baseDir = st.isDirectory() ? root : dirname(root);
   const filePaths = [];
   const tree = { root, files: [], packageJson: null, skippedDirs: [] };
+  if (backendRoot !== void 0) tree.backendRoot = backendRoot;
   if (st.isDirectory()) walk(root, filePaths, (d) => recordSkip(tree, d, root));
   else if (root.endsWith(".ts") || root.endsWith(".tsx")) filePaths.push(root);
   tree.files = filePaths.map((p) => loadFile(p, baseDir));
@@ -128,9 +129,14 @@ function loadTree(root) {
 var COM = 1;
 var CODE = 2;
 var maskCache = /* @__PURE__ */ new WeakMap();
+var maskEnd = /* @__PURE__ */ new WeakMap();
 function buildCodeMask(file) {
   const mask = [];
   let mode = "code";
+  const jsxFile = /\.[tj]sx$/.test(file.path);
+  let jsxDepth = 0;
+  let jstrQuote = "";
+  const jsxExprStack = [];
   const tplStack = [];
   let braceDepth = 0;
   let prevSig = "";
@@ -192,6 +198,75 @@ function buildCodeMask(file) {
         } else i++;
         continue;
       }
+      if (mode === "jstr") {
+        if (c === jstrQuote) mode = "jtag";
+        i++;
+        continue;
+      }
+      if (mode === "jtag") {
+        if (c === "/" && n === ">") {
+          row[i] = CODE;
+          row[i + 1] = CODE;
+          i += 2;
+          mode = jsxDepth > 0 ? "jtext" : "code";
+          if (mode === "code") prevSig = "x";
+        } else if (c === ">") {
+          row[i] = CODE;
+          i++;
+          jsxDepth++;
+          mode = "jtext";
+        } else if (c === '"' || c === "'") {
+          jstrQuote = c;
+          mode = "jstr";
+          i++;
+        } else if (c === "{") {
+          row[i] = CODE;
+          jsxExprStack.push({ depth: braceDepth, back: "jtag", savedJsxDepth: jsxDepth });
+          jsxDepth = 0;
+          braceDepth++;
+          i++;
+          mode = "code";
+          prevSig = "{";
+        } else {
+          if (c !== " " && c !== "	") row[i] = CODE;
+          i++;
+        }
+        continue;
+      }
+      if (mode === "jtext") {
+        if (c === "{") {
+          row[i] = CODE;
+          jsxExprStack.push({ depth: braceDepth, back: "jtext", savedJsxDepth: jsxDepth });
+          jsxDepth = 0;
+          braceDepth++;
+          i++;
+          mode = "code";
+          prevSig = "{";
+        } else if (c === "<" && n === "/") {
+          row[i] = CODE;
+          row[i + 1] = CODE;
+          i += 2;
+          mode = "jclose";
+        } else if (c === "<" && n !== void 0 && /[A-Za-z_$>]/.test(n)) {
+          row[i] = CODE;
+          i++;
+          mode = "jtag";
+        } else i++;
+        continue;
+      }
+      if (mode === "jclose") {
+        if (c === ">") {
+          row[i] = CODE;
+          i++;
+          jsxDepth = Math.max(0, jsxDepth - 1);
+          mode = jsxDepth > 0 ? "jtext" : "code";
+          if (mode === "code") prevSig = "x";
+        } else {
+          if (c !== " " && c !== "	") row[i] = CODE;
+          i++;
+        }
+        continue;
+      }
       if (mode === "sq" || mode === "dq") {
         if (c === "\\") i += 2;
         else if (mode === "sq" && c === "'" || mode === "dq" && c === '"') {
@@ -259,6 +334,11 @@ function buildCodeMask(file) {
         i = j;
         continue;
       }
+      if (jsxFile && c === "<" && n !== void 0 && /[A-Za-z_$>]/.test(n) && (prevSig === "" || "(,=:?&|{};![".includes(prevSig) || wordBefore === "return" || prevSig === ">" && /=>\s*$/.test(s.slice(0, i)) || prevSig === "}") && !/^<[A-Za-z_$][\w$]*\s+extends\b/.test(s.slice(i)) && !/^<[A-Za-z_$][\w$]*\s*,/.test(s.slice(i))) {
+        i++;
+        mode = "jtag";
+        continue;
+      }
       if (c === '"' || c === "'" || c === "`") {
         mode = c === '"' ? "dq" : c === "'" ? "sq" : "tpl";
         i++;
@@ -278,6 +358,14 @@ function buildCodeMask(file) {
           i++;
           continue;
         }
+        const jx = jsxExprStack[jsxExprStack.length - 1];
+        if (jx && jx.depth === braceDepth) {
+          jsxExprStack.pop();
+          jsxDepth = jx.savedJsxDepth;
+          mode = jx.back;
+          i++;
+          continue;
+        }
       }
       if (c !== " " && c !== "	") prevSig = c;
       i++;
@@ -285,6 +373,7 @@ function buildCodeMask(file) {
     if (mode === "sq" || mode === "dq" || mode === "re" || mode === "recls") mode = "code";
     mask.push(row);
   }
+  if (mode !== "code") maskEnd.set(file, mode);
   return mask;
 }
 function maskOf(file) {
@@ -295,6 +384,12 @@ function maskOf(file) {
   }
   return mask;
 }
+function unterminatedContext(file) {
+  maskOf(file);
+  const m = maskEnd.get(file);
+  if (!m) return null;
+  return m.startsWith("j") ? "an unterminated JSX element" : m === "block" ? "an unterminated block comment" : m === "tpl" ? "an unterminated template literal" : `an unterminated ${m} context`;
+}
 function isCodeAt(file, n, col) {
   const mask = maskOf(file);
   return mask[n - 1]?.[col] === CODE;
@@ -751,6 +846,34 @@ var MATCHERS = [
     re: /\bcreateHash\s*\(|\bcreateHmac\s*\(|\bsubtle\s*\.\s*(digest|sign|verify)\s*\(/,
     accept: (m, ctx) => !digestsStaticInput(m, ctx),
     sample: 'const h = await crypto.subtle.digest("SHA-256", data);'
+  },
+  // ── Minting / signing: shown, not counted (category "mints-token") ──────────
+  {
+    id: "mint-sign-jwt",
+    category: "mints-token",
+    re: /\bnew\s+SignJWT\s*\(/,
+    sample: "return new SignJWT({ sub }).setProtectedHeader({ alg }).sign(key);"
+  },
+  {
+    id: "mint-jwt-sign",
+    category: "mints-token",
+    re: /\b(jwt|jsonwebtoken)\.sign\s*\(/,
+    sample: "const token = jwt.sign(claims, privateKey);"
+  },
+  {
+    // A key that can only be a private one by construction.
+    id: "mint-private-key-import",
+    category: "mints-token",
+    re: /\b(importPKCS8|createPrivateKey)\s*\(/,
+    sample: "const key = await importPKCS8(pem, 'RS256');"
+  },
+  {
+    // importJWK is neutral (it also loads PUBLIC verification keys); it is a minting
+    // site only when its argument is named as a private/secret key.
+    id: "mint-private-key-import",
+    category: "mints-token",
+    re: /\bimportJWK\s*\(\s*[\w$.]*(?:priv|secret)[\w$.]*/i,
+    sample: 'const key = await importJWK(privateJwk, "RS256");'
   }
 ];
 function biteSample(mt, text) {
@@ -781,6 +904,12 @@ function localIdentityPositiveControls() {
   out["negative:switch-on-unrelated-field"] = !bites('switch (row.kind) { case "a": return 1; }');
   out["negative:literal-array-unrelated"] = !bites("return [kind].includes(row.status);");
   out["negative:localecompare-unrelated"] = !bites("return a.name.localeCompare(b.name) === 0;");
+  out["negative:public-jwk-import-is-not-minting"] = !bites(
+    'const key = await importJWK(publicJwk, "RS256");'
+  );
+  out["negative:verify-is-not-minting"] = !MATCHERS.filter(
+    (m) => m.category === "mints-token"
+  ).some((mt) => biteSample(mt, "const { payload } = await jwtVerify(token, keys);"));
   out["negative:object-is-nullish"] = !bites("return Object.is(row.orgId, undefined);");
   return out;
 }
@@ -860,19 +989,55 @@ function unreadableReason(file) {
   if (file.lines.some((l) => l.raw.includes("\0") || l.raw.includes("\uFFFD"))) {
     return "file is not valid UTF-8 text";
   }
+  const open = unterminatedContext(file);
+  if (open) return `the file ends inside ${open} \u2014 the tail cannot be read as code`;
   const pairs = [
     ["{", "}"],
     ["(", ")"],
     ["[", "]"]
   ];
   const off = [];
-  for (const [open, close] of pairs) {
+  for (const [open2, close] of pairs) {
     let net = 0;
-    for (const l of file.lines) net += countInCode(file, l, open) - countInCode(file, l, close);
-    if (net !== 0) off.push(`${open}${close} ${net > 0 ? "+" : ""}${net}`);
+    for (const l of file.lines) net += countInCode(file, l, open2) - countInCode(file, l, close);
+    if (net !== 0) off.push(`${open2}${close} ${net > 0 ? "+" : ""}${net}`);
   }
   return off.length > 0 ? `brackets never balance (${off.join(", ")}) \u2014 the file cannot be read as code` : null;
 }
+function signingChainLines(file) {
+  const inChain = /* @__PURE__ */ new Set();
+  const lines = file.lines;
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i];
+    if (l.comment) continue;
+    const start = l.raw.match(/\bnew\s+SignJWT\s*\(|\b(?:jwt|jsonwebtoken)\.sign\s*\(/);
+    if (!start || start.index === void 0 || !isCodeAt(file, l.n, start.index)) continue;
+    let end = -1;
+    if (/SignJWT/.test(start[0])) {
+      for (let j = i; j < Math.min(lines.length, i + 60); j++) {
+        if (!lines[j].comment && /\.sign\s*\(/.test(lines[j].raw)) {
+          end = j;
+          break;
+        }
+      }
+    }
+    if (end < 0) {
+      let depth = 0;
+      let opened = false;
+      for (let j = i; j < Math.min(lines.length, i + 60); j++) {
+        const raw = j === i ? lines[j].raw.slice(start.index) : lines[j].raw;
+        depth += (raw.match(/\(/g) ?? []).length - (raw.match(/\)/g) ?? []).length;
+        if (/\(/.test(raw)) opened = true;
+        if (opened && depth <= 0) {
+          end = j;
+          break;
+        }
+      }
+    }
+    for (let j = i; j <= (end < 0 ? i : end); j++) inChain.add(lines[j].n);
+  }
+  return inChain;
+}
 function findLocalIdentitySites(tree) {
   const pkg = tree.packageJson;
   const selfExempt = !pkg?.unreadable && pkg?.json.name === CLOUD_IDENTITY_PACKAGE;
@@ -881,6 +1046,7 @@ function findLocalIdentitySites(tree) {
     violations: [],
     exempt: [],
     delegatedCalls: 0,
+    minting: [],
     unreadable: []
   };
   for (const file of tree.files) {
@@ -889,6 +1055,7 @@ function findLocalIdentitySites(tree) {
     const bindings = cloudIdentityBindings(file);
     const statics = staticConstants(file);
     const catalog = [...MATCHERS, ...aliasMatchers(file)];
+    const signingChain = signingChainLines(file);
     scan.delegatedCalls += countDelegatedCalls(file, bindings);
     for (const line of file.lines) {
       if (line.comment) continue;
@@ -908,6 +1075,16 @@ function findLocalIdentitySites(tree) {
       }
       if (!hit) continue;
       const decl = enclosingDecl(file, line.n);
+      if (hit.category === "mints-token" || signingChain.has(line.n)) {
+        scan.minting.push({
+          file: file.rel,
+          line: line.n,
+          primitive: hit.category === "mints-token" ? hit.id : `signing-payload (${hit.id})`,
+          category: "mints-token",
+          enclosing: decl
+        });
+        continue;
+      }
       const site = {
         file: file.rel,
         line: line.n,
@@ -931,6 +1108,10 @@ function exemptSuffix(exempt) {
   const rows = exempt.map((e) => `${describeSite(e)} \u2014 "${e.justification}"`);
   return `; EXEMPT (${exempt.length}): ${rows.join("; ")}`;
 }
+function mintingSuffix(minting) {
+  if (minting.length === 0) return "";
+  return `; MINTING/SIGNING (${minting.length}, shown, not counted): ${minting.map(describeSite).join("; ")}`;
+}
 function makeLocalIdentity(opts = {}) {
   const ceiling = opts.ceiling ?? 0;
   if (!Number.isInteger(ceiling) || ceiling < 0) {
@@ -966,7 +1147,7 @@ function makeLocalIdentity(opts = {}) {
           id,
           anchor: `${v.file}:${v.line}`,
           state: "non-conforming",
-          verdict: `${s.violations.length} local identity primitive(s), ceiling ${ceiling} (positive-control OK): ${listed}${exemptSuffix(s.exempt)} -> delegate to ${CLOUD_IDENTITY_PACKAGE} (validateMasterBearer, verifyClerkSessionToken, isMasterScope, ...) or justify the site with "// ${EXEMPT_MARKER} <reason>"`
+          verdict: `${s.violations.length} local identity primitive(s), ceiling ${ceiling} (positive-control OK): ${listed}${exemptSuffix(s.exempt)}${mintingSuffix(s.minting)} -> delegate to ${CLOUD_IDENTITY_PACKAGE} (validateMasterBearer, verifyClerkSessionToken, isMasterScope, ...) or justify the site with "// ${EXEMPT_MARKER} <reason>"`
         };
       } else if (s.violations.length > 0) {
         const v = s.violations[0];
@@ -974,14 +1155,14 @@ function makeLocalIdentity(opts = {}) {
           id,
           anchor: `${v.file}:${v.line}`,
           state: "present",
-          verdict: `${s.violations.length} local identity primitive(s) at or under the ceiling ${ceiling} \u2014 a ratchet, not a clean bill: ${listed}${exemptSuffix(s.exempt)}`
+          verdict: `${s.violations.length} local identity primitive(s) at or under the ceiling ${ceiling} \u2014 a ratchet, not a clean bill: ${listed}${exemptSuffix(s.exempt)}${mintingSuffix(s.minting)}`
         };
       } else {
         decided = {
           id,
           anchor: s.exempt[0] ? `${s.exempt[0].file}:${s.exempt[0].line}` : "-",
           state: "present",
-          verdict: `0 local identity primitives; ${delegated} (positive-control OK)${exemptSuffix(s.exempt)}`
+          verdict: `0 local identity primitives; ${delegated} (positive-control OK)${exemptSuffix(s.exempt)}${mintingSuffix(s.minting)}`
         };
       }
       return settle(id, decided, s.unreadable);
@@ -1168,6 +1349,237 @@ function resolveNameBindings(tree) {
   }
   return bindings;
 }
+var READ_STRING_LITERAL_RE = /^(?:"((?:[^"\\\n]|\\.)*)"|'((?:[^'\\\n]|\\.)*)'|`((?:[^`\\$]|\\.|\$(?!\{))*)`)/;
+function readDescriptionValue(text) {
+  let rest = text.replace(/^\s+/, "");
+  let acc = "";
+  let first = true;
+  for (; ; ) {
+    const m = rest.match(READ_STRING_LITERAL_RE);
+    if (!m) {
+      const expr = rest.split("\n")[0].trim().slice(0, 60);
+      return { kind: "non-literal", expr: first ? expr : `\u2026+ ${expr}` };
+    }
+    first = false;
+    acc += m[1] ?? m[2] ?? m[3] ?? "";
+    rest = rest.slice(m[0].length).replace(/^\s+/, "");
+    if (rest.startsWith("+")) {
+      rest = rest.slice(1).replace(/^\s+/, "");
+      continue;
+    }
+    return { kind: "literal", text: acc };
+  }
+}
+function constExpression(tree, name) {
+  const decl = new RegExp(`\\bconst\\s+${name.replace(/\$/g, "\\$")}\\s*(?::[^=\\n]+)?=(?!=)`);
+  let found = null;
+  let count = 0;
+  for (const file of tree.files) {
+    const code = file.lines.map((l) => l.comment ? "" : l.raw);
+    for (let i = 0; i < code.length; i++) {
+      const m = code[i].match(decl);
+      if (!m) continue;
+      count++;
+      let text = code[i].slice((m.index ?? 0) + m[0].length);
+      let depth = 0;
+      let j = i;
+      for (; ; ) {
+        for (const ch of text) {
+          if ("([{".includes(ch)) depth++;
+          else if (")]}".includes(ch)) depth--;
+        }
+        if (depth <= 0 && /;\s*$/.test(text)) break;
+        if (++j >= code.length || j > i + 60) break;
+        text += `
+${code[j]}`;
+      }
+      found = text.replace(/;\s*$/, "").trim();
+    }
+  }
+  return count === 1 ? found : null;
+}
+var wrapperScans = /* @__PURE__ */ new WeakMap();
+var wrapperOpeners = /* @__PURE__ */ new WeakMap();
+var FUNCTION_DECL_RE = /^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*(?:<[^>(]*>)?\s*\(|^\s*(?:export\s+)?const\s+([A-Za-z_$][\w$]*)\s*(?::[^=]+)?=\s*(?:async\s*)?\(/;
+function splitArgs(text, open, max = Number.POSITIVE_INFINITY) {
+  const args = [];
+  let depth = 0;
+  let start = open + 1;
+  for (let i = open; i < text.length; i++) {
+    const c = text[i];
+    if (c === '"' || c === "'" || c === "`") {
+      for (i++; i < text.length && text[i] !== c; i++) if (text[i] === "\\") i++;
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "*") {
+      const e = text.indexOf("*/", i + 2);
+      if (e < 0) return null;
+      i = e + 1;
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === ")" || c === "]" || c === "}") {
+      depth--;
+      if (depth === 0) {
+        args.push(text.slice(start, i).trim());
+        return { args, end: i };
+      }
+    } else if (c === "," && depth === 1) {
+      args.push(text.slice(start, i).trim());
+      start = i + 1;
+      if (args.length >= max) return { args, end: i };
+    }
+  }
+  return null;
+}
+function scanWrappers(tree) {
+  const cached = wrapperScans.get(tree);
+  if (cached) return cached;
+  const scan = {
+    sites: [],
+    unresolved: [],
+    internal: /* @__PURE__ */ new Set(),
+    descriptions: /* @__PURE__ */ new Map()
+  };
+  wrapperScans.set(tree, scan);
+  const wrappers = [];
+  for (const file of tree.files) {
+    const text = file.lines.map((l) => l.comment ? " ".repeat(l.raw.length) : l.raw).join("\n");
+    const lineStart = [];
+    let off = 0;
+    for (const l of file.lines) {
+      lineStart.push(off);
+      off += l.raw.length + 1;
+    }
+    const lineOf = (idx) => {
+      let lo = 0;
+      let hi = lineStart.length - 1;
+      while (lo < hi) {
+        const mid = lo + hi + 1 >> 1;
+        if (lineStart[mid] <= idx) lo = mid;
+        else hi = mid - 1;
+      }
+      return lo + 1;
+    };
+    const aliases = /* @__PURE__ */ new Set(["registerTool", "tool"]);
+    for (const m of text.matchAll(
+      /\bconst\s+([A-Za-z_$][\w$]*)\s*=[^;\n]*\.(?:registerTool|tool)\b/g
+    )) {
+      aliases.add(m[1]);
+    }
+    const callRe = new RegExp(
+      `(?:\\b(?:${[...aliases].join("|")})|\\.(?:registerTool|tool))\\s*\\(\\s*([A-Za-z_$][\\w$]*)\\s*,`,
+      "g"
+    );
+    file.lines.forEach((line, i) => {
+      if (line.comment) return;
+      const d = line.raw.match(FUNCTION_DECL_RE);
+      if (!d) return;
+      const name = d[1] ?? d[2];
+      if (name === "registerTool" || name === "tool") return;
+      const open = lineStart[i] + (d.index ?? 0) + d[0].length - 1;
+      const params = splitArgs(text, open);
+      if (!params) return;
+      const paramNames = params.args.map(
+        (a) => a.replace(/^\.\.\./, "").match(/^([A-Za-z_$][\w$]*)/)?.[1] ?? null
+      );
+      const bodyOpen = text.indexOf("{", params.end);
+      if (bodyOpen < 0) return;
+      let depth = 0;
+      let bodyEnd = -1;
+      for (let k = bodyOpen; k < text.length; k++) {
+        if (text[k] === "{") depth++;
+        else if (text[k] === "}" && --depth === 0) {
+          bodyEnd = k;
+          break;
+        }
+      }
+      if (bodyEnd < 0) return;
+      const body = text.slice(bodyOpen, bodyEnd);
+      const idxs = /* @__PURE__ */ new Set();
+      let descIdx = -1;
+      for (const c of body.matchAll(callRe)) {
+        const k = paramNames.indexOf(c[1]);
+        if (k < 0) continue;
+        idxs.add(k);
+        scan.internal.add(`${file.rel}:${lineOf(bodyOpen + (c.index ?? 0))}`);
+        const after = body.slice((c.index ?? 0) + c[0].length, (c.index ?? 0) + c[0].length + 3e3);
+        const dm = after.match(/(?:^|[\s{,])description\b\s*(?::\s*([A-Za-z_$][\w$]*))?\s*[,}]/);
+        if (dm) {
+          const ref = dm[1] ?? "description";
+          descIdx = paramNames.indexOf(ref);
+        }
+      }
+      if (idxs.size !== 1) return;
+      wrappers.push({
+        name,
+        nameIdx: [...idxs][0],
+        descIdx,
+        file,
+        declLine: line.n,
+        endLine: lineOf(bodyEnd)
+      });
+    });
+  }
+  for (const w of wrappers) {
+    const callRe = new RegExp(`(?<![\\w$.])${w.name.replace(/\$/g, "\\$")}\\s*\\(`, "g");
+    for (const file of tree.files) {
+      const text = file.lines.map((l) => l.comment ? " ".repeat(l.raw.length) : l.raw).join("\n");
+      const lineStart = [];
+      let off = 0;
+      for (const l of file.lines) {
+        lineStart.push(off);
+        off += l.raw.length + 1;
+      }
+      file.lines.forEach((line, i) => {
+        if (line.comment) return;
+        if (file === w.file && line.n >= w.declLine && line.n <= w.endLine) return;
+        if (/^\s*(?:export\s+)?(?:async\s+)?function\b|^\s*import\b|^\s*\}?\s*from\b/.test(line.raw))
+          return;
+        for (const m of line.raw.matchAll(callRe)) {
+          if (!isCodeAtCached(file, line.n, m.index ?? 0)) continue;
+          const open = lineStart[i] + (m.index ?? 0) + m[0].length - 1;
+          const parsed = splitArgs(text, open, Math.max(w.nameIdx, w.descIdx) + 1);
+          const anchor = `${file.rel}:${line.n}`;
+          if (!parsed || parsed.args.length <= w.nameIdx) {
+            scan.unresolved.push(anchor);
+            continue;
+          }
+          let nameArg = parsed.args[w.nameIdx];
+          if (/^[A-Za-z_$][\w$]*$/.test(nameArg))
+            nameArg = constExpression(tree, nameArg) ?? nameArg;
+          const nameVal = readDescriptionValue(nameArg);
+          if (nameVal.kind !== "literal" || nameVal.text === "") {
+            scan.unresolved.push(anchor);
+            continue;
+          }
+          const toolName = nameVal.text;
+          scan.sites.push({ name: toolName, anchor });
+          let set = wrapperOpeners.get(file);
+          if (!set) {
+            set = /* @__PURE__ */ new Set();
+            wrapperOpeners.set(file, set);
+          }
+          set.add(line.n);
+          if (w.descIdx >= 0 && parsed.args.length > w.descIdx) {
+            scan.descriptions.set(anchor, parsed.args[w.descIdx]);
+          }
+        }
+      });
+    }
+  }
+  return scan;
+}
+function isCodeAtCached(file, n, col) {
+  return isCodeAt(file, n, col);
+}
+function wrapperDescriptionArg(tree, anchor) {
+  return scanWrappers(tree).descriptions.get(anchor);
+}
 function findRegisteredTools(tree) {
   const bindings = resolveNameBindings(tree);
   const out = [];
@@ -1226,6 +1638,7 @@ function findRegisteredTools(tree) {
       if (hasSchema) push(m[2], `${file.rel}:${line.n}`);
     }
   }
+  for (const w of scanWrappers(tree).sites) push(w.name, w.anchor);
   return out;
 }
 var DESCRIPTOR_KEY_RE = new RegExp(`^(\\s*)name:\\s*["'\`](${NAME_LITERAL})["'\`]\\s*,?\\s*$`);
@@ -1296,7 +1709,9 @@ function findUnresolvedToolSites(tree) {
     }
     if (awaitingName) out.push(openerAnchor);
   }
-  return out;
+  const wrappers = scanWrappers(tree);
+  const kept = out.filter((a) => !wrappers.internal.has(a));
+  return [...kept, ...wrappers.unresolved];
 }
 function findListReadBuilders(tree) {
   const out = [];
@@ -1349,6 +1764,45 @@ function sdkFirstAnchor(tree) {
   }
   return null;
 }
+var ANNOTATIONS_NONLITERAL_RE = /\bannotations\s*:\s*([^\s{][^\n]*?)\s*,?\s*$/;
+var SIMPLE_IDENT_RE = /^([A-Za-z_$][A-Za-z0-9_$]*)(?:\s+(?:as\s+const|satisfies\s+[\w.<>\[\]]+))?$/;
+function resolveConstObjectLines(tree, home, ident, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(ident)) return null;
+  seen.add(ident);
+  const openRe = new RegExp(
+    `\\bconst\\s+${ident.replace(/\$/g, "\\$")}\\s*(?::[^=]+)?=\\s*(?:Object\\.freeze\\(\\s*)?\\{`
+  );
+  const found = [];
+  for (const file of tree.files) {
+    for (let i = 0; i < file.lines.length; i++) {
+      const l = file.lines[i];
+      if (!l.comment && openRe.test(l.raw)) found.push({ file, index: i });
+    }
+  }
+  const local = found.filter((f) => f.file === home);
+  const pick = local.length === 1 ? local[0] : local.length === 0 && found.length === 1 ? found[0] : null;
+  if (!pick) return null;
+  const out = [];
+  let depth = 0;
+  const started = true;
+  for (let i = pick.index; i < pick.file.lines.length; i++) {
+    const l = pick.file.lines[i];
+    if (l.comment) continue;
+    const text = i === pick.index ? l.raw.slice(l.raw.search(openRe)) : l.raw;
+    out.push(text);
+    depth += (text.match(/\{/g) ?? []).length - (text.match(/\}/g) ?? []).length;
+    const spread = text.match(/\.\.\.\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*[,}]?\s*$/);
+    if (spread) {
+      const inner = resolveConstObjectLines(tree, pick.file, spread[1], seen);
+      if (!inner) return null;
+      out.push(...inner);
+    } else if (/\.\.\./.test(text)) {
+      return null;
+    }
+    if (started && depth <= 0) return out;
+  }
+  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_-]+(?:\([^)]*\))?)["'`]/;
@@ -1436,7 +1890,7 @@ 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)) {
+    if (TOOL_INLINE_LITERAL_RE.test(line.raw) || TOOL_INLINE_IDENT_RE.test(line.raw) || OPENER_RE.test(line.raw) || wrapperOpeners.get(file)?.has(line.n)) {
       return line.n;
     }
   }
@@ -1457,6 +1911,34 @@ function ownCallEnd(file, siteLine) {
   }
   return file.lines.length;
 }
+var HINT_KEYS = ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"];
+function effectiveHints(tree, file, objectText, seen = /* @__PURE__ */ new Set()) {
+  const state = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+  };
+  const open = objectText.indexOf("{");
+  const parsed = open < 0 ? null : splitArgs(objectText, open);
+  if (!parsed) return { unresolved: objectText.trim().slice(0, 60) };
+  for (const member of parsed.args) {
+    if (member.startsWith("...")) {
+      const id = member.slice(3).trim().match(SIMPLE_IDENT_RE);
+      const lines = id && !seen.has(id[1]) ? resolveConstObjectLines(tree, file, id[1]) : null;
+      if (!lines) return { unresolved: member };
+      const inner = effectiveHints(tree, file, lines.join("\n"), /* @__PURE__ */ new Set([...seen, id?.[1] ?? ""]));
+      if ("unresolved" in inner) return inner;
+      for (const k of HINT_KEYS) if (inner[k]) state[k] = true;
+      continue;
+    }
+    const kv = member.match(/^["'`]?([A-Za-z_$][\w$]*)["'`]?\s*:\s*([\s\S]*)$/);
+    if (kv && HINT_KEYS.includes(kv[1])) {
+      state[kv[1]] = /^(?:true|false)$/.test(kv[2].trim());
+    }
+  }
+  return state;
+}
 function findToolAnnotations(tree) {
   const allSites = findRegisteredTools(tree);
   const out = [];
@@ -1481,10 +1963,31 @@ function findToolAnnotations(tree) {
       let paginationCursorDeclared = false;
       let paginationDefault;
       let paginationMax;
+      let annotationsUnresolved;
+      const windowRaws = [];
       for (const line of file.lines) {
         if (line.n <= windowStart || line.n > windowEnd) continue;
         if (line.comment) continue;
-        const raw = line.raw;
+        windowRaws.push(line.raw);
+      }
+      const ownStart = callOpenerLine(file, site.line);
+      const ownRaws = [];
+      let ownExpr;
+      for (const line of file.lines) {
+        if (line.n < ownStart || line.n > windowEnd || line.comment) continue;
+        ownRaws.push(line.raw);
+        const nl = line.raw.match(ANNOTATIONS_NONLITERAL_RE);
+        if (nl && ownExpr === void 0) ownExpr = nl[1];
+      }
+      if (ownExpr !== void 0) {
+        const id = ownExpr.match(SIMPLE_IDENT_RE);
+        const body = id ? resolveConstObjectLines(tree, file, id[1]) : null;
+        windowRaws.length = 0;
+        windowRaws.push(...ownRaws);
+        if (body) windowRaws.push(...body);
+        else annotationsUnresolved = ownExpr;
+      }
+      for (const raw of windowRaws) {
         if (!verb) {
           const m = raw.match(VERB_FIELD_RE);
           if (m) verb = m[1];
@@ -1529,6 +2032,22 @@ function findToolAnnotations(tree) {
           if (m) paginationMax = Number.parseInt(m[1], 10);
         }
       }
+      const ownText = ownRaws.join("\n");
+      const inlineAnn = ownText.match(/\bannotations\s*:\s*\{/);
+      if (inlineAnn && inlineAnn.index !== void 0) {
+        const objText = ownText.slice(inlineAnn.index + inlineAnn[0].length - 1);
+        const parsedObj = splitArgs(objText, 0);
+        if (parsedObj?.args.some((m) => m.startsWith("..."))) {
+          const eff = effectiveHints(tree, file, objText);
+          if ("unresolved" in eff) annotationsUnresolved = eff.unresolved;
+          else {
+            readOnlyHintDeclared = eff.readOnlyHint;
+            destructiveHintDeclared = eff.destructiveHint;
+            idempotentHintDeclared = eff.idempotentHint;
+            openWorldHintDeclared = eff.openWorldHint;
+          }
+        }
+      }
       out.push({
         name: site.name,
         anchor: site.anchor,
@@ -1545,7 +2064,8 @@ function findToolAnnotations(tree) {
         tokensEstimeContexte,
         paginationCursorDeclared,
         paginationDefault,
-        paginationMax
+        paginationMax,
+        annotationsUnresolved
       });
     }
   }
@@ -1569,6 +2089,18 @@ function countKeywordInCode(tree, re) {
   }
   return { count, firstFile, firstLine };
 }
+function opaqueAnnotationsAbstain(id, rule, tools) {
+  const opaque = tools.find((t) => t.annotationsUnresolved);
+  if (!opaque) return null;
+  const reason = `tool "${opaque.name}" at ${opaque.anchor} passes \`annotations: ${opaque.annotationsUnresolved}\`, which is not an inline object and does not resolve to a \`const\` object literal in this tree \u2014 the fields it declares are unreadable statically (${rule})`;
+  return {
+    id,
+    anchor: opaque.anchor,
+    state: "could-not-judge",
+    reason,
+    verdict: `could not judge: ${reason}`
+  };
+}
 
 // src/detectors/c8-authority-declared.ts
 var TIER_SET = /* @__PURE__ */ new Set(["public", "org-member", "org-admin", "fleet-internal", "master"]);
@@ -1621,6 +2153,8 @@ var c8AuthorityDeclared = {
         verdict: "no tool registrations found; authority-declared check n/a"
       };
     }
+    const opaque = opaqueAnnotationsAbstain(this.id, "C-8", tools);
+    if (opaque) return opaque;
     for (const t of tools) {
       if (isFolded(t)) {
         return {
@@ -1724,6 +2258,8 @@ var c9VerbDeclared = {
         verdict: "no tool registrations found; verb-declared check n/a"
       };
     }
+    const opaque = opaqueAnnotationsAbstain(this.id, "C-9", tools);
+    if (opaque) return opaque;
     for (const t of tools) {
       if (!t.verb) {
         return {
@@ -1819,6 +2355,8 @@ var c10MechanismDeclared = {
         verdict: "no list/search tool found; mechanism-declared check n/a"
       };
     }
+    const opaque = opaqueAnnotationsAbstain(this.id, "C-10", applicable);
+    if (opaque) return opaque;
     for (const t of applicable) {
       if (!t.searchMechanism) {
         return {
@@ -1893,6 +2431,8 @@ var c11Pagination = {
         verdict: "no list/read/get/search tool registrations found; pagination declaration check n/a"
       };
     }
+    const opaque = opaqueAnnotationsAbstain(this.id, "C-11", tools);
+    if (opaque) return opaque;
     for (const t of tools) {
       const missing = [];
       if (!t.paginationCursorDeclared) missing.push("paginationCursor");
@@ -2116,6 +2656,8 @@ var c13ContextCeiling = {
         verdict: "no tool registrations found; context-ceiling check n/a"
       };
     }
+    const opaque = opaqueAnnotationsAbstain(this.id, "C-13", tools);
+    if (opaque) return opaque;
     const ceiling = findCeiling(tree);
     if (!ceiling) {
       return {
@@ -2349,7 +2891,7 @@ var c15AnnotationsUntrusted = {
       };
     }
     for (const t of tools) {
-      if (!allHintsDeclared(t)) {
+      if (!allHintsDeclared(t) && !t.annotationsUnresolved) {
         const missing = missingHints(t).join(", ");
         return {
           id: this.id,
@@ -2359,6 +2901,17 @@ var c15AnnotationsUntrusted = {
         };
       }
     }
+    const opaque = tools.find((t) => t.annotationsUnresolved);
+    if (opaque) {
+      const reason = `tool "${opaque.name}" at ${opaque.anchor} passes \`annotations: ${opaque.annotationsUnresolved}\`, which is not an inline object and does not resolve to a \`const\` object literal in this tree \u2014 its four behavioral hints are unreadable statically (C-15)`;
+      return {
+        id: this.id,
+        anchor: opaque.anchor,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
     return {
       id: this.id,
       anchor: tools[0].anchor,
@@ -2447,21 +3000,92 @@ var c16UntrustedOutput = {
 
 // src/detectors/c17-supply-chain.ts
 import { existsSync as existsSync3, readFileSync as readFileSync4, readdirSync as readdirSync2 } from "fs";
-import { join as join3 } from "path";
+import { dirname as dirname2, join as join3, relative as relative2, resolve } from "path";
 var PIN4 = "a74a042b53c71a095ab88b3073bd47728eeda814";
 var LOCKFILES = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb"];
 var WORKFLOW_DIR = join3(".github", "workflows");
-var PROVENANCE_RE2 = /--provenance\b|\bprovenance\s*:\s*true\b|id-token:\s*write/i;
+var PROVENANCE_RE2 = /\b(?:npm|pnpm|yarn|bun)\s+publish\b[^\n]*?--provenance\b/;
+function workflowStatements(text) {
+  const out = [];
+  const lines = text.split("\n").map((l) => l.replace(/(^|\s)#.*$/, "$1"));
+  for (let i = 0; i < lines.length; i++) {
+    let stmt = lines[i];
+    const start = i + 1;
+    while (/\\\s*$/.test(stmt) && i + 1 < lines.length) {
+      stmt = `${stmt.replace(/\\\s*$/, " ")}${lines[++i].trim()}`;
+    }
+    out.push([start, stmt]);
+  }
+  return out;
+}
+var PROVENANCE_RECORD_FILES = ["PROVENANCE", "PROVENANCE.md", "CHANGELOG.md", "README.md"];
+var RECORD_LINE_RE = /^[\s>*_\-+]*Provenance\s*:\s*(.*)$/i;
+var SHASUM_HEX_RE = /\bshasum\b[^\n]*?\b([0-9a-f]{40})\b/i;
+function judgeProvenanceRecord(line, name, version) {
+  const body = line.match(RECORD_LINE_RE)?.[1] ?? "";
+  const esc2 = (x) => x.replace(/[.+*?^$()[\]{}|\\/]/g, "\\$&");
+  const named = new RegExp(`(?:^|[\\s(])${esc2(name)}@v?${esc2(version)}(?![\\w.-]*\\d)`);
+  if (!named.test(body)) {
+    return { ok: false, why: `it does not name ${name}@${version}, the artifact being published` };
+  }
+  if (!SHASUM_HEX_RE.test(body)) {
+    return { ok: false, why: "it carries no 40-hex `shasum` (the width of dist.shasum)" };
+  }
+  return { ok: true, why: "" };
+}
+function findProvenanceRecord(root, name, version) {
+  let firstBad = null;
+  for (const recordFile of PROVENANCE_RECORD_FILES) {
+    const path = join3(root, recordFile);
+    if (!existsSync3(path)) continue;
+    let text;
+    try {
+      text = readFileSync4(path, "utf8");
+    } catch {
+      continue;
+    }
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (!RECORD_LINE_RE.test(lines[i])) continue;
+      const site = `${recordFile}:${i + 1}`;
+      if (!version || !name) {
+        firstBad ??= {
+          site,
+          ok: false,
+          why: "package.json declares no name and version to match it against"
+        };
+        continue;
+      }
+      const j = judgeProvenanceRecord(lines[i], name, version);
+      if (j.ok) return { site, ok: true, why: "" };
+      firstBad ??= { site, ok: false, why: j.why };
+    }
+  }
+  return firstBad;
+}
+var RECORD_SAMPLE = "Provenance: p@1.2.3 npm-pack shasum 4b825dc642cb6eb9a060e54bf8d69288fbee4904 reproduced by r, read back from the registry 2026-10-10";
 function c17PositiveControls() {
   const sample = "npm publish --provenance --access public";
   const bare = "npm publish --access public";
+  const claimed = (t) => workflowStatements(t).some(([, l]) => PROVENANCE_RE2.test(l));
   return {
     provenanceMatcher: {
       pattern: PROVENANCE_RE2.source,
       sample,
       matched: PROVENANCE_RE2.test(sample),
-      rejectsBare: !PROVENANCE_RE2.test(bare)
-    }
+      // Bare publish, a comment naming the flag, the OIDC permission alone, and a continuation
+      // line are the four shapes the matcher must tell apart.
+      rejectsBare: !PROVENANCE_RE2.test(bare) && !claimed("# run: npm publish --provenance") && !claimed("    run: npm publish --access public # --provenance later") && !claimed("permissions:\n  id-token: write") && claimed("run: npm publish \\\n  --provenance --access public")
+    },
+    recordAcceptsComplete: judgeProvenanceRecord(RECORD_SAMPLE, "p", "1.2.3").ok,
+    recordRejectsOtherVersion: !judgeProvenanceRecord(RECORD_SAMPLE, "p", "1.2.4").ok,
+    recordRejectsOtherPackage: !judgeProvenanceRecord(RECORD_SAMPLE, "q", "1.2.3").ok,
+    recordRejectsBareVersion: !judgeProvenanceRecord(
+      "Provenance: version 1.2.3 npm-pack shasum 4b825dc642cb6eb9a060e54bf8d69288fbee4904",
+      "p",
+      "1.2.3"
+    ).ok,
+    recordRejectsNoShasum: !judgeProvenanceRecord("Provenance: p@1.2.3 trust us", "p", "1.2.3").ok
   };
 }
 function findLockfile(root) {
@@ -2478,30 +3102,45 @@ function findProvenanceClaim(tree, root) {
       return { site: `${pkg.path}:publishConfig.provenance`, text: "provenance: true" };
     }
   }
-  const workflowsDir = join3(root, WORKFLOW_DIR);
-  if (!existsSync3(workflowsDir)) return null;
-  let entries = [];
-  try {
-    entries = readdirSync2(workflowsDir);
-  } catch {
-    return null;
-  }
-  for (const name of entries) {
-    if (!/\.ya?ml$/.test(name)) continue;
-    const path = join3(workflowsDir, name);
-    let text;
+  for (const dir of workflowDirs(root)) {
+    const workflowsDir = join3(dir, WORKFLOW_DIR);
+    if (!existsSync3(workflowsDir)) continue;
+    let entries = [];
     try {
-      text = readFileSync4(path, "utf8");
+      entries = readdirSync2(workflowsDir).sort();
     } 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 };
+    for (const name of entries) {
+      if (!/\.ya?ml$/.test(name)) continue;
+      const path = join3(workflowsDir, name);
+      let text;
+      try {
+        text = readFileSync4(path, "utf8");
+      } catch {
+        continue;
+      }
+      const hit = workflowStatements(text).find(([, l]) => PROVENANCE_RE2.test(l));
+      if (hit) {
+        const line = hit[0];
+        const rel = relative2(root, workflowsDir) || WORKFLOW_DIR;
+        return { site: `${rel}/${name}:${line}`, text };
+      }
     }
   }
   return null;
 }
+function workflowDirs(root) {
+  const chain = [];
+  let dir = resolve(root);
+  for (; ; ) {
+    chain.push(dir);
+    if (existsSync3(join3(dir, ".git"))) return chain;
+    const parent = dirname2(dir);
+    if (parent === dir) return [resolve(root)];
+    dir = parent;
+  }
+}
 var c17SupplyChainInner = {
   id: "C17 supply-chain",
   rule: "C-17",
@@ -2513,6 +3152,11 @@ var c17SupplyChainInner = {
         `C17 provenance-matcher control FAILED: accept(\`${controls.provenanceMatcher.sample}\`)=${controls.provenanceMatcher.matched} rejectsBare=${controls.provenanceMatcher.rejectsBare} \u2014 matcher broken, verdict untrustworthy`
       );
     }
+    if (!controls.recordAcceptsComplete || !controls.recordRejectsOtherVersion || !controls.recordRejectsNoShasum || !controls.recordRejectsOtherPackage || !controls.recordRejectsBareVersion) {
+      throw new Error(
+        `C17 provenance-record control FAILED: ${JSON.stringify(controls)} \u2014 record parser broken, verdict untrustworthy`
+      );
+    }
     const lockfile = findLockfile(tree.root);
     if (!lockfile) {
       return {
@@ -2523,12 +3167,31 @@ var c17SupplyChainInner = {
       };
     }
     const claim = findProvenanceClaim(tree, tree.root);
+    const pkgVersion = typeof tree.packageJson?.json.version === "string" ? tree.packageJson.json.version : void 0;
+    const pkgName = typeof tree.packageJson?.json.name === "string" ? tree.packageJson.json.name : void 0;
+    const record = claim ? null : findProvenanceRecord(tree.root, pkgName, pkgVersion);
+    if (!claim && record?.ok) {
+      return {
+        id: this.id,
+        anchor: record.site,
+        state: "present",
+        verdict: `lockfile ${lockfile} pinned + reproduced-shasum record at ${record.site} (non-CI path, C-17; PROPOSED EVIDENCE FORM \u2014 the reviewer rules on it). Whether that shasum equals the registry's dist.shasum is the gate check at publish time \u2014 this static run asserts the record is complete and names version ${pkgVersion}, not that the gate has resolved it.`
+      };
+    }
+    if (!claim && record && !record.ok) {
+      return {
+        id: this.id,
+        anchor: record.site,
+        state: "non-conforming",
+        verdict: `lockfile ${lockfile} present and a \`Provenance:\` line at ${record.site}, but ${record.why} -> a record covers only the version it names and must carry the reproduced 40-hex shasum (C-17, non-CI path; proposed evidence form)`
+      };
+    }
     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)`
+        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\`, or, when no CI publishes, a \`Provenance: <pkg>@<version> npm-pack shasum <40-hex> ...\` record in PROVENANCE / CHANGELOG.md / README.md (C-17b; record form proposed)`
       };
     }
     return {
@@ -2552,6 +3215,28 @@ function manifestPath(root) {
   if (existsSync4(extPath)) return { kind: "extension", path: extPath };
   return { kind: "server", path: join4(root, "mcp.json") };
 }
+var SERVER_MANIFEST_NAMES = ["mcp.json", "mcp-server.json"];
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function classifyRootJson(json) {
+  if (!json) return "unparseable";
+  if (isObject(json.mcpServers)) return "plugin-config";
+  if (isObject(json.capabilities) && isObject(json.transport) && typeof json.version === "string") {
+    return "server-manifest";
+  }
+  return "partial";
+}
+function rootCandidates(root) {
+  const out = [];
+  for (const name of SERVER_MANIFEST_NAMES) {
+    const path = join4(root, name);
+    if (!existsSync4(path)) continue;
+    const json = readJson(path);
+    out.push({ name, path, role: classifyRootJson(json), json });
+  }
+  return out;
+}
 function readJson(path) {
   try {
     return JSON.parse(readFileSync5(path, "utf8"));
@@ -2565,7 +3250,10 @@ function c18PositiveControls() {
     versionParity: {
       matched: equalCheck("0.1.0", "0.1.0"),
       rejectsMismatch: !equalCheck("0.1.0", "0.2.0")
-    }
+    },
+    contentIdentifiesPluginConfig: classifyRootJson({ mcpServers: { a: {} } }) === "plugin-config",
+    contentIdentifiesServerManifest: classifyRootJson({ version: "1", capabilities: {}, transport: {} }) === "server-manifest",
+    contentRejectsPartial: classifyRootJson({ version: "1", name: "x" }) === "partial"
   };
 }
 var c18StructureManifestInner = {
@@ -2574,6 +3262,11 @@ var c18StructureManifestInner = {
   pin: PIN5,
   run(tree) {
     const controls = c18PositiveControls();
+    if (!controls.contentIdentifiesPluginConfig || !controls.contentIdentifiesServerManifest || !controls.contentRejectsPartial) {
+      throw new Error(
+        "C18 manifest-by-content control FAILED: mcpServers must read as plugin config, capabilities+transport+version as server manifest, a bare name+version as partial \u2014 verdict untrustworthy"
+      );
+    }
     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"
@@ -2600,25 +3293,64 @@ var c18StructureManifestInner = {
         verdict: `could not judge: ${reason}`
       };
     }
-    const { kind, path } = manifestPath(tree.root);
-    const manifestName = kind === "extension" ? "extension.json" : "mcp.json";
-    if (!existsSync4(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)`
-      };
+    const ext = manifestPath(tree.root);
+    const kind = ext.kind;
+    let path = ext.path;
+    let manifest = null;
+    let manifestName = kind === "extension" ? "extension.json" : "mcp.json";
+    if (kind === "server") {
+      const cands = rootCandidates(tree.root);
+      const bad = cands.find((c) => c.role === "unparseable");
+      if (bad) {
+        return {
+          id: this.id,
+          anchor: bad.path,
+          state: "non-conforming",
+          verdict: `${bad.name} present but could not be parsed as JSON -> fix the manifest (C-18)`
+        };
+      }
+      const manifests = cands.filter((c) => c.role === "server-manifest");
+      if (manifests.length > 1) {
+        return {
+          id: this.id,
+          anchor: manifests[0].path,
+          state: "non-conforming",
+          verdict: `two root files each carry capabilities + transport + version (${manifests.map((c) => c.name).join(" and ")}) -> a repository has ONE server manifest; keep it in mcp-server.json when mcp.json is the OpenAI plugin config, otherwise in mcp.json (C-18)`
+        };
+      }
+      const chosen = manifests[0] ?? cands.find((c) => c.role === "partial" && c.name === "mcp-server.json") ?? cands.find((c) => c.role === "partial");
+      if (!chosen) {
+        const plugin = cands.find((c) => c.role === "plugin-config");
+        return {
+          id: this.id,
+          anchor: plugin ? plugin.path : tree.root,
+          state: "non-conforming",
+          verdict: plugin ? `no server manifest found: ${plugin.name} carries \`mcpServers\` (the OpenAI plugin config, not the server manifest) and no root file carries capabilities + transport + version -> add mcp-server.json with the server manifest (C-18)` : "no mcp.json or mcp-server.json found at the tree root -> the server/App manifest is required (C-18)"
+        };
+      }
+      path = chosen.path;
+      manifest = chosen.json;
+      manifestName = chosen.name;
+    } else {
+      if (!existsSync4(path)) {
+        return {
+          id: this.id,
+          anchor: tree.root,
+          state: "non-conforming",
+          verdict: "no extension.json found at the tree root -> the extension manifest is required (C-18)"
+        };
+      }
+      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 (!manifest) throw new Error("C18: manifest selection produced no manifest \u2014 unreachable");
     if (typeof manifest.name !== "string" || manifest.name.length === 0) {
       return {
         id: this.id,
@@ -2652,7 +3384,7 @@ var c18StructureManifestInner = {
           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)`
+          verdict: `${manifestName} is missing required field(s): ${missing.join(", ")} not declared -> declare capabilities/transport (C-18)`
         };
       }
     }
@@ -2688,30 +3420,52 @@ var c18StructureManifest = guardUnreadablePackageJson(
 // 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;
+var DESCRIPTION_KEY_RE = /\bdescription\s*:/;
 function findInlineDescription(tree, siteAnchor, toolName) {
+  const forwarded = wrapperDescriptionArg(tree, siteAnchor);
+  if (forwarded !== void 0) {
+    const resolved = /^[A-Za-z_$][\w$]*$/.test(forwarded) ? constExpression(tree, forwarded) : null;
+    const v = readDescriptionValue(resolved ?? forwarded);
+    if (v.kind === "literal" && v.text.length > 0) return v.text;
+    if (v.kind === "non-literal") return v;
+  }
   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);
+  let floor = 1;
+  for (const other of findRegisteredTools(tree)) {
+    const [orel, oline] = other.anchor.split(":");
+    const n = Number.parseInt(oline, 10);
+    if (orel === rel && n < siteLine) floor = Math.max(floor, ownCallEnd(file, n) + 1);
+  }
+  const start = Math.max(floor, siteLine - BACKWARD_LOOKBACK);
   const end = Math.min(siteLine + FORWARD_LOOKAHEAD, file.lines.length + 1);
+  let nonLiteral;
   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];
+    const key = line.raw.match(DESCRIPTION_KEY_RE);
+    if (key && key.index !== void 0) {
+      const after = line.raw.slice(key.index + key[0].length);
+      const tail = file.lines.slice(n, n + 8).filter((l) => !l.comment).map((l) => l.raw).join("\n");
+      const v = readDescriptionValue(`${after}
+${tail}`);
+      if (v.kind === "literal" && v.text.length > 0) return v.text;
+      if (v.kind === "non-literal" && !nonLiteral) nonLiteral = v;
+      continue;
+    }
     if (n >= siteLine) {
       const bare = line.raw.match(BARE_STRING_RE);
       if (bare && bare[1] !== toolName) return bare[1];
     }
   }
-  return void 0;
+  return nonLiteral;
 }
 var TRIGGER_LIST_RE = /use this whenever/i;
 var TRIGGER_CLOSE_RE = /even if they don'?t say/i;
@@ -2726,7 +3480,10 @@ function c19PositiveControls() {
     triggerListAccepts: TRIGGER_LIST_RE.test(triggerSample),
     triggerCloseAccepts: TRIGGER_CLOSE_RE.test(triggerSample),
     bilingualAccepts: BILINGUAL_SPLIT_RE.test(bilingualSample),
-    bilingualRejectsMonolingual: !BILINGUAL_SPLIT_RE.test(monoSample)
+    bilingualRejectsMonolingual: !BILINGUAL_SPLIT_RE.test(monoSample),
+    concatenationAccepts: JSON.stringify(readDescriptionValue(`"a, b's " +
+ "c"`)) === JSON.stringify({ kind: "literal", text: "a, b's c" }),
+    nonLiteralRejects: readDescriptionValue("describeTool(x)").kind === "non-literal"
   };
 }
 var c19ServedDescriptions = {
@@ -2735,7 +3492,7 @@ var c19ServedDescriptions = {
   pin: PIN6,
   run(tree) {
     const controls = c19PositiveControls();
-    if (!controls.inlineDescAccepts || !controls.triggerListAccepts || !controls.triggerCloseAccepts || !controls.bilingualAccepts || !controls.bilingualRejectsMonolingual) {
+    if (!controls.inlineDescAccepts || !controls.triggerListAccepts || !controls.triggerCloseAccepts || !controls.bilingualAccepts || !controls.bilingualRejectsMonolingual || !controls.concatenationAccepts || !controls.nonLiteralRejects) {
       throw new Error(
         `C19 positive control FAILED: ${JSON.stringify(controls)} \u2014 matcher broken, verdict untrustworthy`
       );
@@ -2763,8 +3520,13 @@ var c19ServedDescriptions = {
         verdict: "no tool registrations found; served-descriptions check n/a (C-19)"
       };
     }
+    let opaque;
     for (const site of sites) {
       const desc = findInlineDescription(tree, site.anchor, site.name);
+      if (typeof desc === "object") {
+        opaque ??= { anchor: site.anchor, name: site.name, expr: desc.expr };
+        continue;
+      }
       if (!desc) {
         return {
           id: this.id,
@@ -2774,6 +3536,16 @@ var c19ServedDescriptions = {
         };
       }
     }
+    if (opaque) {
+      const reason = `tool "${opaque.name}" at ${opaque.anchor} declares \`description: ${opaque.expr}\`, which is not a string literal, a concatenation of literals, or a template literal without expressions \u2014 the declared text is unreadable statically (C-19)`;
+      return {
+        id: this.id,
+        anchor: opaque.anchor,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
     return {
       id: this.id,
       anchor: sites[0].anchor,
@@ -3116,6 +3888,11 @@ var IDENTITY_KEY_NAMES = [
   "gitCommit",
   "gitRevision"
 ];
+var HEALTH_ROUTE_RE = /\b[A-Za-z_$][\w$]*\.(?:get|all|route|use)\s*\(\s*["'`][^"'`]*\/health|\bpathname\s*===?\s*["'`][^"'`]*\/health/;
+var HEALTH_IDENTITY_KEYS = [...IDENTITY_KEY_NAMES, "commit"];
+var HEALTH_KEY_LINE_RE = new RegExp(
+  `(?:^|[\\s{,])(${HEALTH_IDENTITY_KEYS.join("|")})\\s*:\\s*(.+?)\\s*,?\\s*$`
+);
 var CONSTRUCTOR_RE = /\bnew\s+(?:McpServer|Server)\s*\(/;
 var IDENTITY_KEY_LINE_RE = new RegExp(
   `\\b(${IDENTITY_KEY_NAMES.join("|")})\\s*:\\s*(.+?)\\s*,?\\s*$`
@@ -3131,12 +3908,25 @@ function isLiteralValue(expr) {
   if (m[1] === "`" && /\$\{/.test(m[2])) return false;
   return true;
 }
+function valueIsLiteral(tree, expr) {
+  const trimmed = expr.trim().replace(/,$/, "").trim();
+  if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
+    const bound = constExpression(tree, trimmed);
+    if (bound !== null) return isLiteralValue(bound);
+  }
+  return isLiteralValue(expr);
+}
 function c25PositiveControls() {
+  const hd = '  commit: process.env.RAILWAY_GIT_COMMIT_SHA ?? "unknown",'.match(HEALTH_KEY_LINE_RE);
+  const hl = '  commit: "4b825dc",'.match(HEALTH_KEY_LINE_RE);
   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
+    derivedRejectsAsLiteral: derivedMatch ? isLiteralValue(derivedMatch[2]) : false,
+    healthRouteMatches: HEALTH_ROUTE_RE.test('app.get("/health", (c) =>') && !HEALTH_ROUTE_RE.test('app.get("/tools", h)'),
+    healthDerivedCommitReads: hd ? !isLiteralValue(hd[2]) : false,
+    healthLiteralCommitReads: hl ? isLiteralValue(hl[2]) : false
   };
 }
 function extractConstructorArgs(file, startIdx) {
@@ -3161,6 +3951,27 @@ function extractConstructorArgs(file, startIdx) {
   }
   return null;
 }
+function findHealthSurfaces(tree) {
+  const out = [];
+  for (const file of tree.files) {
+    file.lines.forEach((line, idx) => {
+      if (line.comment || !HEALTH_ROUTE_RE.test(line.raw)) return;
+      const anchor = `${file.rel}:${line.n}`;
+      const body = extractConstructorArgs(file, idx);
+      if (body === null || !/\bversion\s*:/.test(body)) return;
+      for (const raw of body.split("\n")) {
+        const m = raw.match(HEALTH_KEY_LINE_RE);
+        if (!m) continue;
+        const value = m[2];
+        out.push(
+          valueIsLiteral(tree, value) ? { kind: "literal", key: m[1], value: value.trim(), anchor: `${anchor} (/health)` } : { kind: "derived", key: m[1], anchor: `${anchor} (/health)` }
+        );
+        return;
+      }
+    });
+  }
+  return out;
+}
 function findConstructorSites(tree) {
   const sites = [];
   for (const file of tree.files) {
@@ -3176,14 +3987,14 @@ function findConstructorSites(tree) {
   }
   return sites;
 }
-function classifyArgs(args, anchor) {
+function classifyArgs(tree, 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 };
+      if (valueIsLiteral(tree, value)) return { kind: "literal", key, value: value.trim(), anchor };
       return { kind: "derived", key, anchor };
     }
   }
@@ -3195,7 +4006,7 @@ var c25BuildIdentity = {
   pin: PIN8,
   run(tree) {
     const controls = c25PositiveControls();
-    if (!controls.literalAccepts || controls.derivedRejectsAsLiteral) {
+    if (!controls.literalAccepts || controls.derivedRejectsAsLiteral || !controls.healthRouteMatches || !controls.healthDerivedCommitReads || !controls.healthLiteralCommitReads) {
       throw new Error(
         `C25 literal/derived control FAILED: ${JSON.stringify(controls)} \u2014 matcher broken, verdict untrustworthy`
       );
@@ -3221,8 +4032,18 @@ var c25BuildIdentity = {
         };
       }
     }
+    const health = findHealthSurfaces(tree);
+    const healthDerived = health.find((h) => h.kind === "derived");
+    if (healthDerived && healthDerived.kind === "derived") {
+      return {
+        id: this.id,
+        anchor: healthDerived.anchor,
+        state: "present",
+        verdict: `build-identity field "${healthDerived.key}" at ${healthDerived.anchor} is fed by the build (not a literal) \u2014 served beside version on the unauthenticated /health surface (C-25). Whether the SERVED value equals the expected commit is the dynamique half, run with a live session.`
+      };
+    }
     for (const site of sites) {
-      const finding = classifyArgs(site.args, site.anchor);
+      const finding = classifyArgs(tree, 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 {
@@ -3250,6 +4071,15 @@ var c25BuildIdentity = {
         };
       }
     }
+    const healthLiteral = health.find((h) => h.kind === "literal");
+    if (healthLiteral && healthLiteral.kind === "literal") {
+      return {
+        id: this.id,
+        anchor: healthLiteral.anchor,
+        state: "non-conforming",
+        verdict: `build-identity field "${healthLiteral.key}" at ${healthLiteral.anchor} is a hand-written literal (${healthLiteral.value}) -> a literal never changes on its own and proves nothing about the tree actually served; derive it from the build (C-25)`
+      };
+    }
     return {
       id: this.id,
       anchor: sites[0].anchor,
@@ -3358,7 +4188,7 @@ import {
   writeFileSync
 } from "fs";
 import { tmpdir } from "os";
-import { basename as basename2, join as join6, relative as relative2, sep as sep2 } from "path";
+import { basename as basename2, join as join6, relative as relative3, sep as sep2 } from "path";
 var PIN9 = "20136b50";
 var DEPLOY_CONFIG_FILES = [
   "railway.json",
@@ -3461,12 +4291,12 @@ function c26DeriveScope(root, tree) {
   const skipped = [];
   const onSkip = (skippedDir, depth) => {
     const entry = tree ? recordSkip(tree, skippedDir, root) : {
-      path: relative2(root, skippedDir).split(sep2).join("/"),
+      path: relative3(root, skippedDir).split(sep2).join("/"),
       reason: SKIP_DIR_INFO[basename2(skippedDir)]?.reason ?? "skipped"
     };
     if (SKIP_DIR_INFO[basename2(skippedDir)]?.authored) {
       const hit = probeForCandidate(skippedDir, depth);
-      if (hit) entry.candidate = relative2(root, hit).split(sep2).join("/");
+      if (hit) entry.candidate = relative3(root, hit).split(sep2).join("/");
     }
     if (!skipped.some((d) => d.path === entry.path)) skipped.push(entry);
   };
@@ -3650,7 +4480,7 @@ function renderCoverage(scope, verdicts) {
     }
   }
   return verdicts.map((v) => {
-    const rel = relative2(process.cwd(), v.site.dir) || v.site.dir;
+    const rel = relative3(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(" | ");
@@ -3728,30 +4558,102 @@ var c26SubpackageLockfile = {
 
 // src/detectors/d2.ts
 var SESSION_RE = /mcp-session-id/i;
+var GENERATOR_RE = /\bsessionIdGenerator\s*:\s*(?!undefined\b)\S/;
+var HEADER_CALL_RE = /\b(?:get|header|set|setHeader|append|getHeader)\s*\(\s*["'`]mcp-session-id["'`]/i;
+var HEADER_INDEX_RE = /\[\s*["'`]mcp-session-id["'`]\s*\]/i;
+var HEADER_KEY_RE = /["'`]mcp-session-id["'`]\s*:/i;
+var STORE_RE = /\b(?:sessions?|transports?)\w*\s*(?:\[\s*\w*[sS]essionId|\.(?:get|set|has|delete)\(\s*\w*[sS]essionId)/;
+var KEYING = [
+  { id: "sessionIdGenerator set", re: GENERATOR_RE },
+  { id: "header read/written by call", re: HEADER_CALL_RE },
+  { id: "header read by index", re: HEADER_INDEX_RE },
+  { id: "header sent as an object key", re: HEADER_KEY_RE },
+  { id: "store keyed by a session id", re: STORE_RE }
+];
+var CORS_OPEN_RE = /\b(?:allow|expose)d?Headers\s*:\s*\[|Access-Control-(?:Allow|Expose)-Headers/i;
+function inCorsList(file, idx) {
+  if (CORS_OPEN_RE.test(file.lines[idx].raw)) return true;
+  let depth = 0;
+  for (let i = idx; i >= Math.max(0, idx - 25); i--) {
+    const l = file.lines[i];
+    if (l.comment) continue;
+    const raw = i === idx ? l.raw.slice(0, l.raw.search(SESSION_RE)) : l.raw;
+    depth += (raw.match(/\]/g) ?? []).length - (raw.match(/\[/g) ?? []).length;
+    if (i !== idx && CORS_OPEN_RE.test(l.raw) && depth < 0) return true;
+    if (depth < 0 && i !== idx) return false;
+  }
+  return false;
+}
+function d2PositiveControls() {
+  const f = (s) => ({
+    path: "x.ts",
+    rel: "x.ts",
+    lines: s.split("\n").map((raw, i) => ({ n: i + 1, raw, comment: false }))
+  });
+  const cors = f('cors({\n  allowHeaders: [\n    "Content-Type",\n    "mcp-session-id",\n  ],\n})');
+  const notCors = f('const x = [\n  "mcp-session-id",\n];');
+  return {
+    "keying:generator": GENERATOR_RE.test("sessionIdGenerator: () => randomUUID(),"),
+    "negative:generator-undefined": !GENERATOR_RE.test("sessionIdGenerator: undefined,"),
+    "keying:index": HEADER_INDEX_RE.test('req.headers["mcp-session-id"]'),
+    "keying:call": HEADER_CALL_RE.test('c.req.header("mcp-session-id")'),
+    "keying:store": STORE_RE.test("transports[sessionId]"),
+    "negative:cors-entry-is-not-a-keying-form": !KEYING.some(
+      (k) => k.re.test('  "mcp-session-id",')
+    ),
+    "cors:array-above": inCorsList(cors, 3),
+    "negative:plain-array-is-not-cors": !inCorsList(notCors, 1)
+  };
+}
 var d2 = {
   id: "D2 stateless",
   run(tree) {
-    const hits = [];
+    const failed = Object.entries(d2PositiveControls()).filter(([, ok]) => !ok);
+    if (failed.length > 0) {
+      throw new Error(
+        `D2 positive control FAILED: ${failed.map(([k]) => k).join(", ")} \u2014 matcher broken, verdict untrustworthy`
+      );
+    }
+    const keying = [];
+    const cors = [];
+    const unknown = [];
     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 });
-      }
+      file.lines.forEach((line, idx) => {
+        if (line.comment) return;
+        const site = `${file.rel}:${line.n}`;
+        const form = KEYING.find((k) => k.re.test(line.raw));
+        if (form) {
+          keying.push({ site, form: form.id });
+          return;
+        }
+        if (!SESSION_RE.test(line.raw)) return;
+        if (inCorsList(file, idx)) cors.push(site);
+        else unknown.push(site);
+      });
     }
-    if (hits.length > 0) {
-      const anchor = `${hits[0].file}:${hits.map((h) => h.line).join(",")}`;
+    if (keying.length > 0) {
       return {
         id: this.id,
-        anchor,
+        anchor: `${keying[0].site}`,
         state: "non-conforming",
-        verdict: "session-keyed (mcp-session-id header) -> migrate to stateless"
+        verdict: `session-keyed -> migrate to stateless: ${keying.map((k) => `${k.site} (${k.form})`).join("; ")}`
+      };
+    }
+    if (unknown.length > 0) {
+      const reason = `mcp-session-id at ${unknown.join(", ")} is neither a CORS header-list entry nor a recognised session-keying form (generator, header read/write, header key, session-keyed store) \u2014 whether it keys sessions is undecidable statically`;
+      return {
+        id: this.id,
+        anchor: unknown[0],
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
       };
     }
     return {
       id: this.id,
-      anchor: "-",
+      anchor: cors[0] ?? "-",
       state: "present",
-      verdict: "stateless (no mcp-session-id session-keying)"
+      verdict: cors.length > 0 ? `stateless: mcp-session-id is only named in CORS header lists (${cors.join(", ")}) \u2014 an inert header name, no session id generator, header read or session-keyed store found` : "stateless (no mcp-session-id session-keying)"
     };
   }
 };
@@ -3989,9 +4891,53 @@ function depListed(pkgJson) {
   }
   return false;
 }
+var SDK_V2_PKG = "@modelcontextprotocol/server";
+var DEP_KEYS = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+function sdkV2Dependency(pkgJson) {
+  if (!pkgJson) return { kind: "none" };
+  for (const key of DEP_KEYS) {
+    const deps = pkgJson[key];
+    if (!deps || typeof deps !== "object") continue;
+    const range = deps[SDK_V2_PKG];
+    if (typeof range !== "string") continue;
+    const m = range.trim().match(/^(?:[\^~]|>=|>|=)?\s*v?(\d+)(?:\.(?:\d+|x|\*))*(?:\s|$|-)/);
+    if (!m) return { kind: "unreadable", range };
+    return Number(m[1]) >= 2 ? { kind: "v2", range } : { kind: "below-v2", range };
+  }
+  return { kind: "none" };
+}
+var HANDROLLED_FIELD_RE = /\b(resultType|ttlMs|cacheScope)\s*:/;
+function handRolledBuilder(tree) {
+  for (const file of tree.files) {
+    const code = file.lines;
+    let hintsDepth = 0;
+    for (const line of code) {
+      if (line.comment) continue;
+      const opens = (line.raw.match(/\{/g) ?? []).length;
+      const closes = (line.raw.match(/\}/g) ?? []).length;
+      const startsHints = /\bcacheHints\s*:/.test(line.raw);
+      const inside = hintsDepth > 0 || startsHints;
+      if (!inside) {
+        const m = line.raw.match(HANDROLLED_FIELD_RE);
+        if (m) return { file: file.rel, line: line.n, field: m[1] };
+      }
+      if (startsHints || hintsDepth > 0) {
+        hintsDepth += opens - closes;
+        if (hintsDepth < 0) hintsDepth = 0;
+      }
+    }
+  }
+  return null;
+}
 var d7Inner = {
   id: "D7 protocol-kit",
   run(tree) {
+    const v2 = (r) => sdkV2Dependency({ dependencies: { [SDK_V2_PKG]: r } }).kind;
+    if (v2("^2.3.1") !== "v2" || v2(">=2 <3") !== "v2" || v2("^1.12.0") !== "below-v2" || v2("latest") !== "unreadable" || !HANDROLLED_FIELD_RE.test('{ resultType: "complete" }') || HANDROLLED_FIELD_RE.test("{ resultTypes: [] }")) {
+      throw new Error(
+        "D7 control FAILED: SDK v2 range reader / hand-rolled matcher broken \u2014 verdict untrustworthy"
+      );
+    }
     const listed = depListed(tree.packageJson?.json);
     let importLine = null;
     let callLine = null;
@@ -4012,17 +4958,46 @@ var d7Inner = {
         verdict: "protocol-kit listed + builder called"
       };
     }
-    if (listed && !called) {
+    if (listed && !called) {
+      return {
+        id: this.id,
+        anchor: tree.packageJson ? tree.packageJson.path.split("/").slice(-2).join("/") : "-",
+        state: "non-conforming",
+        verdict: "protocol-kit listed but no builder called -> wire buildToolsListResult/handleServerDiscover"
+      };
+    }
+    const pkgAnchor = tree.packageJson ? tree.packageJson.path.split("/").slice(-2).join("/") : "-";
+    const sdk = sdkV2Dependency(tree.packageJson?.json);
+    if (sdk.kind === "unreadable") {
+      const reason = `${SDK_V2_PKG} is declared as "${sdk.range}", whose lowest admissible major cannot be read \u2014 whether the SDK v2 path applies is undecidable (D7)`;
+      return {
+        id: this.id,
+        anchor: pkgAnchor,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    if (sdk.kind === "v2") {
+      const hand = handRolledBuilder(tree);
+      if (hand) {
+        return {
+          id: this.id,
+          anchor: `${hand.file}:${hand.line}`,
+          state: "non-conforming",
+          verdict: `hand-rolled result builder (\`${hand.field}:\` written in source at ${hand.file}:${hand.line}) and @vantageos/mcp-protocol-kit not a dependency -> let the SDK emit resultType/ttlMs/cacheScope (cacheHints) or adopt the kit (D7)`
+        };
+      }
       return {
         id: this.id,
-        anchor: tree.packageJson ? tree.packageJson.path.split("/").slice(-2).join("/") : "-",
-        state: "non-conforming",
-        verdict: "protocol-kit listed but no builder called -> wire buildToolsListResult/handleServerDiscover"
+        anchor: pkgAnchor,
+        state: "present",
+        verdict: `${SDK_V2_PKG} ${sdk.range} (SDK v2) and no hand-rolled result builder found: the SDK emits resultType/ttlMs/cacheScope, so protocol-kit is not required (D7). That the SDK serves all three fields is proven on the served response (S-2/S-3), not here`
       };
     }
     return {
       id: this.id,
-      anchor: tree.packageJson ? tree.packageJson.path.split("/").slice(-2).join("/") : "-",
+      anchor: pkgAnchor,
       state: "absent",
       verdict: "hand-rolled builders, protocol-kit not a dependency -> add @vantageos/mcp-protocol-kit"
     };
@@ -4032,7 +5007,7 @@ var d7 = guardUnreadablePackageJson(d7Inner, { authoritative: true });
 
 // src/detectors/d8.ts
 import { existsSync as existsSync7, statSync as statSync3 } from "fs";
-import { dirname as dirname2, join as join7, relative as relative3 } from "path";
+import { dirname as dirname3, join as join7, relative as relative4 } from "path";
 var POSITIVE_CONTROL2 = 'server.registerTool("list_items", { ... }, handler);';
 function d8PositiveControl() {
   return {
@@ -4042,9 +5017,9 @@ function d8PositiveControl() {
   };
 }
 function resolveBaseDir(tree) {
-  if (tree.packageJson) return dirname2(tree.packageJson.path);
+  if (tree.packageJson) return dirname3(tree.packageJson.path);
   try {
-    return statSync3(tree.root).isDirectory() ? tree.root : dirname2(tree.root);
+    return statSync3(tree.root).isDirectory() ? tree.root : dirname3(tree.root);
   } catch {
     return tree.root;
   }
@@ -4054,7 +5029,7 @@ function findEvalsFile(tree) {
   for (let depth = 0; depth < 8; depth++) {
     const candidate = join7(dir, "evals", "evals.json");
     if (existsSync7(candidate)) return candidate;
-    const parent = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -4115,7 +5090,7 @@ var d8 = {
       };
     }
     const baseDir = resolveBaseDir(tree);
-    const displayPath = relative3(baseDir, evalsPath) || evalsPath;
+    const displayPath = relative4(baseDir, evalsPath) || evalsPath;
     const parsed = readJsonObject(evalsPath);
     if (parsed === null || !Array.isArray(parsed.cases)) {
       return couldNotJudge(
@@ -4199,7 +5174,7 @@ var d8 = {
 
 // src/detectors/d9.ts
 import { existsSync as existsSync8 } from "fs";
-import { dirname as dirname3, join as join8 } from "path";
+import { dirname as dirname4, 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() {
@@ -4247,7 +5222,7 @@ var d9Inner = {
         verdict: `no "version" field in ${pkgPath.split("/").pop()} -> set a valid SemVer version`
       };
     }
-    const projectDir = dirname3(pkgPath);
+    const projectDir = dirname4(pkgPath);
     const changelogPath = join8(projectDir, "CHANGELOG.md");
     const hasChangelog = existsSync8(changelogPath);
     const validSemver = SEMVER_RE.test(version);
@@ -4279,7 +5254,7 @@ var d9 = guardUnreadablePackageJson(d9Inner, { authoritative: false });
 
 // src/detectors/d10.ts
 import { existsSync as existsSync9 } from "fs";
-import { dirname as dirname4, join as join9 } from "path";
+import { dirname as dirname5, join as join9 } from "path";
 var DESCRIPTION_FR_RE = /"description_fr"\s*:\s*"[^"]+"/;
 var POSITIVE_CONTROL4 = '"description_fr": "Un serveur MCP conforme.",';
 function d10PositiveControl() {
@@ -4314,17 +5289,38 @@ function firstSourceAnchor(tree, re) {
 function scanSourceDescriptionFr(tree) {
   const recognized = firstSourceAnchor(tree, SOURCE_DESCRIPTION_FR_RE);
   if (recognized) return { present: true, anchor: recognized.anchor };
-  const mentioned = firstSourceAnchor(tree, MENTION_RE);
-  if (mentioned) {
-    return {
-      present: false,
-      anchor: null,
-      undecidable: {
-        anchor: mentioned.anchor,
-        reason: `description_fr occurrence at ${mentioned.anchor} (\`${mentioned.raw}\`) does not match the recognized source form /${SOURCE_DESCRIPTION_FR_RE.source}/ \u2014 unknown bilingual-declaration shape, verdict undecidable`
+  const bindings = resolveNameBindings(tree);
+  let undecidable;
+  for (const file of tree.files) {
+    for (let i = 0; i < file.lines.length; i++) {
+      const line = file.lines[i];
+      if (line.comment || !MENTION_RE.test(line.raw)) continue;
+      const anchor = `${file.rel}:${line.n}`;
+      const key = line.raw.match(/description_fr\s*:/);
+      if (!key || key.index === void 0) {
+        undecidable ??= {
+          anchor,
+          reason: `description_fr occurrence at ${anchor} (\`${line.raw.trim()}\`) does not match the recognized source form /${SOURCE_DESCRIPTION_FR_RE.source}/ \u2014 unknown bilingual-declaration shape, verdict undecidable`
+        };
+        continue;
       }
-    };
+      const after = line.raw.slice(key.index + key[0].length);
+      const tail = file.lines.slice(i + 1, i + 9).filter((l) => !l.comment).map((l) => l.raw).join("\n");
+      const v = readDescriptionValue(`${after}
+${tail}`);
+      if (v.kind === "literal" && v.text.length > 0) return { present: true, anchor };
+      if (v.kind === "non-literal") {
+        const ident = v.expr.match(/^([A-Za-z_$][\w$]*)\s*[,}]?\s*$/);
+        if (ident && bindings.get(ident[1])) return { present: true, anchor };
+        const form = ident ? "an identifier that does not resolve to a same-tree string const" : /\w\s*\(/.test(v.expr) ? "a call" : "a non-literal expression";
+        undecidable ??= {
+          anchor,
+          reason: `description_fr at ${anchor} is followed by ${form} (\`${v.expr}\`) \u2014 the French text is computed, so whether it is declared and non-empty is unverifiable statically; verdict undecidable`
+        };
+      }
+    }
   }
+  if (undecidable) return { present: false, anchor: null, undecidable };
   return { present: false, anchor: null };
 }
 var d10Inner = {
@@ -4344,6 +5340,11 @@ var d10Inner = {
         `D10 source-form control FAILED: /${sourceControl.pattern}/ accept=${sourceControl.matchedPositive} reject=${!sourceControl.matchedNegative} \u2014 matcher broken, absence verdict untrustworthy`
       );
     }
+    if (readDescriptionValue('\n  "Un serveur."').kind !== "literal" || readDescriptionValue("t(locale, k)").kind !== "non-literal") {
+      throw new Error(
+        "D10 value-reader control FAILED: must accept a next-line literal and reject a call \u2014 verdict untrustworthy"
+      );
+    }
     if (!tree.packageJson) {
       return {
         id: this.id,
@@ -4354,7 +5355,7 @@ var d10Inner = {
       };
     }
     const { path: pkgPath, json: pkg } = tree.packageJson;
-    const root = dirname4(pkgPath);
+    const root = dirname5(pkgPath);
     const descriptionFr = typeof pkg.description_fr === "string" ? pkg.description_fr.trim() : "";
     const hasDescriptionFrJson = descriptionFr.length > 0;
     const sourceScan = scanSourceDescriptionFr(tree);
@@ -4774,11 +5775,11 @@ 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";
+import { dirname as dirname6, join as join10 } from "path";
 var DISCOVER_RE2 = /server\/discover|DiscoverResult|ServerDiscover|handleServerDiscover/;
 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(
+var HEALTH_ROUTE_RE2 = new RegExp(
   `${HEALTH_ROUTE_FRAMEWORK_RE.source}|${HEALTH_ROUTE_RAWPATH_RE.source}`
 );
 var VERSION_FIELD_RE = /\bversion\s*:/;
@@ -4789,6 +5790,7 @@ var VERSION_COMPUTED_RE = /\bversion\s*:\s*[A-Za-z_$][\w.]*\s*\(/;
 var VERSION_LITERAL_RE = /\bversion\s*:\s*["'`][^"'`]+["'`]/;
 var AUTH_GATE_RE = /requireAuth|verifyBearer|assertAuth|ensureAuthenticated|withAuth|requireBearer/;
 var WINDOW = 25;
+var SDK_SERVER_NEW_RE = /\bnew\s+McpServer\s*\(/;
 var CONTROLS2 = [
   {
     key: "surface",
@@ -4798,7 +5800,7 @@ var CONTROLS2 = [
   },
   {
     key: "health-framework",
-    re: HEALTH_ROUTE_RE,
+    re: HEALTH_ROUTE_RE2,
     positive: 'app.get("/health", handler)',
     negative: 'app.get("/tools", handler)'
   },
@@ -4807,7 +5809,7 @@ var CONTROLS2 = [
     // 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,
+    re: HEALTH_ROUTE_RE2,
     positive: 'if (req.method === "GET" && url.pathname === "/health") {',
     negative: 'if (url.pathname === "/mcp") {'
   },
@@ -4817,6 +5819,12 @@ var CONTROLS2 = [
     positive: "version: pkg.version",
     negative: "version: tool.version"
   },
+  {
+    key: "sdk-construction",
+    re: SDK_SERVER_NEW_RE,
+    positive: "const s = new McpServer({ name, version }, opts)",
+    negative: "const s = new Server({ name, version })"
+  },
   {
     key: "auth-gate",
     re: AUTH_GATE_RE,
@@ -4889,13 +5897,58 @@ function classifySurface(file, startIdx, anchor, pkgIdents) {
   if (!hasVersion) return { kind: "absent-version", anchor };
   return { kind: "unreadable-source", anchor };
 }
+function packageJsonVersionConsts(tree) {
+  const names = /* @__PURE__ */ new Set();
+  const decl = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\b/;
+  for (const file of tree.files) {
+    const code = file.lines.filter((l) => !l.comment);
+    for (let i = 0; i < code.length; i++) {
+      const m = code[i].raw.match(decl);
+      if (!m) continue;
+      let stmt = "";
+      let depth = 0;
+      for (let j = i; j < Math.min(code.length, i + 10); j++) {
+        const raw = code[j].raw;
+        stmt += `${raw}
+`;
+        depth += (raw.match(/[({[]/g) ?? []).length - (raw.match(/[)}\]]/g) ?? []).length;
+        if (depth <= 0 && /;\s*$/.test(raw)) break;
+      }
+      if (/package\.json/.test(stmt) && /\.version\b/.test(stmt)) names.add(m[1]);
+    }
+  }
+  return names;
+}
+function sdkServerVersionSurface(tree) {
+  const derived = packageJsonVersionConsts(tree);
+  for (const file of tree.files) {
+    const pkgIdents = collectPkgIdents(file);
+    for (let idx = 0; idx < file.lines.length; idx++) {
+      const line = file.lines[idx];
+      if (line.comment || !SDK_SERVER_NEW_RE.test(line.raw)) continue;
+      const body = extractHandlerBody(file, idx);
+      if (body === null) continue;
+      const v = body.match(/\bversion\s*:\s*([A-Za-z_$][\w$]*(?:\.[\w$]+)*)\s*(?:[,}]|$)/m);
+      if (!v) continue;
+      const expr = v[1];
+      const root = expr.split(".")[0];
+      const direct = pkgIdents.has(root) && expr.endsWith(".version") || PKG_SOURCE_RE.test(`version: ${expr}`);
+      if (direct || !expr.includes(".") && derived.has(expr)) {
+        return { kind: "present", anchor: `${file.rel}:${line.n}`, via: "sdk-server-info" };
+      }
+    }
+  }
+  return null;
+}
 function evalSurfaces(tree) {
   const out = [];
+  const sdk = sdkServerVersionSurface(tree);
+  if (sdk) out.push(sdk);
   for (const file of tree.files) {
     const pkgIdents = collectPkgIdents(file);
     file.lines.forEach((line, idx) => {
       if (line.comment) return;
-      if (DISCOVER_RE2.test(line.raw) || HEALTH_ROUTE_RE.test(line.raw)) {
+      if (DISCOVER_RE2.test(line.raw) || HEALTH_ROUTE_RE2.test(line.raw)) {
         out.push(classifySurface(file, idx, `${file.rel}:${line.n}`, pkgIdents));
       }
     });
@@ -4927,7 +5980,7 @@ var d16 = {
         id: this.id,
         anchor: present.anchor,
         state: "present",
-        verdict: `[static read] version exposed pre-auth at ${present.anchor}, sourced from package.json (Server Rule 16)`
+        verdict: present.via === "sdk-server-info" ? `[static read] version sourced from package.json is carried by the SDK server construction (new McpServer({ name, version })) at ${present.anchor}; the SDK serves it on server/discover and initialize. Declared residual: whether that SDK transport is reachable pre-auth is not readable statically \u2014 run --mode=dynamic for the served-value half (Server Rule 16)` : `[static read] version exposed pre-auth at ${present.anchor}, sourced from package.json (Server Rule 16)`
       };
     }
     const decisive = surfaces.find(
@@ -5041,14 +6094,14 @@ var d16 = {
 };
 function readPackageVersion(root) {
   try {
-    let dir = statSync4(root).isDirectory() ? root : dirname5(root);
+    let dir = statSync4(root).isDirectory() ? root : dirname6(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);
+      const parent = dirname6(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -5060,7 +6113,7 @@ function readPackageVersion(root) {
 
 // src/detectors/dAppI18n.ts
 import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
-import { dirname as dirname6, join as join11 } from "path";
+import { dirname as dirname7, join as join11 } from "path";
 function flattenKeys(obj, prefix = "") {
   if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
     return prefix ? [prefix] : [];
@@ -5107,7 +6160,7 @@ var dAppI18n = {
         `DAppI18n key-diff control FAILED: detectsGap=${control.detectsGap} detectsComplete=${control.detectsComplete} \u2014 matcher broken, verdict untrustworthy`
       );
     }
-    const root = tree.packageJson ? dirname6(tree.packageJson.path) : tree.root;
+    const root = tree.packageJson ? dirname7(tree.packageJson.path) : tree.root;
     const i18nDir = join11(root, "i18n");
     const enPath = join11(i18nDir, "en.json");
     const frPath = join11(i18nDir, "fr.json");
@@ -5980,7 +7033,7 @@ var dExt4 = {
 
 // src/detectors/dExt5.ts
 import { existsSync as existsSync12 } from "fs";
-import { dirname as dirname7, join as join14 } from "path";
+import { dirname as dirname8, join as join14 } from "path";
 function nonEmptyString(v) {
   return typeof v === "string" && v.trim().length > 0;
 }
@@ -6017,7 +7070,7 @@ var dExt5 = {
     }
     for (const manifestPath2 of manifests) {
       const shortPath = manifestPath2.split("/").slice(-2).join("/");
-      const root = dirname7(manifestPath2);
+      const root = dirname8(manifestPath2);
       const cannotRead = (reason) => ({
         id: this.id,
         anchor: shortPath,
@@ -6084,7 +7137,7 @@ var dExt5 = {
 
 // src/detectors/dExt7.ts
 import { existsSync as existsSync13 } from "fs";
-import { dirname as dirname8, join as join15 } from "path";
+import { dirname as dirname9, join as join15 } from "path";
 var ABSENCE_FLAG_FIELDS = [
   "extensionAbsent",
   "extension_absent",
@@ -6148,7 +7201,7 @@ var dExt7 = {
     const unreadable = [];
     const decided = (() => {
       for (const manifestPath2 of manifests) {
-        const extDir = dirname8(manifestPath2);
+        const extDir = dirname9(manifestPath2);
         const extLabel = extDir.split("/").pop() ?? extDir;
         const evalsPath = join15(extDir, "evals", "evals.json");
         const shortPath = `${extLabel}/evals/evals.json`;
@@ -6217,7 +7270,7 @@ var dExt7 = {
 
 // src/detectors/dExt8.ts
 import { existsSync as existsSync14 } from "fs";
-import { dirname as dirname9, join as join16 } from "path";
+import { dirname as dirname10, join as join16 } 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() {
@@ -6249,7 +7302,7 @@ var dExt8 = {
     let finding;
     let judgedConforming = 0;
     for (const manifestPath2 of manifests) {
-      const extDir = dirname9(manifestPath2);
+      const extDir = dirname10(manifestPath2);
       const extLabel = extDir.split("/").pop() ?? extDir;
       const pkgPath = join16(extDir, "package.json");
       const shortPkgPath = `${extLabel}/package.json`;
@@ -6805,6 +7858,50 @@ function collectLogCalls(file) {
   }
   return { calls, unbalanced };
 }
+var LITERAL_VALUE_RE = /^\s*(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`[^`$\\]*`|-?\d[\d_.]*)\s*[;,)]?\s*$/;
+function codeLines(tree) {
+  const out = [];
+  for (const file of tree.files) for (const l of file.lines) if (!l.comment) out.push(l.raw);
+  return out;
+}
+var esc = (x) => x.replace(/[$]/g, "\\$&");
+function resolvesToLiteral(tree, path) {
+  const lines = codeLines(tree);
+  const plainLiteral = (name) => {
+    const decl = new RegExp(`\\b(?:const|let|var)\\s+${esc(name)}\\s*(?::[^=]+)?=\\s*(.*)$`);
+    const found = lines.map((l) => l.match(decl)).filter((m) => m !== null);
+    if (found.length !== 1 || !LITERAL_VALUE_RE.test(found[0][1])) return false;
+    const param = new RegExp(`[(,]\\s*${esc(name)}\\s*[:,)=?]|\\bfunction\\s+${esc(name)}\\b`);
+    return !lines.some((l) => param.test(l));
+  };
+  if (/[()]/.test(path)) return false;
+  if (!path.includes(".")) return plainLiteral(path);
+  const prop = path.split(".").pop() ?? "";
+  const def = new RegExp(`(?:^|[\\s{,])${esc(prop)}\\s*:\\s*([^,}\\n]+)`);
+  const shorthand = new RegExp(`[{,]\\s*${esc(prop)}\\s*[,}]`);
+  const defs = lines.map((l) => l.match(def)).filter((m) => m !== null);
+  if (defs.length === 0 || lines.some((l) => shorthand.test(l))) return false;
+  return defs.every((m) => {
+    const v = m[1].trim();
+    return LITERAL_VALUE_RE.test(v) || /^[A-Za-z_$][\w$]*$/.test(v) && plainLiteral(v);
+  });
+}
+function referenceHits(tree, refs) {
+  const out = [];
+  for (const m of refs.matchAll(/[A-Za-z_$][\w$]*(?:\??\.[A-Za-z_$][\w$]*)*\s*\(?/g)) {
+    const isCall = m[0].trimEnd().endsWith("(");
+    const path = m[0].replace(/\s*\(?$/, "").replace(/\?/g, "");
+    const form = SECRET_RE.test(path) ? "A" : PII_RE.test(path) ? "C" : INTERNAL_RE.test(path) ? "D" : null;
+    if (form) out.push({ form, path, resolved: !isCall && resolvesToLiteral(tree, path) });
+  }
+  return out;
+}
+var FORM_TEXT = {
+  A: "log call references a secret-like identifier -> never log secrets; redact before logging",
+  C: "log call references a PII-shaped identifier -> never log PII; redact before logging",
+  D: "log call references an internal-infrastructure identifier -> never log internal system detail; redact before logging",
+  B: "raw error.stack serialized into a client-facing response -> return an McpError message, never the raw stack"
+};
 var PIN10 = "a74a042b53c71a095ab88b3073bd47728eeda814";
 var dServer6 = {
   id: "DServer6 secret-hygiene",
@@ -6832,8 +7929,15 @@ var dServer6 = {
         `DServer6 stack control FAILED: /${controls.stack.pattern}/ accept(\`${STACK_POSITIVE}\`)=${controls.stack.positive} reject(\`${STACK_NEGATIVE}\`)=${!controls.stack.negative} \u2014 matcher broken, verdict untrustworthy`
       );
     }
+    if (!LITERAL_VALUE_RE.test('"0.0.0.0";') || LITERAL_VALUE_RE.test("os.hostname();")) {
+      throw new Error(
+        "DServer6 literal-value control FAILED: must accept a string literal and reject a call \u2014 verdict untrustworthy"
+      );
+    }
     const unreadable = [];
     const decided = (() => {
+      const findings = [];
+      const resolved = [];
       for (const file of tree.files) {
         const { calls, unbalanced } = collectLogCalls(file);
         for (const anchor of unbalanced) {
@@ -6850,30 +7954,20 @@ var dServer6 = {
             });
             continue;
           }
-          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 D \u2014 log call references an internal-infrastructure identifier (positive-control OK) -> never log internal system detail; redact before logging (C-6)"
-            };
+          const hits = referenceHits(tree, referencedIdentifiers(call.argText));
+          for (const form of ["A", "C", "D"]) {
+            const mine = hits.filter((h) => h.form === form);
+            if (mine.length === 0) continue;
+            const open = mine.filter((h) => !h.resolved);
+            if (open.length === 0) {
+              resolved.push(`${call.anchor} (${mine.map((h) => h.path).join(", ")})`);
+              continue;
+            }
+            findings.push({
+              site: call.anchor,
+              form,
+              note: `identifier-name match, value unresolved: ${open.map((h) => h.path).join(", ")}`
+            });
           }
         }
       }
@@ -6881,20 +7975,29 @@ var dServer6 = {
         for (const line of file.lines) {
           if (line.comment) continue;
           if (STACK_RE.test(line.raw) && CLIENT_SINK_RE.test(line.raw)) {
-            return {
-              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 (C-6)"
-            };
+            findings.push({
+              site: `${file.rel}:${line.n}`,
+              form: "B",
+              note: "client-facing stack"
+            });
           }
         }
       }
+      if (findings.length > 0) {
+        const forms = [...new Set(findings.map((f) => f.form))].sort();
+        const sites = findings.map((f) => `${f.site} [Form ${f.form}, ${f.note}]`).join("; ");
+        return {
+          id: this.id,
+          anchor: findings[0].site,
+          state: "non-conforming",
+          verdict: `${findings.length} site(s) (positive-control OK): ${sites}. ${forms.map((f) => `Form ${f} \u2014 ${FORM_TEXT[f]}`).join("; ")} (C-6)${resolved.length > 0 ? `; not counted, value is a literal constant: ${resolved.join("; ")}` : ""}`
+        };
+      }
       return {
         id: this.id,
         anchor: tree.files.length > 0 ? `${tree.files[0].rel}:1` : tree.root,
         state: "present",
-        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)."
+        verdict: `no secret/PII/internal-detail referenced in any log call; no raw error.stack exposed to the client (all positive-controls OK)${resolved.length > 0 ? `; ${resolved.length} name match(es) resolved to a literal constant and not counted: ${resolved.join("; ")}` : ""}. Logging-sink configuration and explicit-activation-only diagnostic mode are the gate/runtime half, out of static scope (declared).`
       };
     })();
     return settle(this.id, decided, unreadable);
@@ -7050,7 +8153,7 @@ var PRM_ROUTE_RE = /(?:app|router|server)\.(?:get|route|all)\s*\(\s*["'`][^"'`]*
 var CLERK_RE = /clerk/i;
 var AS_DISCOVERY_RE = /authorizationServers|authorization_servers|openid-configuration|oauth-authorization-server/i;
 var JWKS_RE = /jwks|createRemoteJWKSet|createLocalJWKSet/i;
-var RS256_RE = /RS256|jwtVerify|verifyMcpBearer|verifyBearer/;
+var RS256_RE = /RS256|jwtVerify|verifyMcpBearer|verifyBearer|verifyMcpAccessToken/;
 var AUDIENCE_RE = /audience|\baud\b/i;
 var ISSUER_RE = /issuer/i;
 var REUSE_RE = /@vantageos\/cloud-identity/;
@@ -7084,13 +8187,163 @@ var CONTROLS4 = [
     negative: 'from "@vantageos/other-kit"'
   }
 ];
+var DELEGATING_FNS = ["unauthorizedChallenge", "verifyMcpAccessToken"];
+var KIT_IMPORT_RE2 = /import\s+(?:type\s+)?\{([^}]*)\}\s*from\s*["']@vantageos\/cloud-identity(?:\/resource-server)?["']/g;
+function delegatingLocals(text) {
+  const out = [];
+  for (const m of text.matchAll(KIT_IMPORT_RE2)) {
+    for (const part of m[1].split(",")) {
+      const spec = part.trim().replace(/^type\s+/, "");
+      if (!spec) continue;
+      const [imported, local] = spec.split(/\s+as\s+/).map((x) => x.trim());
+      if (DELEGATING_FNS.includes(imported)) out.push(local ?? imported);
+    }
+  }
+  return out;
+}
+var PRM_PATH_LITERAL = ".well-known/oauth-protected-resource";
+function prmRouteViaConstant(tree) {
+  for (const file of tree.files) {
+    const text = file.lines.filter((l) => !l.comment).map((l) => l.raw).join("\n");
+    if (!text.includes(PRM_PATH_LITERAL)) continue;
+    const holders = /* @__PURE__ */ new Set();
+    const decl = /\bconst\s+([A-Za-z_$][\w$]*)\s*(?::[^=\n]+)?=\s*(\[[^\]]*\]|"[^"\n]*"|'[^'\n]*'|`[^`]*`)/g;
+    for (const m of text.matchAll(decl)) if (m[2].includes(PRM_PATH_LITERAL)) holders.add(m[1]);
+    if (holders.size === 0) continue;
+    const names = new Set(holders);
+    const loop = /\bfor\s*\(\s*(?:const|let)\s+([A-Za-z_$][\w$]*)\s+of\s+([A-Za-z_$][\w$]*)\s*\)/g;
+    for (const m of text.matchAll(loop)) if (holders.has(m[2])) names.add(m[1]);
+    const route = /\b(?:app|router|server)\.(?:get|route|all)\s*\(\s*([A-Za-z_$][\w$]*)\s*,/g;
+    for (const m of text.matchAll(route)) if (names.has(m[1])) return true;
+  }
+  return false;
+}
+var FORWARD_HEADER_LINE_RE = /WWW-Authenticate[^\n]*\.headers\b|\bheaders\s*:\s*[\w$.]+\.headers\b/i;
+var FORWARD_STATUS_RE = /\bstatus\s*:\s*[\w$.]+\.status\b|[\w$]+\.status\b/;
+function challengeForwarded(tree) {
+  for (const file of tree.files) {
+    const code = file.lines.filter((l) => !l.comment);
+    const text = code.map((l) => l.raw).join("\n");
+    if (!FORWARD_STATUS_RE.test(text)) continue;
+    const hit = code.find((l) => FORWARD_HEADER_LINE_RE.test(l.raw));
+    if (hit) return `${file.rel}:${hit.n}`;
+  }
+  return null;
+}
+function findDelegation(tree) {
+  let call = null;
+  for (const file of tree.files) {
+    const text = file.lines.filter((l) => !l.comment).map((l) => l.raw).join("\n");
+    const locals = delegatingLocals(text);
+    if (locals.length === 0) continue;
+    for (const line of file.lines) {
+      if (line.comment || /^\s*(?:import\b|\}\s*from\b)/.test(line.raw)) continue;
+      if (locals.some((n) => new RegExp(`\\b${n}\\s*\\(`).test(line.raw))) {
+        call = `${file.rel}:${line.n}`;
+        break;
+      }
+    }
+    if (call) break;
+  }
+  if (!call) return null;
+  const fwd = challengeForwarded(tree);
+  return { anchor: fwd ?? call, forwarded: fwd !== null };
+}
+var IDENTITY_PKG = "@vantageos/cloud-identity";
+var DEPRECATED_AUTH_PKG = "@vantageos/mcp-auth-kit";
+var SHIPPED_DEP_KEYS = ["dependencies", "peerDependencies", "optionalDependencies"];
+var IDENTITY_FLOOR = [0, 15, 0];
+function lowestAdmissible(range) {
+  const alts = range.split("||").map((a) => a.trim());
+  let lowest = null;
+  for (const alt of alts) {
+    let bound = null;
+    for (const tok of alt.split(/\s+/).filter(Boolean)) {
+      const m = tok.match(
+        /^(?:[\^~]|>=|>|=)?v?(\d+)(?:\.(\d+|x|\*))?(?:\.(\d+|x|\*))?(?:[-+].*)?$/
+      );
+      if (!m) {
+        if (/^<=?/.test(tok)) continue;
+        return null;
+      }
+      const t = [
+        Number(m[1]),
+        m[2] && /^\d+$/.test(m[2]) ? Number(m[2]) : 0,
+        m[3] && /^\d+$/.test(m[3]) ? Number(m[3]) : 0
+      ];
+      if (!bound || cmp(t, bound) > 0) bound = t;
+    }
+    if (!bound) return null;
+    if (!lowest || cmp(bound, lowest) < 0) lowest = bound;
+  }
+  return lowest;
+}
+function cmp(a, b) {
+  for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] - b[i];
+  return 0;
+}
+function shippedDep(pkg, name) {
+  for (const key of SHIPPED_DEP_KEYS) {
+    const deps = pkg[key];
+    if (deps && typeof deps === "object") {
+      const v = deps[name];
+      if (typeof v === "string") return { key, range: v };
+    }
+  }
+  return null;
+}
+function packageRule(tree, id) {
+  const pj = tree.packageJson;
+  if (!pj || pj.unreadable) return null;
+  const anchor = pj.path.split("/").slice(-2).join("/");
+  const kit = shippedDep(pj.json, DEPRECATED_AUTH_PKG);
+  if (kit) {
+    return {
+      id,
+      anchor,
+      state: "non-conforming",
+      verdict: `package depends on ${DEPRECATED_AUTH_PKG} (${kit.key}: "${kit.range}") \u2014 deprecated -> remove it; ${IDENTITY_PKG} >= 0.15.0 is the only identity package (Server Rule 14 / S-5)`
+    };
+  }
+  const ci = shippedDep(pj.json, IDENTITY_PKG);
+  if (!ci) return null;
+  const floor = lowestAdmissible(ci.range);
+  if (!floor) {
+    const reason = `${IDENTITY_PKG} is declared as "${ci.range}" (${ci.key}), whose lowest admissible version cannot be read \u2014 the >= 0.15.0 floor is undecidable (Server Rule 14 / S-5)`;
+    return { id, anchor, state: "could-not-judge", reason, verdict: `could not judge: ${reason}` };
+  }
+  if (cmp(floor, IDENTITY_FLOOR) < 0) {
+    return {
+      id,
+      anchor,
+      state: "non-conforming",
+      verdict: `${IDENTITY_PKG} is declared as "${ci.range}" (${ci.key}), admitting ${floor.join(".")} \u2014 below the 0.15.0 floor of the resource-server entry point -> raise the range to >= 0.15.0 (Server Rule 14 / S-5)`
+    };
+  }
+  return null;
+}
 function dServer14PositiveControls() {
-  return CONTROLS4.map((c) => ({
+  const base = CONTROLS4.map((c) => ({
     key: c.key,
     pattern: c.re.source,
     positive: c.re.test(c.positive),
     negative: c.re.test(c.negative)
   }));
+  base.push({
+    key: "dependency-floor",
+    pattern: "lowestAdmissible",
+    positive: lowestAdmissible("^0.14.2")?.join(".") === "0.14.2" && lowestAdmissible(">=0.15.0 <1")?.join(".") === "0.15.0",
+    negative: lowestAdmissible("latest") !== null
+  });
+  base.push({
+    key: "delegation",
+    pattern: KIT_IMPORT_RE2.source,
+    positive: delegatingLocals(
+      'import {\n  verifyMcpAccessToken as v,\n} from "@vantageos/cloud-identity/resource-server";'
+    ).join() === "v",
+    negative: delegatingLocals('import { verifyMcpAccessToken } from "some-other-kit";').length > 0
+  });
+  return base;
 }
 function codeBlob(tree) {
   const parts = [];
@@ -7133,6 +8386,8 @@ var dServer14 = {
         );
       }
     }
+    const pkgVerdict = packageRule(tree, this.id);
+    if (pkgVerdict) return pkgVerdict;
     const blob = codeBlob(tree);
     const surfacePresent = WWW_AUTH_RE.test(blob) || PRM_ROUTE_RE.test(blob) || JWKS_RE.test(blob) || CLERK_RE.test(blob) || REUSE_RE.test(blob);
     if (!surfacePresent) {
@@ -7143,6 +8398,17 @@ var dServer14 = {
         verdict: "no OAuth 2.1 resource-server surface detected (n/a for Server Rule 14)"
       };
     }
+    const delegation = findDelegation(tree);
+    if (delegation && !delegation.forwarded && !CHALLENGE_PARAM_RE.test(blob)) {
+      const reason = `${delegation.anchor} calls a challenge-returning function of @vantageos/cloud-identity but no \`<result>.status\` / \`<result>.headers\` forwarding is readable in that file \u2014 whether the 401 + WWW-Authenticate reaches the client is unverifiable statically (Server Rule 14, Element 1)`;
+      return {
+        id: this.id,
+        anchor: delegation.anchor,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
     if (!CHALLENGE_PARAM_RE.test(blob)) {
       const computedAnchor = firstAnchor(tree, COMPUTED_CHALLENGE_RE);
       if (computedAnchor) {
@@ -7159,13 +8425,13 @@ var dServer14 = {
     const elements = [
       {
         name: "Element 1 CHALLENGE (401 + WWW-Authenticate: Bearer \u2026 resource_metadata=\u2026)",
-        present: WWW_AUTH_RE.test(blob) && CHALLENGE_PARAM_RE.test(blob) && STATUS_401_RE.test(blob) && BEARER_RE.test(blob),
+        present: Boolean(delegation?.forwarded) || WWW_AUTH_RE.test(blob) && CHALLENGE_PARAM_RE.test(blob) && STATUS_401_RE.test(blob) && BEARER_RE.test(blob),
         probe: WWW_AUTH_RE,
         fix: "answer 401 with WWW-Authenticate: Bearer \u2026 resource_metadata=\u2026 (RFC 9728)"
       },
       {
         name: "Element 2 PRM ROUTE (/.well-known/oauth-protected-resource)",
-        present: PRM_ROUTE_RE.test(blob),
+        present: PRM_ROUTE_RE.test(blob) || prmRouteViaConstant(tree),
         probe: PRM_ROUTE_RE,
         fix: "serve /.well-known/oauth-protected-resource (Protected Resource Metadata, RFC 9728)"
       },
@@ -7215,6 +8481,436 @@ var dServer14 = {
   }
 };
 
+// src/detectors/s28-claim-forwarded.ts
+import { existsSync as existsSync15, readFileSync as readFileSync11, readdirSync as readdirSync7, statSync as statSync8 } from "fs";
+import { dirname as dirname11, join as join18, relative as relative5 } from "path";
+var PIN11 = "bacc54a53d5f6f9f20e5254908e2b46807902faa";
+var CLAIM_TOKEN = /\bverified(?:Org|Person)\b/;
+var ANY_CLAIM = /\bverified(?:Actor|Org|Person)\b/g;
+var CALL_RE = /\b([A-Za-z_$][\w$]*)\s*\.\s*(query|mutation|action)\s*\(/g;
+var GUARD_RE = /\b(?:unresolved\w*Denial|requireVerified\w+|requireClaim\w*)\s*\(|verified-org-unresolved/;
+var FLEET_WIDE = /fleet-wide:\s*\S[^\n]{7,}/;
+var SCOPE_MARKERS = /\bwithOrgScope\b|\brequireAuthenticatedCaller\b|\bresolveInboxReader\b|\bresolveVerified\w*\b|\brequireScope\b|\bgetUserIdentity\b|\bisMaster\b|\bscope\b/;
+var ACTOR_SET_RE = /\bconst\s+(VERIFIED_\w*DOORS)\b[^=]*=\s*new\s+Set\s*(?:<[^>]*>)?\s*\(\s*\[([\s\S]*?)\]\s*\)/;
+function masked(file) {
+  const out = [];
+  for (const line of file.lines) {
+    let row = "";
+    for (let c = 0; c < line.raw.length; c++) {
+      const ch = line.raw[c];
+      row += ch === " " || ch === "	" || ch === "\r" || isCodeAt(file, line.n, c) ? ch : " ";
+    }
+    out.push(row);
+  }
+  return out.join("\n");
+}
+function rawText(file) {
+  return file.lines.map((l) => l.raw).join("\n");
+}
+function lineAt(text, offset) {
+  let n = 1;
+  for (let i = 0; i < offset && i < text.length; i++) if (text.charCodeAt(i) === 10) n++;
+  return n;
+}
+var OPEN = { "(": ")", "[": "]", "{": "}" };
+function matchClose(m, open) {
+  const stack = [];
+  for (let i = open; i < m.length; i++) {
+    const ch = m[i];
+    if (OPEN[ch] !== void 0) stack.push(OPEN[ch]);
+    else if (ch === ")" || ch === "]" || ch === "}") {
+      if (stack.pop() !== ch) return -1;
+      if (stack.length === 0) return i;
+    }
+  }
+  return -1;
+}
+function splitTop(m, from, to) {
+  const parts = [];
+  let depth = 0;
+  let start = from;
+  for (let i = from; i < to; i++) {
+    const ch = m[i];
+    if (OPEN[ch] !== void 0) depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") depth--;
+    else if (ch === "," && depth === 0) {
+      parts.push([start, i]);
+      start = i + 1;
+    }
+  }
+  if (start < to && m.slice(start, to).trim() !== "") parts.push([start, to]);
+  return parts;
+}
+function listTs(dir, out = []) {
+  let names;
+  try {
+    names = readdirSync7(dir);
+  } catch {
+    return out;
+  }
+  for (const n of names) {
+    if (n === "node_modules" || n === "_generated" || n === "__tests__") continue;
+    const p = join18(dir, n);
+    let st;
+    try {
+      st = statSync8(p);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) listTs(p, out);
+    else if (n.endsWith(".ts") && !n.endsWith(".test.ts") && !n.endsWith(".d.ts")) out.push(p);
+  }
+  return out;
+}
+function discoverBackend(root) {
+  let dir = root;
+  try {
+    if (!statSync8(root).isDirectory()) dir = dirname11(root);
+  } catch {
+    return void 0;
+  }
+  for (let up = 0; up < 5; up++) {
+    const cand = join18(dir, "convex");
+    if (existsSync15(join18(cand, "schema.ts"))) return cand;
+    const parent = dirname11(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+function readDoors(backendRoot) {
+  const doors = /* @__PURE__ */ new Map();
+  for (const path of listTs(backendRoot)) {
+    let text;
+    try {
+      text = readFileSync11(path, "utf8");
+    } catch {
+      continue;
+    }
+    const file = {
+      path,
+      rel: relative5(backendRoot, path),
+      lines: text.split("\n").map((raw, i) => ({ n: i + 1, raw, comment: false }))
+    };
+    const m = masked(file);
+    const module = relative5(backendRoot, path).replace(/\.ts$/, "").split("\\").join("/");
+    const re = /\bexport\s+const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:query|mutation|action)\s*\(/g;
+    for (let hit = re.exec(m); hit; hit = re.exec(m)) {
+      const open = hit.index + hit[0].length - 1;
+      const close = matchClose(m, open);
+      if (close < 0) continue;
+      let start = hit.index;
+      const lines = text.slice(0, start).split("\n");
+      let k = lines.length - 2;
+      while (k >= 0 && (lines[k].trim() === "" || /^\s*(\/\/|\/\*|\*)/.test(lines[k])) && lines.length - 2 - k < 60)
+        k--;
+      start = lines.slice(0, k + 1).join("\n").length;
+      const region = text.slice(start, close + 1);
+      const mRegion = m.slice(hit.index, close + 1);
+      const claims = [];
+      const am = /\bargs\s*:\s*/.exec(mRegion);
+      if (am) {
+        const at = hit.index + am.index + am[0].length;
+        let argsText = "";
+        if (m[at] === "{") argsText = text.slice(at, matchClose(m, at) + 1);
+        else {
+          const id = /^[A-Za-z_$][\w$]*/.exec(m.slice(at));
+          if (id) {
+            const dm = new RegExp(`\\bconst\\s+${id[0]}\\b[^=]*=\\s*`).exec(m);
+            if (dm) {
+              let p = dm.index + dm[0].length;
+              if (m.slice(p).startsWith("v.object(")) p += "v.object(".length;
+              if (m[p] === "{") argsText = text.slice(p, matchClose(m, p) + 1);
+            }
+          }
+        }
+        for (const c of argsText.match(ANY_CLAIM) ?? []) if (!claims.includes(c)) claims.push(c);
+      }
+      let exit;
+      if (/\brequireServiceAccount\b/.test(mRegion))
+        exit = "service-account-only (requireServiceAccount)";
+      else if (/\brequireResolvedCaller\s*\([^)]*masterOnly[^)]*mcpBoundOnly|\brequireResolvedCaller\s*\([^)]*mcpBoundOnly[^)]*masterOnly/s.test(
+        mRegion
+      ))
+        exit = "service-account-only (requireResolvedCaller masterOnly+mcpBoundOnly)";
+      else {
+        const fw = FLEET_WIDE.exec(region);
+        if (fw) exit = `fleet-wide declaration (${fw[0].slice(11).trim().slice(0, 80)})`;
+      }
+      doors.set(`${module}:${hit[1]}`, {
+        claims,
+        exit,
+        resolvesCaller: SCOPE_MARKERS.test(mRegion)
+      });
+    }
+  }
+  return doors;
+}
+function definitionOf(name, files) {
+  const esc2 = name.replace(/\$/g, "\\$");
+  const re = new RegExp(`(?:\\b(?:const|let|var)\\s+${esc2}\\b|\\bfunction\\s+${esc2}\\b)`);
+  for (const f of files) {
+    const hit = re.exec(f.m);
+    if (!hit) continue;
+    let depth = 0;
+    for (let i = hit.index + hit[0].length; i < f.m.length; i++) {
+      const ch = f.m[i];
+      if (OPEN[ch] !== void 0) {
+        depth++;
+      } else if (ch === ")" || ch === "]" || ch === "}") {
+        depth--;
+        if (depth === 0 && ch === "}" && /\bfunction\b/.test(hit[0]))
+          return { mask: f.m.slice(hit.index, i + 1) };
+      } else if (ch === ";" && depth === 0 && !/\bfunction\b/.test(hit[0])) {
+        return { mask: f.m.slice(hit.index, i + 1) };
+      }
+      if (depth < 0) break;
+    }
+    return { mask: f.m.slice(hit.index, Math.min(f.m.length, hit.index + 1500)) };
+  }
+  return void 0;
+}
+function readHelper(name, files, seen = /* @__PURE__ */ new Set(), depth = 0) {
+  if (seen.has(name) || depth > 3) return { forwards: false, optional: false };
+  seen.add(name);
+  const def = definitionOf(name, files);
+  if (!def) return { forwards: false, optional: false };
+  let forwards = CLAIM_TOKEN.test(def.mask);
+  const optional = /:\s*\{\s*\}|return\s*\{\s*\}|\?\?\s*\{\s*\}/.test(def.mask);
+  if (!forwards) {
+    for (const c of def.mask.matchAll(/\b([A-Za-z_$][\w$]*)\s*\(/g)) {
+      const sub = readHelper(c[1], files, seen, depth + 1);
+      if (sub.forwards) {
+        forwards = true;
+        break;
+      }
+    }
+  }
+  return { forwards, optional };
+}
+function toolNameBefore(text, offset) {
+  const head = text.slice(0, offset);
+  const open = Math.max(head.lastIndexOf("defineTool("), head.lastIndexOf("registerTool("));
+  if (open >= 0) {
+    const m = /^\s*"([a-z][a-z0-9_]*)",?\s*$/m.exec(head.slice(open));
+    if (m) return { name: m[1], start: open };
+    const r = /registerTool\(\s*"([a-z][a-z0-9_]*)"/.exec(head.slice(open));
+    if (r) return { name: r[1], start: open };
+    return { name: void 0, start: open };
+  }
+  const lines = head.split("\n");
+  const back = Math.max(0, lines.length - 120);
+  return { name: void 0, start: lines.slice(0, back).join("\n").length };
+}
+function scanS28(tree) {
+  const scan = { violate: [], conform: [], cnj: [], calls: 0, backend: void 0 };
+  const backendRoot = tree.backendRoot ?? discoverBackend(tree.root);
+  scan.backend = backendRoot;
+  const doors = backendRoot ? readDoors(backendRoot) : void 0;
+  const files = tree.files.map((f) => ({ f, text: rawText(f), m: masked(f) }));
+  const actorDoors = /* @__PURE__ */ new Set();
+  for (const { text } of files) {
+    const hit = ACTOR_SET_RE.exec(text);
+    if (hit) for (const s of hit[2].matchAll(/["'`]([\w/]+:[\w]+)["'`]/g)) actorDoors.add(s[1]);
+  }
+  for (const { f, text, m } of files) {
+    for (let hit = CALL_RE.exec(m); hit; hit = CALL_RE.exec(m)) {
+      const recv = hit[1];
+      if (!/convex|client/i.test(recv)) continue;
+      const open = hit.index + hit[0].length - 1;
+      const close = matchClose(m, open);
+      if (close < 0) continue;
+      scan.calls++;
+      const line = lineAt(text, hit.index);
+      const tool = toolNameBefore(text, hit.index);
+      const parts = splitTop(m, open + 1, close);
+      let door;
+      if (parts[0]) {
+        const rawFirst = text.slice(parts[0][0], parts[0][1]);
+        const lit = /^\s*(?:\/\/[^\n]*\n\s*)*["'`]([\w/]+:[\w]+)["'`]/.exec(rawFirst);
+        const ref = /^\s*(?:api|internal)\.([\w]+)\.([\w]+)/.exec(rawFirst);
+        if (lit) door = lit[1];
+        else if (ref) door = `${ref[1]}:${ref[2]}`;
+      }
+      const site = (note) => ({
+        file: f.rel,
+        line,
+        door: door ?? "?",
+        tool: tool.name,
+        note
+      });
+      if (door === void 0) {
+        scan.cnj.push(
+          site(
+            "the door is named by an expression the scan cannot resolve (not statically resolvable)"
+          )
+        );
+        continue;
+      }
+      const argText = parts[1] ? m.slice(parts[1][0], parts[1][1]) : "";
+      const region = m.slice(tool.start, hit.index);
+      const regionRaw = text.slice(tool.start, hit.index);
+      const guard = GUARD_RE.test(region) || GUARD_RE.test(regionRaw);
+      let direct = CLAIM_TOKEN.test(argText);
+      let viaHelper;
+      let virtual = argText;
+      const bare = /^\s*([A-Za-z_$][\w$]*)\s*$/.exec(argText);
+      if (bare && !direct) {
+        const v = bare[1].replace(/\$/g, "\\$");
+        const pieces = [];
+        for (const a of region.matchAll(new RegExp(`Object\\.assign\\s*\\(\\s*${v}\\s*,`, "g"))) {
+          const o = a.index + a[0].length - 1;
+          const c = matchClose(region, region.lastIndexOf("(", o));
+          pieces.push(region.slice(o, c < 0 ? o + 400 : c));
+        }
+        for (const a of region.matchAll(
+          new RegExp(`\\b${v}\\.verified(?:Org|Person|Actor)\\b`, "g")
+        ))
+          pieces.push(a[0]);
+        const decl = new RegExp(`\\b(?:const|let)\\s+${v}\\b[^=]*=\\s*\\{`).exec(region);
+        if (decl) {
+          const o = decl.index + decl[0].length - 1;
+          const c = matchClose(region, o);
+          pieces.push(region.slice(o, c < 0 ? o + 600 : c + 1));
+        }
+        virtual = pieces.join("\n");
+        direct = CLAIM_TOKEN.test(virtual);
+      }
+      if (!direct) {
+        for (const sp of virtual.matchAll(/\.\.\.\s*([A-Za-z_$][\w$]*)/g)) {
+          const h = readHelper(sp[1], files);
+          if (h.forwards) {
+            viaHelper = h;
+            break;
+          }
+        }
+        if (!viaHelper) {
+          for (const sp of virtual.matchAll(/\b([A-Za-z_$][\w$]*)\s*\(\s*\)/g)) {
+            const h = readHelper(sp[1], files);
+            if (h.forwards) {
+              viaHelper = h;
+              break;
+            }
+          }
+        }
+      }
+      if (direct) {
+        scan.conform.push(site("forwards the verified claim in the call"));
+        continue;
+      }
+      if (viaHelper) {
+        if (viaHelper.optional && !guard) {
+          scan.violate.push(
+            site(
+              "forwards its claim through an optional helper (it returns {} when the bearer holds none) and no refusal precedes the call in the handler: a bearer with no resolvable organisation is sent claimless"
+            )
+          );
+        } else {
+          scan.conform.push(
+            site(
+              viaHelper.optional ? "forwards the verified claim through a helper and refuses before the call when it holds none" : "forwards the verified claim through a helper"
+            )
+          );
+        }
+        continue;
+      }
+      if (!doors) {
+        scan.cnj.push(
+          site(
+            "forwards no verified claim and no backend source was found above the scanned tree (no convex/ with a schema.ts, and no backend root given): whether the door is an exit cannot be read"
+          )
+        );
+        continue;
+      }
+      const info = doors.get(door);
+      if (!info) {
+        scan.cnj.push(
+          site(
+            `forwards no verified claim and the door ${door} is not defined in the supplied backend (${backendRoot})`
+          )
+        );
+        continue;
+      }
+      if (info.exit) {
+        scan.conform.push(site(`needs no claim: the door is ${info.exit}`));
+        continue;
+      }
+      if (!info.resolvesCaller) {
+        scan.cnj.push(
+          site(
+            `forwards no verified claim and the door ${door} shows no caller resolution in its own source (its scope comes from a helper or a run call that this scan does not follow)`
+          )
+        );
+        continue;
+      }
+      const accepts = info.claims.length > 0 ? `the door accepts ${info.claims.join(", ")} and the tool omits it` : "the door accepts no claim argument, so R-54 must add one before the tool can forward it";
+      const actorNote = actorDoors.has(door) ? "; verifiedActor is added by the wrapped client only for a bearer that resolved an agent, and a bearer that resolved no agent (a seat or person token, an org-level token) is sent claimless" : "";
+      scan.violate.push(site(`forwards no verified claim \u2014 ${accepts}${actorNote}`));
+    }
+  }
+  return scan;
+}
+function fmt(s) {
+  return `${s.file}:${s.line} ${s.door} ${s.tool ? `[${s.tool}] ` : ""}(${s.note})`;
+}
+var S28_ID = "S-28 claim-forwarded";
+var s28ClaimForwarded = {
+  id: S28_ID,
+  rule: "S-28",
+  pin: PIN11,
+  run(tree) {
+    const s = scanS28(tree);
+    const breakdown = `[conform=${s.conform.length} non-conforming=${s.violate.length} could-not-judge=${s.cnj.length}]`;
+    const list = (xs) => xs.slice(0, 5).map(fmt).join("; ");
+    if (s.violate.length > 0) {
+      const first = s.violate[0];
+      return {
+        id: S28_ID,
+        anchor: `${first.file}:${first.line}`,
+        state: "non-conforming",
+        verdict: `S-28: ${s.violate.length} backend call(s) VIOLATE (a tool forwards the verified claim of its caller to every backend door it calls, and refuses when it has none). ${breakdown} Violations: ${list(s.violate)}${s.violate.length > 5 ? `; +${s.violate.length - 5} more` : ""}.${s.cnj.length ? ` could-not-judge calls (a verdict is owed): ${list(s.cnj)}.` : ""}`
+      };
+    }
+    if (s.cnj.length > 0) {
+      const reason2 = `S-28: ${s.cnj.length} backend call(s) could not be judged \u2014 ${list(s.cnj)}. This is NOT a clean bill. ${breakdown}`;
+      return {
+        id: S28_ID,
+        anchor: `${s.cnj[0].file}:${s.cnj[0].line}`,
+        state: "could-not-judge",
+        verdict: reason2,
+        reason: reason2
+      };
+    }
+    if (s.conform.length > 0) {
+      return {
+        id: S28_ID,
+        anchor: `${s.conform[0].file}:${s.conform[0].line}`,
+        state: "present",
+        verdict: `S-28: ${s.conform.length} backend call(s) forward the verified claim or call a door that needs none; 0 violations. ${breakdown} Conform: ${list(s.conform)}.`
+      };
+    }
+    const usesBackend = tree.files.some(
+      (f) => f.lines.some((l) => !l.comment && /\bConvexHttpClient\b|from\s+["']convex\//.test(l.raw))
+    );
+    if (!usesBackend) {
+      return {
+        id: S28_ID,
+        anchor: "source:no-backend-client",
+        state: "absent",
+        verdict: `S-28: no Convex client is imported anywhere in the ${tree.files.length} file(s) read; no backend door is called, so there is no claim to forward (rule out of subject).`
+      };
+    }
+    const reason = `S-28: no applicable site \u2014 a Convex client is imported but none of the ${s.calls} <client>.query|mutation|action call(s) read names a door statically. NOT a clean bill.`;
+    return {
+      id: S28_ID,
+      anchor: "source:no-applicable-site",
+      state: "could-not-judge",
+      verdict: reason,
+      reason
+    };
+  }
+};
+
 // src/detectors/index.ts
 var detectors = [
   d2,
@@ -7248,6 +8944,7 @@ var detectors = [
   c22TestRatioGate,
   c25BuildIdentity,
   c26SubpackageLockfile,
+  s28ClaimForwarded,
   dServer2,
   dServer6,
   dDebugOptIn,
@@ -7267,18 +8964,18 @@ var detectors = [
 
 // src/runtime/launch.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync15, readFileSync as readFileSync11, statSync as statSync8 } from "fs";
-import { dirname as dirname10, isAbsolute, join as join18, resolve } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync12, statSync as statSync9 } from "fs";
+import { dirname as dirname12, isAbsolute, join as join19, resolve as resolve2 } from "path";
 function findPackageDir(target) {
   let dir;
   try {
-    dir = statSync8(target).isDirectory() ? target : dirname10(target);
+    dir = statSync9(target).isDirectory() ? target : dirname12(target);
   } catch {
     return null;
   }
   for (let depth = 0; depth < 8; depth++) {
-    if (existsSync15(join18(dir, "package.json"))) return dir;
-    const parent = dirname10(dir);
+    if (existsSync16(join19(dir, "package.json"))) return dir;
+    const parent = dirname12(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -7302,17 +8999,17 @@ function deriveLaunchPlan(target) {
   }
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync11(join18(pkgDir, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync12(join19(pkgDir, "package.json"), "utf8"));
   } catch (err) {
     return {
-      error: `could not parse ${join18(pkgDir, "package.json")}: ${err instanceof Error ? err.message : String(err)}`
+      error: `could not parse ${join19(pkgDir, "package.json")}: ${err instanceof Error ? err.message : String(err)}`
     };
   }
   const bin = firstBinEntry(pkg.bin);
   if (bin) {
     return {
       command: process.execPath,
-      args: [isAbsolute(bin) ? bin : resolve(pkgDir, bin)],
+      args: [isAbsolute(bin) ? bin : resolve2(pkgDir, bin)],
       cwd: pkgDir
     };
   }
@@ -7325,7 +9022,7 @@ function deriveLaunchPlan(target) {
   if (main2) {
     return {
       command: process.execPath,
-      args: [isAbsolute(main2) ? main2 : resolve(pkgDir, main2)],
+      args: [isAbsolute(main2) ? main2 : resolve2(pkgDir, main2)],
       cwd: pkgDir
     };
   }
@@ -7383,10 +9080,10 @@ function readEvalCounts(target) {
   if (!pkgDir) return counts;
   let dir = pkgDir;
   for (let depth = 0; depth < 8; depth++) {
-    const candidate = join18(dir, "evals", "evals.json");
-    if (existsSync15(candidate)) {
+    const candidate = join19(dir, "evals", "evals.json");
+    if (existsSync16(candidate)) {
       try {
-        const parsed = JSON.parse(readFileSync11(candidate, "utf8"));
+        const parsed = JSON.parse(readFileSync12(candidate, "utf8"));
         for (const c of parsed.cases ?? []) {
           if (c && typeof c.tool === "string") counts.set(c.tool, (counts.get(c.tool) ?? 0) + 1);
         }
@@ -7394,7 +9091,7 @@ function readEvalCounts(target) {
       }
       return counts;
     }
-    const parent = dirname10(dir);
+    const parent = dirname12(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -7402,7 +9099,7 @@ function readEvalCounts(target) {
 }
 function statSyncSafe(p) {
   try {
-    return statSync8(p).isDirectory();
+    return statSync9(p).isDirectory();
   } catch {
     return false;
   }
@@ -7525,7 +9222,7 @@ function runDoctor(target, detectorList = detectors, opts = {}) {
 }
 function runDoctorReport(target, detectorList = detectors, opts = {}) {
   const mode = opts.mode ?? "static";
-  const tree = loadTree(target);
+  const tree = loadTree(target, opts.backend);
   const needsRuntime = mode !== "static" && detectorList.some((d) => typeof d.runDynamic === "function");
   const runtime = needsRuntime ? launchAndIntrospect(target) : null;
   const results = [];
@@ -7654,7 +9351,7 @@ function computeExitCode(results) {
   return 0;
 }
 var USAGE = [
-  "usage: mcp-doctor <source-tree-path> [--mode=static|dynamic|both]",
+  "usage: mcp-doctor <source-tree-path> [--mode=static|dynamic|both] [--backend=<convex-dir>]",
   "",
   "  --mode=static   read the tree only (default)",
   "  --mode=dynamic  launch the server and judge what it serves",
@@ -7662,6 +9359,8 @@ var USAGE = [
   "  --local-identity-ceiling=N",
   "                  local identity primitives tolerated before DLocalIdentity",
   "                  fails (default 0)",
+  "  --backend=DIR   the backend source (a convex/ dir) whose door list S-28 reads;",
+  "                  default: the nearest convex/ above the tree",
   "  --version       print the version and exit",
   "  --help          print this and exit",
   "",
@@ -7669,8 +9368,8 @@ var USAGE = [
 ].join("\n");
 function readVersion() {
   try {
-    const here = dirname11(fileURLToPath(import.meta.url));
-    const manifest = JSON.parse(readFileSync12(join19(here, "..", "package.json"), "utf8"));
+    const here = dirname13(fileURLToPath(import.meta.url));
+    const manifest = JSON.parse(readFileSync13(join20(here, "..", "package.json"), "utf8"));
     return manifest.version ?? null;
   } catch {
     return null;
@@ -7692,6 +9391,7 @@ function main() {
     return;
   }
   const modeArg = args.find((a) => a.startsWith("--mode="));
+  const backendArg = args.find((a) => a.startsWith("--backend="));
   const target = args.find((a) => !a.startsWith("--"));
   if (!target) {
     console.error(USAGE);
@@ -7714,7 +9414,11 @@ function main() {
     const ratchet = makeLocalIdentity({ ceiling });
     detectorList = detectors.map((d) => d === localIdentity ? ratchet : d);
   }
-  const { results, skipped } = runDoctorReport(target, detectorList, { mode });
+  const backend = backendArg ? backendArg.slice("--backend=".length) : void 0;
+  const { results, skipped } = runDoctorReport(target, detectorList, {
+    mode,
+    ...backend !== void 0 ? { backend } : {}
+  });
   console.log(renderTable(target, results, skipped));
   process.exitCode = computeExitCode(results);
 }
@@ -7728,7 +9432,7 @@ function isDirectInvocation() {
     return false;
   }
   try {
-    return realpathSync(resolve2(entry)) === selfReal;
+    return realpathSync(resolve3(entry)) === selfReal;
   } catch {
     return false;
   }