@vantageos/mcp-doctor 0.8.0 → 0.8.2

package/dist/doctor.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/doctor.ts
-import { readFileSync as readFileSync17, realpathSync } from "fs";
+import { readFileSync as readFileSync16, realpathSync } from "fs";
 import { dirname as dirname17, join as join27, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/scan.ts
-import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { constants, accessSync, existsSync, readFileSync, readdirSync, statSync } from "fs";
 import { basename, dirname, join, relative, sep } from "path";
 var SKIP_DIR_INFO = {
   node_modules: { reason: "vendored dependencies", authored: false },
@@ -46,11 +46,12 @@ function isCommentLine(raw) {
 }
 var UNSCANNED_RE = /\.(?:m?js|cjs|jsx|mts|cts)$/;
 var NOT_PRODUCT_NAME_RE = /\.d\.[mc]?ts$|\.(?:test|spec)\.[mc]?[jt]sx?$|\.config\.[mc]?[jt]s$|\.min\./;
-function walk(dir, out, onSkip, unscanned = []) {
+function walk(dir, out, onSkip, unscanned = [], seen = { files: 0 }) {
   let entries;
   try {
     entries = readdirSync(dir);
-  } catch {
+  } catch (err) {
+    onSkip(dir, `could not be listed (${fsErrorCode(err)}) \u2014 not read`);
     return;
   }
   for (const name of entries) {
@@ -58,7 +59,8 @@ function walk(dir, out, onSkip, unscanned = []) {
     let st;
     try {
       st = statSync(full);
-    } catch {
+    } catch (err) {
+      onSkip(full, `could not be read (${fsErrorCode(err)}) \u2014 not read`);
       continue;
     }
     if (st.isDirectory()) {
@@ -66,8 +68,21 @@ function walk(dir, out, onSkip, unscanned = []) {
         onSkip(full);
         continue;
       }
-      walk(full, out, onSkip, unscanned);
-    } else if (UNSCANNED_RE.test(name)) {
+      walk(full, out, onSkip, unscanned, seen);
+      continue;
+    }
+    if (!st.isFile()) {
+      onSkip(full, "not a regular file (FIFO, socket or device) \u2014 not read");
+      continue;
+    }
+    try {
+      accessSync(full, constants.R_OK);
+    } catch (err) {
+      onSkip(full, `could not be read (${fsErrorCode(err)}) \u2014 not read`);
+      continue;
+    }
+    seen.files++;
+    if (UNSCANNED_RE.test(name)) {
       if (!NOT_PRODUCT_NAME_RE.test(name)) unscanned.push(full);
     } else if (name.endsWith(".ts") || name.endsWith(".tsx")) {
       if (name.endsWith(".d.ts") || name.endsWith(".test.ts")) continue;
@@ -75,6 +90,22 @@ function walk(dir, out, onSkip, unscanned = []) {
     }
   }
 }
+function fsErrorCode(err) {
+  const code = err?.code;
+  return typeof code === "string" ? code : String(err);
+}
+var SubjectUnreadableError = class extends Error {
+  target;
+  form;
+  constructor(target, form) {
+    super(
+      `mcp-doctor: could not judge ${target} \u2014 ${form}. Nothing was read, so no verdict is given (exit 2).`
+    );
+    this.name = "SubjectUnreadableError";
+    this.target = target;
+    this.form = form;
+  }
+};
 function loadFile(path, root) {
   const raw = readFileSync(path, "utf8");
   const lines = raw.split("\n").map((r, i) => ({ n: i + 1, raw: r, comment: isCommentLine(r) }));
@@ -103,6 +134,9 @@ function findPackageJson(startDir) {
     const candidate = join(dir, "package.json");
     if (existsSync(candidate)) {
       try {
+        if (!statSync(candidate).isFile()) {
+          return { path: candidate, json: {}, unreadable: "not a regular file" };
+        }
         const parsed = JSON.parse(readFileSync(candidate, "utf8"));
         if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
           return { path: candidate, json: {}, unreadable: "not a JSON object" };
@@ -119,16 +153,67 @@ function findPackageJson(startDir) {
   return null;
 }
 function loadTree(root, backendRoot) {
-  const st = statSync(root);
+  let st;
+  try {
+    st = statSync(root);
+  } catch (err) {
+    const code = fsErrorCode(err);
+    throw new SubjectUnreadableError(
+      root,
+      code === "ENOENT" ? "the path does not exist" : `the path cannot be read (${code})`
+    );
+  }
   const baseDir = st.isDirectory() ? root : dirname(root);
   const filePaths = [];
   const tree = { root, files: [], packageJson: null, skippedDirs: [] };
   if (backendRoot !== void 0) tree.backendRoot = backendRoot;
   const unscanned = [];
-  if (st.isDirectory()) walk(root, filePaths, (d) => recordSkip(tree, d, root), unscanned);
-  else if (root.endsWith(".ts") || root.endsWith(".tsx")) filePaths.push(root);
+  if (st.isDirectory()) {
+    let entries;
+    try {
+      entries = readdirSync(root);
+    } catch (err) {
+      throw new SubjectUnreadableError(
+        root,
+        `the directory cannot be listed (${fsErrorCode(err)})`
+      );
+    }
+    if (entries.length === 0) {
+      throw new SubjectUnreadableError(root, "the directory is empty (0 entries)");
+    }
+    const seen = { files: 0 };
+    walk(root, filePaths, (d, reason) => recordSkip(tree, d, root, reason), unscanned, seen);
+    for (const p of filePaths) {
+      try {
+        tree.files.push(loadFile(p, baseDir));
+      } catch (err) {
+        recordSkip(tree, p, root, `could not be read (${fsErrorCode(err)}) \u2014 not read`);
+        seen.files--;
+      }
+    }
+    if (seen.files === 0) {
+      const passed = tree.skippedDirs.map((d) => `${d.path} (${d.reason})`).join(", ");
+      throw new SubjectUnreadableError(
+        root,
+        `the walk reached no readable file (${entries.length} entr${entries.length === 1 ? "y" : "ies"}, none a readable file${passed ? `; passed over: ${passed}` : ""})`
+      );
+    }
+  } else if (st.isFile()) {
+    if (!root.endsWith(".ts") && !root.endsWith(".tsx")) {
+      throw new SubjectUnreadableError(
+        root,
+        "a file the scan does not read: a target is a source directory or a single .ts/.tsx file"
+      );
+    }
+    try {
+      tree.files.push(loadFile(root, baseDir));
+    } catch (err) {
+      throw new SubjectUnreadableError(root, `the file cannot be read (${fsErrorCode(err)})`);
+    }
+  } else {
+    throw new SubjectUnreadableError(root, "neither a directory nor a regular file");
+  }
   tree.unscannedSource = unscanned.map((p) => relative(baseDir, p).split(sep).join("/"));
-  tree.files = filePaths.map((p) => loadFile(p, baseDir));
   tree.packageJson = findPackageJson(baseDir);
   return tree;
 }
@@ -423,7 +508,7 @@ function countInCode(file, line, ch) {
 }
 
 // src/detectors/couldNotJudge.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync2, statSync as statSync2 } from "fs";
 function couldNotJudge(id, anchor, reason, owedVerdict) {
   return {
     id,
@@ -451,6 +536,7 @@ function settle(id, decided, unreadable) {
 function readJsonObject(path) {
   let value;
   try {
+    if (!statSync2(path).isFile()) return null;
     value = JSON.parse(readFileSync2(path, "utf8"));
   } catch {
     return null;
@@ -477,8 +563,194 @@ function guardUnreadablePackageJson(inner, opts) {
   };
 }
 
+// src/detectors/siteScan.ts
+import { constants as constants2, accessSync as accessSync2, existsSync as existsSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { join as join2, relative as relative2, sep as sep2 } from "path";
+function codeSites(tree, re) {
+  const out = [];
+  const g = new RegExp(re.source, re.flags.includes("g") ? re.flags : `${re.flags}g`);
+  for (const file of tree.files) {
+    for (const line of file.lines) {
+      if (line.comment) continue;
+      for (const m of line.raw.matchAll(g)) {
+        const col = m.index ?? 0;
+        if (isCodeAt(file, line.n, col)) {
+          out.push({ file, line, col, match: m, anchor: `${file.rel}:${line.n}` });
+        }
+      }
+    }
+  }
+  return out;
+}
+var uncommentedCache = /* @__PURE__ */ new WeakMap();
+function uncommentedLines(file) {
+  const hit = uncommentedCache.get(file);
+  if (hit) return hit;
+  const rows = file.lines.map((l) => {
+    let s = "";
+    for (let c = 0; c < l.raw.length; c++) {
+      s += l.comment || isCommentAt(file, l.n, c) ? " " : l.raw[c];
+    }
+    return s;
+  });
+  uncommentedCache.set(file, rows);
+  return rows;
+}
+function balancedBlock(file, line, col, open, close) {
+  const rows = uncommentedLines(file);
+  let depth = 0;
+  let text = "";
+  for (let n = line; n <= file.lines.length; n++) {
+    const raw = rows[n - 1];
+    const from = n === line ? col : 0;
+    for (let c = from; c < raw.length; c++) {
+      const ch = raw[c];
+      if (ch === open && isCodeAt(file, n, c)) depth++;
+      else if (ch === close && isCodeAt(file, n, c)) depth--;
+      text += ch;
+      if (depth === 0 && ch === close) {
+        return { startLine: line, endLine: n, text };
+      }
+    }
+    text += "\n";
+  }
+  return null;
+}
+function nextOpener(file, line, col, openers = "{[(", maxLines = 3) {
+  const rows = uncommentedLines(file);
+  for (let n = line; n <= Math.min(file.lines.length, line + maxLines); n++) {
+    const raw = rows[n - 1];
+    for (let c = n === line ? col : 0; c < raw.length; c++) {
+      if (openers.includes(raw[c]) && isCodeAt(file, n, c)) return { line: n, col: c, ch: raw[c] };
+    }
+  }
+  return null;
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function baseOf(tree) {
+  try {
+    return statSync3(tree.root).isDirectory() ? tree.root : join2(tree.root, "..");
+  } catch {
+    return tree.root;
+  }
+}
+function findDiskFiles(tree, pred) {
+  const out = [];
+  const base = baseOf(tree);
+  const walk2 = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync2(dir);
+    } catch (err) {
+      recordSkip(tree, dir, base, `could not be listed (${fsErrorCode(err)}) \u2014 not read`);
+      return;
+    }
+    for (const name of entries.sort()) {
+      const full = join2(dir, name);
+      let st;
+      try {
+        st = statSync3(full);
+      } catch (err) {
+        recordSkip(tree, full, base, `could not be read (${fsErrorCode(err)}) \u2014 not read`);
+        continue;
+      }
+      if (st.isDirectory()) {
+        if (SKIP_DIRS.has(name)) {
+          recordSkip(tree, full, base);
+          continue;
+        }
+        walk2(full);
+      } else {
+        const rel = relative2(base, full).split(sep2).join("/");
+        if (!pred(name, rel)) continue;
+        if (!st.isFile()) {
+          recordSkip(tree, full, base, "not a regular file (FIFO, socket or device) \u2014 not read");
+          continue;
+        }
+        try {
+          accessSync2(full, constants2.R_OK);
+        } catch (err) {
+          recordSkip(tree, full, base, `could not be read (${fsErrorCode(err)}) \u2014 not read`);
+          continue;
+        }
+        out.push({ path: full, rel, name });
+      }
+    }
+  };
+  walk2(base);
+  return out;
+}
+function readText(path) {
+  try {
+    if (!statSync3(path).isFile()) return null;
+    return readFileSync3(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function readJsonRecord(path) {
+  const text = readText(path);
+  if (text === null) return null;
+  try {
+    const v = JSON.parse(text);
+    return isRecord(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+function proseWordCount(markdown) {
+  const noFences = markdown.replace(/^(```|~~~)[^\n]*\n[\s\S]*?^\1[ \t]*$/gm, " ");
+  const noInline = noFences.replace(/`[^`\n]*`/g, " ");
+  return (noInline.match(/[\p{L}\p{N}][\p{L}\p{N}'’-]*/gu) ?? []).length;
+}
+function lineHits(tree, re) {
+  const out = [];
+  for (const file of tree.files) {
+    const rows = uncommentedLines(file);
+    rows.forEach((text, i) => {
+      if (re.test(text)) {
+        out.push({ file, line: i + 1, anchor: `${file.rel}:${i + 1}`, text });
+      }
+    });
+  }
+  return out;
+}
+function enclosingBlock(file, line, col, levels = 0) {
+  const rows = uncommentedLines(file);
+  let curLine = line;
+  let curCol = col;
+  let result = null;
+  for (let level = 0; level <= levels; level++) {
+    let depth = 0;
+    let found = null;
+    outer: for (let n = curLine; n >= 1; n--) {
+      const raw = rows[n - 1];
+      for (let c = (n === curLine ? curCol : raw.length) - 1; c >= 0; c--) {
+        if (!isCodeAt(file, n, c)) continue;
+        if (raw[c] === "}") depth++;
+        else if (raw[c] === "{") {
+          if (depth === 0) {
+            found = { l: n, c };
+            break outer;
+          }
+          depth--;
+        }
+      }
+    }
+    if (!found) return result;
+    const b = balancedBlock(file, found.l, found.c, "{", "}");
+    if (!b) return null;
+    result = { ...b, openLine: found.l, openCol: found.c };
+    curLine = found.l;
+    curCol = found.c;
+  }
+  return result;
+}
+
 // src/detectors/standardPin.ts
-var STANDARD_PIN = "b714129a110237c5521d5269ee61ab919408a17f";
+var STANDARD_PIN = "6d463a1ecc5256cd59dd1afe5aa5e335accacc90";
 
 // src/detectors/dLocalIdentity.ts
 var CLOUD_IDENTITY_PACKAGE = "@vantageos/cloud-identity";
@@ -601,21 +873,155 @@ function literalHoldsIdentity(m) {
   const arg = unfold(m[2]);
   return m[1].split(",").map((e) => unfold(e.trim())).some((e) => e !== "" && !isLiteral(e) && !isLiteral(arg) && comparesIdentity(e, arg));
 }
-function digestsStaticInput(m, ctx) {
+function scopesOf(ctx) {
+  const out = [];
+  for (let level = 0; level < 6; level++) {
+    const b = enclosingBlock(ctx.file, ctx.line.n, ctx.idx, level);
+    if (!b || out.length > 0 && b.text === out[out.length - 1]) break;
+    out.push(b.text);
+  }
+  return out;
+}
+var escRe = (x) => x.replace(/[$]/g, "\\$&");
+function exprUntilSemicolon(text, from) {
+  let depth = 0;
+  for (let i = from; 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 === "(" || c === "[" || c === "{") depth++;
+    else if (c === ")" || c === "]" || c === "}") {
+      if (depth === 0) return text.slice(from, i).trim();
+      depth--;
+    } else if (c === ";" && depth === 0) return text.slice(from, i).trim();
+  }
+  return text.slice(from).trim();
+}
+function bindingOf(name, scopes) {
+  const n = escRe(name);
+  for (const text of scopes) {
+    const decl = new RegExp(String.raw`\b(?:const|let|var)\s+${n}\s*(?::[^=;]+)?=\s*`).exec(text);
+    if (decl) return { kind: "value", expr: exprUntilSemicolon(text, decl.index + decl[0].length) };
+    const loop = new RegExp(String.raw`\bfor\s*\(\s*(?:const|let|var)\s+${n}\s+of\s+`).exec(text);
+    if (loop) {
+      const inner = exprUntilSemicolon(text, loop.index + loop[0].length);
+      return { kind: "element", expr: inner };
+    }
+  }
+  return null;
+}
+function functionBody(file, name) {
+  const text = uncommentedLines(file).join("\n");
+  const decl = new RegExp(String.raw`\bfunction\s+${escRe(name)}\s*\(`).exec(text);
+  if (!decl) return null;
+  const params = callArgs(text, decl.index + decl[0].length);
+  if (!params) return null;
+  return blockFrom(text, params.end);
+}
+function isLocalListing(e, ctx, scopes, depth) {
+  if (depth > 4) return false;
+  const x = e.trim().replace(/^await\s+/, "");
+  if (/^(?:[\w$]+\s*\.\s*)*(?:readdirSync|readdir)\s*\(/.test(x)) return true;
+  const call = x.match(/^([A-Za-z_$][\w$]*)\s*\(/);
+  if (call) {
+    const body = functionBody(ctx.file, call[1]);
+    return body !== null && /\b(?:readdirSync|readdir)\s*\(/.test(body);
+  }
+  if (/^[A-Za-z_$][\w$]*$/.test(x)) {
+    const b = bindingOf(x, scopes);
+    return b !== null && b.kind === "value" && isLocalListing(b.expr, ctx, scopes, depth + 1);
+  }
+  return false;
+}
+function templateParts(e) {
+  if (!/^`[\s\S]*`$/.test(e)) return null;
+  const parts = [];
+  for (let i = 1; i < e.length - 1; i++) {
+    if (e[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (e[i] === "$" && e[i + 1] === "{") {
+      let depth = 0;
+      let j = i + 1;
+      for (; j < e.length; j++) {
+        if (e[j] === "{") depth++;
+        else if (e[j] === "}" && --depth === 0) break;
+      }
+      parts.push(e.slice(i + 2, j));
+      i = j;
+    }
+  }
+  return parts;
+}
+function isLocalContent(e, ctx, scopes, depth) {
+  if (depth > 4) return false;
+  const x = e.trim().replace(/^await\s+/, "");
+  if (isStaticInput(x, ctx.statics)) return true;
+  const fsRead = x.match(/^(?:[\w$]+\s*\.\s*)*(?:readFileSync|readFile)\s*\(/);
+  if (fsRead) {
+    const a = callArgs(x, fsRead[0].length);
+    return a !== null && a.end === x.length;
+  }
+  const wrapped = x.match(/^(?:new\s+TextEncoder\s*\(\s*\)\s*\.\s*encode|Buffer\s*\.\s*from)\s*\(/);
+  if (wrapped) {
+    const a = callArgs(x, wrapped[0].length);
+    return a !== null && a.end === x.length && isLocalContent(a.args[0], ctx, scopes, depth + 1);
+  }
+  const tpl = templateParts(x);
+  if (tpl) return tpl.every((p) => isLocalContent(p, ctx, scopes, depth + 1));
+  const ch = x.match(/^(?:[\w$]+\s*\.\s*)?createHash\s*\(/);
+  if (ch) {
+    const c = callArgs(x, ch[0].length);
+    const up = c ? x.slice(c.end).match(/^\s*\.\s*update\s*\(/) : null;
+    const d = c && up ? callArgs(x, c.end + up[0].length) : null;
+    return d !== null && isLocalContent(d.args[0], ctx, scopes, depth + 1);
+  }
+  const sd = x.match(/^(?:[\w$]+\s*\.\s*)*subtle\s*\.\s*digest\s*\(/);
+  if (sd) {
+    const c = callArgs(x, sd[0].length);
+    return c !== null && c.args.length >= 2 && isLocalContent(c.args[1], ctx, scopes, depth + 1);
+  }
+  if (/^[A-Za-z_$][\w$]*$/.test(x)) {
+    const b = bindingOf(x, scopes);
+    if (!b) return false;
+    return b.kind === "element" ? isLocalListing(b.expr, ctx, scopes, depth + 1) : isLocalContent(b.expr, ctx, scopes, depth + 1);
+  }
+  return false;
+}
+function digestsNonCredentialInput(m, ctx) {
   if (!ctx) return false;
   const text = textFrom(ctx);
   const open = text.indexOf("(");
   if (open < 0) return false;
   const call = callArgs(text, open + 1);
   if (!call) return false;
+  const scopes = scopesOf(ctx);
+  const local = (e) => isLocalContent(e, ctx, scopes, 0);
   if (/^subtle/.test(m[0])) {
-    return m[1] === "digest" && call.args.length >= 2 && isStaticInput(call.args[1], ctx.statics);
+    return m[1] === "digest" && call.args.length >= 2 && local(call.args[1]);
   }
   if (!/^createHash/.test(m[0])) return false;
   const update = text.slice(call.end).match(/^\s*\.\s*update\s*\(/);
-  if (!update) return false;
-  const data = callArgs(text, call.end + update[0].length);
-  return data !== null && isStaticInput(data.args[0], ctx.statics);
+  if (update) {
+    const data = callArgs(text, call.end + update[0].length);
+    return data !== null && local(data.args[0]);
+  }
+  const held = ctx.line.raw.slice(0, ctx.idx).match(/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::[^=]+)?=\s*$/);
+  if (!held || scopes.length === 0) return false;
+  const v = escRe(held[1]);
+  const scope = scopes[0];
+  const updates = [...scope.matchAll(new RegExp(String.raw`\b${v}\s*\.\s*update\s*\(`, "g"))];
+  if (updates.length === 0) return false;
+  const digests = [...scope.matchAll(new RegExp(String.raw`\b${v}\s*\.\s*digest\s*\(`, "g"))];
+  const uses = [...scope.matchAll(new RegExp(String.raw`(?<![\w$.])${v}(?![\w$])`, "g"))];
+  if (uses.length !== 1 + updates.length + digests.length) return false;
+  return updates.every((u) => {
+    const a = callArgs(scope, (u.index ?? 0) + u[0].length);
+    return a !== null && local(a.args[0]);
+  });
 }
 var RENAMEABLE = [
   "createHash",
@@ -856,10 +1262,11 @@ var MATCHERS = [
     // Any digest of a presented credential, whatever the algorithm.
     id: "local-digest",
     category: "validates-credential",
-    // A digest over static content (a literal, or a constant made of literals) is
-    // not a digest of a credential. HMAC and sign/verify always take a key: a site.
+    // A digest over static content (a literal, or a constant made of literals) or over local
+    // content (file bytes, a listing, a digest of them: a content fingerprint of the tree) is not a
+    // digest of a credential. HMAC and sign/verify always take a key: a site.
     re: /\bcreateHash\s*\(|\bcreateHmac\s*\(|\bsubtle\s*\.\s*(digest|sign|verify)\s*\(/,
-    accept: (m, ctx) => !digestsStaticInput(m, ctx),
+    accept: (m, ctx) => !digestsNonCredentialInput(m, ctx),
     sample: 'const h = await crypto.subtle.digest("SHA-256", data);'
   },
   // ── Minting / signing: shown, not counted (category "mints-token") ──────────
@@ -1188,178 +1595,6 @@ function makeLocalIdentity(opts = {}) {
 }
 var localIdentity = makeLocalIdentity();
 
-// src/detectors/siteScan.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join2, relative as relative2, sep as sep2 } from "path";
-function codeSites(tree, re) {
-  const out = [];
-  const g = new RegExp(re.source, re.flags.includes("g") ? re.flags : `${re.flags}g`);
-  for (const file of tree.files) {
-    for (const line of file.lines) {
-      if (line.comment) continue;
-      for (const m of line.raw.matchAll(g)) {
-        const col = m.index ?? 0;
-        if (isCodeAt(file, line.n, col)) {
-          out.push({ file, line, col, match: m, anchor: `${file.rel}:${line.n}` });
-        }
-      }
-    }
-  }
-  return out;
-}
-var uncommentedCache = /* @__PURE__ */ new WeakMap();
-function uncommentedLines(file) {
-  const hit = uncommentedCache.get(file);
-  if (hit) return hit;
-  const rows = file.lines.map((l) => {
-    let s = "";
-    for (let c = 0; c < l.raw.length; c++) {
-      s += l.comment || isCommentAt(file, l.n, c) ? " " : l.raw[c];
-    }
-    return s;
-  });
-  uncommentedCache.set(file, rows);
-  return rows;
-}
-function balancedBlock(file, line, col, open, close) {
-  const rows = uncommentedLines(file);
-  let depth = 0;
-  let text = "";
-  for (let n = line; n <= file.lines.length; n++) {
-    const raw = rows[n - 1];
-    const from = n === line ? col : 0;
-    for (let c = from; c < raw.length; c++) {
-      const ch = raw[c];
-      if (ch === open && isCodeAt(file, n, c)) depth++;
-      else if (ch === close && isCodeAt(file, n, c)) depth--;
-      text += ch;
-      if (depth === 0 && ch === close) {
-        return { startLine: line, endLine: n, text };
-      }
-    }
-    text += "\n";
-  }
-  return null;
-}
-function nextOpener(file, line, col, openers = "{[(", maxLines = 3) {
-  const rows = uncommentedLines(file);
-  for (let n = line; n <= Math.min(file.lines.length, line + maxLines); n++) {
-    const raw = rows[n - 1];
-    for (let c = n === line ? col : 0; c < raw.length; c++) {
-      if (openers.includes(raw[c]) && isCodeAt(file, n, c)) return { line: n, col: c, ch: raw[c] };
-    }
-  }
-  return null;
-}
-function isRecord(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function baseOf(tree) {
-  try {
-    return statSync2(tree.root).isDirectory() ? tree.root : join2(tree.root, "..");
-  } catch {
-    return tree.root;
-  }
-}
-function findDiskFiles(tree, pred) {
-  const out = [];
-  const base = baseOf(tree);
-  const walk2 = (dir) => {
-    let entries;
-    try {
-      entries = readdirSync2(dir);
-    } catch {
-      return;
-    }
-    for (const name of entries.sort()) {
-      const full = join2(dir, name);
-      let st;
-      try {
-        st = statSync2(full);
-      } catch {
-        continue;
-      }
-      if (st.isDirectory()) {
-        if (SKIP_DIRS.has(name)) {
-          recordSkip(tree, full, base);
-          continue;
-        }
-        walk2(full);
-      } else {
-        const rel = relative2(base, full).split(sep2).join("/");
-        if (pred(name, rel)) out.push({ path: full, rel, name });
-      }
-    }
-  };
-  walk2(base);
-  return out;
-}
-function readText(path) {
-  try {
-    return readFileSync3(path, "utf8");
-  } catch {
-    return null;
-  }
-}
-function readJsonRecord(path) {
-  const text = readText(path);
-  if (text === null) return null;
-  try {
-    const v = JSON.parse(text);
-    return isRecord(v) ? v : null;
-  } catch {
-    return null;
-  }
-}
-function proseWordCount(markdown) {
-  const noFences = markdown.replace(/^(```|~~~)[^\n]*\n[\s\S]*?^\1[ \t]*$/gm, " ");
-  const noInline = noFences.replace(/`[^`\n]*`/g, " ");
-  return (noInline.match(/[\p{L}\p{N}][\p{L}\p{N}'’-]*/gu) ?? []).length;
-}
-function lineHits(tree, re) {
-  const out = [];
-  for (const file of tree.files) {
-    const rows = uncommentedLines(file);
-    rows.forEach((text, i) => {
-      if (re.test(text)) {
-        out.push({ file, line: i + 1, anchor: `${file.rel}:${i + 1}`, text });
-      }
-    });
-  }
-  return out;
-}
-function enclosingBlock(file, line, col, levels = 0) {
-  const rows = uncommentedLines(file);
-  let curLine = line;
-  let curCol = col;
-  let result = null;
-  for (let level = 0; level <= levels; level++) {
-    let depth = 0;
-    let found = null;
-    outer: for (let n = curLine; n >= 1; n--) {
-      const raw = rows[n - 1];
-      for (let c = (n === curLine ? curCol : raw.length) - 1; c >= 0; c--) {
-        if (!isCodeAt(file, n, c)) continue;
-        if (raw[c] === "}") depth++;
-        else if (raw[c] === "{") {
-          if (depth === 0) {
-            found = { l: n, c };
-            break outer;
-          }
-          depth--;
-        }
-      }
-    }
-    if (!found) return result;
-    const b = balancedBlock(file, found.l, found.c, "{", "}");
-    if (!b) return null;
-    result = { ...b, openLine: found.l, openCol: found.c };
-    curLine = found.l;
-    curCol = found.c;
-  }
-  return result;
-}
-
 // src/detectors/a2-declared-domains.ts
 function stripComments(text) {
   return text.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/(^|[^:"'`])\/\/.*$/gm, "$1");
@@ -1518,7 +1753,7 @@ var a2DeclaredDomains = {
 };
 
 // src/detectors/v080Kit.ts
-import { existsSync as existsSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { existsSync as existsSync3, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
 import { dirname as dirname2, join as join3 } from "path";
 
 // src/detectors/toolContext.ts
@@ -1936,47 +2171,75 @@ function findUnresolvedToolSites(tree) {
   const kept = out.filter((a) => !wrappers.internal.has(a));
   return [...kept, ...wrappers.unresolved];
 }
-function findListReadBuilders(tree) {
-  const out = [];
-  for (const file of tree.files) {
-    let currentTool = null;
-    let currentToolLine = 0;
-    let awaitingName = false;
-    for (const line of file.lines) {
-      if (line.comment) continue;
-      const raw = line.raw;
-      const inline = raw.match(TOOL_INLINE_LITERAL_RE);
-      if (inline) {
-        currentTool = inline[1];
-        currentToolLine = line.n;
-        awaitingName = false;
-      } else if (OPENER_RE.test(raw)) {
-        awaitingName = true;
-      } else if (awaitingName) {
-        const bare = raw.match(BARE_NAME_RE);
-        if (bare) {
-          currentTool = bare[1];
-          currentToolLine = line.n;
-        }
-        awaitingName = false;
-      }
-      const desc = raw.match(DESCRIPTOR_NAME_RE);
-      if (desc) {
-        currentTool = desc[1];
-        currentToolLine = line.n;
-      }
-      if (CONTENT_RE.test(raw) && currentTool && LIST_READ_RE.test(currentTool)) {
-        out.push({
-          file,
-          toolName: currentTool,
-          toolNameLine: currentToolLine,
-          contentLine: line.n
-        });
-      }
+function findListReadBuilders(tree) {
+  const bindings = resolveNameBindings(tree);
+  const extents = [];
+  const endOf = (startLine, startCol, text) => {
+    const lines = text.split("\n");
+    const last = lines.length - 1;
+    return [startLine + last, last === 0 ? startCol + text.length - 1 : lines[last].length - 1];
+  };
+  for (const site of codeSites(tree, /(?:\.tool|\bregisterTool)\s*\(/g)) {
+    const open = site.col + site.match[0].lastIndexOf("(");
+    const b = balancedBlock(site.file, site.line.n, open, "(", ")");
+    if (!b) continue;
+    const first = firstArgument(b.text.slice(1, -1));
+    const lit = first.match(/^["'`]([^"'`]+)["'`]$/);
+    const ident = first.match(/^([A-Za-z_$][\w$]*)(?:\.name)?$/);
+    const name = lit ? lit[1] : ident ? bindings.get(ident[1]) ?? null : null;
+    extents.push({
+      file: site.file,
+      name,
+      nameLine: site.line.n,
+      from: [site.line.n, open],
+      to: endOf(site.line.n, open, b.text)
+    });
+  }
+  for (const site of codeSites(tree, new RegExp(DESCRIPTOR_NAME_RE.source, "g"))) {
+    const b = enclosingBlock(site.file, site.line.n, site.col);
+    if (!b) continue;
+    extents.push({
+      file: site.file,
+      name: site.match[1],
+      nameLine: site.line.n,
+      from: [b.openLine, b.openCol],
+      to: endOf(b.openLine, b.openCol, b.text)
+    });
+  }
+  const before = (a, b) => a[0] < b[0] || a[0] === b[0] && a[1] <= b[1];
+  const out = [];
+  for (const site of codeSites(tree, new RegExp(CONTENT_RE.source, "g"))) {
+    const at = [site.line.n, site.col];
+    let owner = null;
+    for (const e of extents) {
+      if (e.file !== site.file || !before(e.from, at) || !before(at, e.to)) continue;
+      if (!owner || before(owner.from, e.from)) owner = e;
+    }
+    if (owner?.name && LIST_READ_RE.test(owner.name)) {
+      out.push({
+        file: site.file,
+        toolName: owner.name,
+        toolNameLine: owner.nameLine,
+        contentLine: site.line.n
+      });
     }
   }
   return out;
 }
+function firstArgument(inner) {
+  let depth = 0;
+  for (let i = 0; i < inner.length; i++) {
+    const c = inner[i];
+    if (c === '"' || c === "'" || c === "`") {
+      for (i++; i < inner.length && inner[i] !== c; i++) if (inner[i] === "\\") i++;
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === ")" || c === "]" || c === "}") depth--;
+    else if (c === "," && depth === 0) return inner.slice(0, i).trim();
+  }
+  return inner.trim();
+}
 var SDK_FIRST_RE = /\bregisterTool\s*\(|\.tool\s*\(|new\s+McpServer\s*\(/;
 function sdkFirstAnchor(tree) {
   for (const file of tree.files) {
@@ -2381,16 +2644,29 @@ function governingWorkflows(tree) {
     const wf = join3(dir, ".github", "workflows");
     if (existsSync3(wf)) {
       const out = [];
-      for (const name of readdirSync3(wf).sort()) {
+      const base = baseOf(tree);
+      let names;
+      try {
+        names = readdirSync3(wf).sort();
+      } catch (err) {
+        recordSkip(tree, wf, base, `could not be listed (${fsErrorCode(err)}) \u2014 not read`);
+        return out;
+      }
+      for (const name of names) {
         if (!/\.ya?ml$/.test(name)) continue;
         const full = join3(wf, name);
         try {
-          if (!statSync3(full).isFile()) continue;
-        } catch {
+          if (!statSync4(full).isFile()) {
+            recordSkip(tree, full, base, "not a regular file (FIFO, socket or device) \u2014 not read");
+            continue;
+          }
+        } catch (err) {
+          recordSkip(tree, full, base, `could not be read (${fsErrorCode(err)}) \u2014 not read`);
           continue;
         }
         const text = readText(full);
         if (text !== null) out.push({ rel: `.github/workflows/${name}`, text });
+        else recordSkip(tree, full, base, "could not be read \u2014 not read");
       }
       return out;
     }
@@ -2699,7 +2975,7 @@ var a4WcagGate = {
 };
 
 // src/detectors/a5-performance-budgets.ts
-import { readFileSync as readFileSync4, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { readFileSync as readFileSync4, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
 import { join as join4, relative as relative3, sep as sep3 } from "path";
 import { gzipSync } from "zlib";
 var BUDGET_BYTES = 250 * 1024;
@@ -2735,7 +3011,7 @@ function collect(base) {
       const candidate = BUNDLE_EXT_RE.test(name) && UI_PATH_RE.test(rel);
       let st;
       try {
-        st = statSync4(full);
+        st = statSync5(full);
       } catch {
         if (candidate) unmeasured.push(`${rel} (cannot be read: dangling link or permission)`);
         continue;
@@ -2743,6 +3019,10 @@ function collect(base) {
       if (st.isDirectory()) {
         if (!WALK_SKIP.has(name)) walk2(full, depth + 1);
       } else if (candidate) {
+        if (!st.isFile()) {
+          unmeasured.push(`${rel} (not a regular file, not read)`);
+          continue;
+        }
         if (st.size > MAX_MEASURE_BYTES) {
           unmeasured.push(`${rel} (${(st.size / 1048576).toFixed(0)} MB, too large to measure)`);
           continue;
@@ -3996,7 +4276,7 @@ var a12FileWrite = {
 };
 
 // src/detectors/c7-artifact-verifiable.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync5, statSync as statSync6 } from "fs";
 import { join as join5 } from "path";
 var PIN = STANDARD_PIN;
 var DOC_FILES = ["README.md", "README.fr.md"];
@@ -4034,13 +4314,18 @@ function c7PositiveControls() {
     }
   };
 }
-function readDocText(root) {
+function readDocText(root, unreadable) {
   for (const name of DOC_FILES) {
     const path = join5(root, name);
     if (!existsSync4(path)) continue;
     try {
+      if (!statSync6(path).isFile()) {
+        unreadable.push({ anchor: name, reason: `${name} is not a regular file \u2014 not read` });
+        continue;
+      }
       return { text: readFileSync5(path, "utf8"), file: name };
-    } catch {
+    } catch (err) {
+      unreadable.push({ anchor: name, reason: `${name} could not be read (${fsErrorCode(err)})` });
     }
   }
   return null;
@@ -4071,7 +4356,15 @@ var c7ArtifactVerifiable = {
         `C7 channel-matcher control FAILED on \`${controls.channelMatcher.sample}\` \u2014 matcher broken, verdict untrustworthy`
       );
     }
-    const doc = readDocText(tree.root);
+    const unreadable = [];
+    const doc = readDocText(tree.root, unreadable);
+    if (unreadable.length > 0) {
+      return couldNotJudge(
+        this.id,
+        unreadable[0].anchor,
+        `${unreadable.map((u) => u.reason).join("; ")} \u2014 the install, pin, channel and provenance propositions are unjudged (C-7)`
+      );
+    }
     if (!doc) {
       return {
         id: this.id,
@@ -4224,6 +4517,7 @@ var VERB_SET = /* @__PURE__ */ new Set([
   "get",
   "search",
   "aggregate",
+  "prepare",
   "create",
   "update",
   "delete",
@@ -4239,6 +4533,7 @@ function c9PositiveControls() {
   return {
     fieldMatcher: field,
     setAcceptsCreate: VERB_SET.has("create"),
+    setAcceptsPrepare: VERB_SET.has("prepare"),
     setRejectsRpc: !VERB_SET.has("rpc")
   };
 }
@@ -4253,9 +4548,9 @@ var c9VerbDeclared = {
         `C9 positive control FAILED: pattern /${controls.fieldMatcher.pattern}/ did not match sample \`${controls.fieldMatcher.sample}\` \u2014 matcher broken, verdict untrustworthy`
       );
     }
-    if (!controls.setAcceptsCreate || !controls.setRejectsRpc) {
+    if (!controls.setAcceptsCreate || !controls.setAcceptsPrepare || !controls.setRejectsRpc) {
       throw new Error(
-        "C9 closed-set control FAILED: VERB_SET must accept a legitimate verb (create) and reject the banned rpc sentinel \u2014 verdict untrustworthy"
+        "C9 closed-set control FAILED: VERB_SET must accept the legitimate verbs create and prepare and reject the banned rpc sentinel \u2014 verdict untrustworthy"
       );
     }
     const unresolved = findUnresolvedToolSites(tree);
@@ -4302,7 +4597,7 @@ var c9VerbDeclared = {
           id: this.id,
           anchor: t.anchor,
           state: "non-conforming",
-          verdict: `tool "${t.name}" declares verb "${t.verb}", outside the closed set (positive-control OK) -> use list/get/search/aggregate/create/update/delete/upsert/transition/bulk-write/pure/introspect/external-effect (C-9)`
+          verdict: `tool "${t.name}" declares verb "${t.verb}", outside the closed set (positive-control OK) -> use one of ${[...VERB_SET].join("/")} (C-9)`
         };
       }
     }
@@ -4475,17 +4770,14 @@ var c11Pagination = {
     };
   },
   /**
-   * DYNAMIC — confirms the tool(s) the static shape considers paginable are
-   * genuinely SERVED by the running server (a real runtime fact from the
-   * tools/list snapshot). Does NOT perform the invalid-cursor -> -32602
-   * round trip: the one-shot RuntimeContext snapshot carries no per-tool
-   * schema and no `callTool` verb — that half needs `Session.callTool` with a
-   * cursor argument (documented gap, types.ts `Session`). The verdict names
-   * this explicitly rather than folding it into a silent full "present".
+   * DYNAMIC — the invalid-cursor round trip, on each surface where a cursor arrives (C-11 (a) and
+   * (b)). Red on any probe answered in the wrong form; could-not-judge on a probe that got no
+   * answer, was not sent, or recorded an outcome this code cannot read; present only when every
+   * probe answered in its surface's form.
    */
   runDynamic(runtime) {
     if (runtime.launchError) {
-      const reason = `server could not be started/introspected \u2014 runtime pagination applicability unverifiable: ${runtime.launchError} (C-11)`;
+      const reason = `server could not be started/introspected \u2014 the invalid-cursor round trip could not run: ${runtime.launchError} (C-11)`;
       return {
         id: this.id,
         anchor: `${runtime.root} (runtime)`,
@@ -4494,24 +4786,117 @@ var c11Pagination = {
         verdict: `could not judge: ${reason}`
       };
     }
-    const paginable = runtime.tools.filter((t) => PAGINABLE_RE.test(t.name));
+    const paginable = runtime.tools.filter((t) => PAGINABLE_RE.test(t.name) || t.cursorArgument);
     if (paginable.length === 0) {
       return {
         id: this.id,
         anchor: `${runtime.root} (runtime tools/list)`,
         state: "absent",
-        verdict: "server advertises no list/read/get/search tool at runtime; pagination check n/a"
+        verdict: "server advertises no list/read/get/search tool and no tool taking a cursor at runtime; pagination check n/a"
+      };
+    }
+    const anchor = `${runtime.root} (runtime invalid-cursor probes)`;
+    const probes = runtime.cursorProbes;
+    if (!probes || probes.length === 0) {
+      const reason = "no invalid-cursor round trip was recorded for this run: the -32602 / invalid_cursor answers are unread (C-11)";
+      return {
+        id: this.id,
+        anchor,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
+    const red = [];
+    const unread = [];
+    const ok = [];
+    for (const p of probes) {
+      const j = judgeCursorProbe(p);
+      if (j.kind === "red") red.push(j.text);
+      else if (j.kind === "unread") unread.push(j.text);
+      else ok.push(j.text);
+    }
+    if (red.length > 0) {
+      return {
+        id: this.id,
+        anchor,
+        state: "non-conforming",
+        verdict: `${red.join("; ")} -> an invalid cursor on a protocol list method is -32602; passed as a tool argument it is a tool result with isError: true and structuredContent.error.code "invalid_cursor" (SEP-1303) (C-11)`
+      };
+    }
+    if (unread.length > 0) {
+      const reason = `${unread.join("; ")} (C-11)`;
+      return {
+        id: this.id,
+        anchor,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
       };
     }
-    const names = paginable.map((t) => t.name).join(", ");
+    const toolProbes = probes.filter((p) => p.surface === "tool-argument").length;
     return {
       id: this.id,
-      anchor: `${runtime.root} (runtime tools/list)`,
+      anchor,
       state: "present",
-      verdict: `runtime confirms paginable tool(s) actually served: ${names}. The invalid-cursor -> -32602 round trip is NOT performed by this snapshot surface (needs Session.callTool with a cursor argument, not yet exposed \u2014 see types.ts Session doc); this dynamic half asserts service reachability, not the full cursor-handling guarantee.`
+      verdict: `${ok.join("; ")}${toolProbes === 0 ? "; no served tool takes a cursor argument, so C-11 (b) has no object on this server" : ""} (C-11)`
     };
   }
 };
+function judgeCursorProbe(p) {
+  const where = p.surface === "list-method" ? `${p.target} (protocol list method)` : `tool "${p.target}" (cursor argument)`;
+  const o = p.outcome;
+  switch (o.kind) {
+    case "no-answer":
+      return { kind: "unread", text: `${where}: no answer to the invalid cursor (${o.reason})` };
+    case "not-sent":
+      return { kind: "unread", text: `${where}: probe not sent (${o.reason})` };
+    case "error":
+      if (p.surface === "list-method") {
+        return o.code === -32602 ? { kind: "ok", text: `${where}: -32602 on an invalid cursor` } : {
+          kind: "red",
+          text: `${where}: answered an invalid cursor with error ${String(o.code)}, not -32602`
+        };
+      }
+      return {
+        kind: "red",
+        text: `${where}: answered an invalid cursor argument with a protocol error ${String(o.code)} \u2014 a tool input error is a tool result, never a protocol error`
+      };
+    case "result":
+      if (p.surface === "list-method") {
+        return {
+          kind: "red",
+          text: `${where}: answered an invalid cursor with a result (a silent page), not -32602`
+        };
+      }
+      if (!o.isError) {
+        return {
+          kind: "red",
+          text: `${where}: answered an invalid cursor argument with a silent page (no isError)`
+        };
+      }
+      if (o.errorCode === void 0) {
+        return {
+          kind: "red",
+          text: `${where}: isError: true with no structuredContent.error.code (no stable machine code)`
+        };
+      }
+      return o.errorCode === "invalid_cursor" ? {
+        kind: "ok",
+        text: `${where}: isError: true, structuredContent.error.code "invalid_cursor"`
+      } : {
+        kind: "red",
+        text: `${where}: isError: true with structuredContent.error.code ${JSON.stringify(o.errorCode)}, not "invalid_cursor"`
+      };
+    default: {
+      const unknown = o;
+      return {
+        kind: "unread",
+        text: `${where}: an outcome this code cannot read (${JSON.stringify(unknown.kind)})`
+      };
+    }
+  }
+}
 
 // src/detectors/c12-no-duplicates.ts
 function tripletKey(t) {
@@ -4607,37 +4992,162 @@ var c12NoDuplicates = {
 };
 
 // src/detectors/c13-context-ceiling.ts
-var CEILING_GLOBAL_RE = /\b(?:CONTEXT_CEILING|contextCeiling)\b[\s\S]{0,80}?\bglobal\s*:\s*(\d+)\b/;
-var CEILING_PER_TOOL_RE = /\b(?:CONTEXT_CEILING|contextCeiling)\b[\s\S]{0,80}?\bperTool\s*:\s*(\d+)\b/;
-function findCeiling(tree) {
+var SERVER_MANIFEST_NAMES = /* @__PURE__ */ new Set(["mcp.json", "mcp-server.json"]);
+var NAME_RE = /\b(?:CONTEXT_CEILING|contextCeiling)\b/g;
+var NUM = String.raw`(\d[\d_]*)`;
+var halfRe = (key) => new RegExp(String.raw`(?:^|[{,\s])["'\x60]?${key}["'\x60]?\s*:\s*([^,}\s][^,}]*)`);
+function readObjectText(text) {
+  const halves = {};
+  for (const key of ["global", "perTool"]) {
+    const m = text.match(halfRe(key));
+    if (!m) halves[key] = "missing";
+    else {
+      const v = m[1].trim().replace(/\s+as\s+const$/, "");
+      const n = v.match(new RegExp(`^${NUM}$`));
+      halves[key] = n ? Number.parseInt(n[1].replace(/_/g, ""), 10) : v;
+    }
+  }
+  const odd = Object.entries(halves).filter(([, v]) => typeof v === "string" && v !== "missing");
+  if (odd.length > 0) {
+    return { kind: "unreadable", why: odd.map(([k, v]) => `${k}: ${v}`).join(", ") };
+  }
+  const missing = Object.entries(halves).filter(([, v]) => v === "missing").map(([k]) => k);
+  if (missing.length === 2 && /\.\.\./.test(text)) {
+    return { kind: "unreadable", why: `a spread with no literal halves (${text.slice(0, 60)})` };
+  }
+  if (missing.length > 0) return { kind: "partial", missing };
+  return { kind: "pair", global: halves.global, perTool: halves.perTool };
+}
+function braceBlock(text) {
+  let depth = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === "{") depth++;
+    else if (text[i] === "}" && --depth === 0) return text.slice(0, i + 1);
+  }
+  return null;
+}
+function sameFileConstObject(file, name) {
+  const text = uncommentedLines(file).map(codeOnly).join("\n");
+  const m = new RegExp(
+    String.raw`\bconst\s+${name.replace(/\$/g, "\\$")}\s*(?::[^=]+)?=\s*\{`
+  ).exec(text);
+  if (!m) return null;
+  return braceBlock(text.slice(m.index + m[0].length - 1));
+}
+function ceilingCensus(tree) {
+  const census = { readable: [], partial: [], unreadable: [] };
+  for (const f of findDiskFiles(tree, (n) => SERVER_MANIFEST_NAMES.has(n))) {
+    const text = readText(f.path);
+    if (text === null) {
+      census.unreadable.push({ anchor: f.rel, reason: `${f.rel} is not readable as text` });
+      continue;
+    }
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch (e) {
+      census.unreadable.push({
+        anchor: f.rel,
+        reason: `${f.rel} does not parse as JSON (${e instanceof Error ? e.message : String(e)}): a contextCeiling it may declare is unread`
+      });
+      continue;
+    }
+    if (!isRecord(json) || !("contextCeiling" in json)) continue;
+    const anchor = `${f.rel}:${lineOf(text, /"contextCeiling"/)}`;
+    const c = json.contextCeiling;
+    if (!isRecord(c)) {
+      census.partial.push({
+        anchor,
+        form: "manifest",
+        missing: ["global", "perTool (contextCeiling is not an object)"]
+      });
+      continue;
+    }
+    const ok = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+    const missing = [ok(c.global) ? "" : "global", ok(c.perTool) ? "" : "perTool"].filter(Boolean);
+    if (missing.length > 0) census.partial.push({ anchor, form: "manifest", missing });
+    else
+      census.readable.push({
+        global: c.global,
+        perTool: c.perTool,
+        anchor,
+        form: "manifest"
+      });
+  }
   for (const file of tree.files) {
-    for (const line of file.lines) {
-      if (line.comment) continue;
-      if (/\b(?:CONTEXT_CEILING|contextCeiling)\b/.test(line.raw)) {
-        const start = line.n - 1;
-        const windowLines = file.lines.slice(start, start + 6).map((l) => l.raw);
-        const window = windowLines.join("\n");
-        const g = window.match(CEILING_GLOBAL_RE);
-        const p = window.match(CEILING_PER_TOOL_RE);
-        if (g && p) {
-          return {
-            global: Number.parseInt(g[1], 10),
-            perTool: Number.parseInt(p[1], 10),
-            anchor: `${file.rel}:${line.n}`
-          };
+    const rows = uncommentedLines(file).map(codeOnly);
+    rows.forEach((row, i) => {
+      for (const hit of row.matchAll(NAME_RE)) {
+        const at = hit.index ?? 0;
+        const anchor = `${file.rel}:${i + 1}`;
+        const before = row.slice(0, at);
+        const window = [row.slice(at + hit[0].length), ...rows.slice(i + 1, i + 9)].join("\n");
+        const rest = window.replace(/^["'\x60]/, "");
+        let value = null;
+        if (/\b(?:const|let|var)\s+$/.test(before)) {
+          const m = rest.match(/^\s*(?::[^=]+?)?=(?![=>])\s*/);
+          if (m) value = rest.slice(m[0].length);
+        } else {
+          const m = rest.match(/^\s*\??:(?!:)\s*/) ?? rest.match(/^\s*=(?![=>])\s*/);
+          if (m) value = rest.slice(m[0].length);
+        }
+        if (value === null) continue;
+        if (/^[A-Z][a-z]\w*\s*(?:[;,)|>=]|$)/.test(value)) continue;
+        let obj = null;
+        if (value.startsWith("{")) obj = braceBlock(value);
+        else {
+          const id = value.match(/^([A-Za-z_$][\w$]*)\s*(?:[;,)}\n]|as\b|$)/);
+          if (id) {
+            obj = sameFileConstObject(file, id[1]);
+            if (obj === null) {
+              census.unreadable.push({
+                anchor,
+                reason: `${anchor} declares ${hit[0]} as \`${id[1]}\`, which is not a same-file const object literal`
+              });
+              continue;
+            }
+          }
+        }
+        if (obj === null) {
+          census.unreadable.push({
+            anchor,
+            reason: `${anchor} declares ${hit[0]} as a computed value (\`${value.split("\n")[0].trim().slice(0, 50)}\`): its numbers are not readable statically`
+          });
+          continue;
         }
+        const r = readObjectText(obj);
+        if (r.kind === "partial" && r.missing.length === 2 && /;/.test(obj)) continue;
+        if (r.kind === "pair")
+          census.readable.push({ global: r.global, perTool: r.perTool, anchor, form: "source" });
+        else if (r.kind === "partial")
+          census.partial.push({ anchor, form: "source", missing: r.missing });
+        else
+          census.unreadable.push({
+            anchor,
+            reason: `${anchor} declares ${hit[0]} with ${r.why}: not numeric literals`
+          });
       }
-    }
+    });
   }
-  return null;
+  return census;
+}
+function agreed(census) {
+  const [first, ...rest] = census.readable;
+  if (!first) return null;
+  return rest.every((c) => c.global === first.global && c.perTool === first.perTool) ? first : null;
+}
+function findCeiling(tree) {
+  const c = agreed(ceilingCensus(tree));
+  return c ? { global: c.global, perTool: c.perTool, anchor: c.anchor } : null;
 }
 function c13PositiveControls() {
-  const complete = "const CONTEXT_CEILING = { global: 8000, perTool: 800 };";
-  const partial = "const CONTEXT_CEILING = { global: 8000 };";
+  const complete = readObjectText("{ global: 8000, perTool: 800 }");
+  const quoted = readObjectText('{ "global": 1200, "perTool": 700 }');
+  const partial = readObjectText("{ global: 8000 }");
   return {
     tokensMatcher: toolAnnotationFieldControls().tokensCtx,
-    ceilingAcceptsComplete: CEILING_GLOBAL_RE.test(complete) && CEILING_PER_TOOL_RE.test(complete),
-    ceilingRejectsPartial: !(CEILING_GLOBAL_RE.test(partial) && CEILING_PER_TOOL_RE.test(partial))
+    ceilingAcceptsComplete: complete.kind === "pair" && quoted.kind === "pair",
+    ceilingRejectsPartial: partial.kind === "partial"
   };
 }
 var c13ContextCeiling = {
@@ -4653,7 +5163,7 @@ var c13ContextCeiling = {
     }
     if (!controls.ceilingAcceptsComplete || !controls.ceilingRejectsPartial) {
       throw new Error(
-        "C13 ceiling control FAILED: must accept a complete (global, perTool) declaration and reject a partial one \u2014 verdict untrustworthy"
+        "C13 ceiling control FAILED: must accept a complete (global, perTool) declaration, bare or quoted keys, and reject a partial one \u2014 verdict untrustworthy"
       );
     }
     const unresolved = findUnresolvedToolSites(tree);
@@ -4678,13 +5188,44 @@ var c13ContextCeiling = {
     }
     const opaque = opaqueAnnotationsAbstain(this.id, "C-13", tools);
     if (opaque) return opaque;
-    const ceiling = findCeiling(tree);
-    if (!ceiling) {
+    const census = ceilingCensus(tree);
+    const unreadNote = census.unreadable.length > 0 ? `; also seen and not read: ${census.unreadable.map((u) => u.reason).join("; ")}` : "";
+    if (census.readable.length === 0) {
+      if (census.partial.length > 0) {
+        const p = census.partial[0];
+        return {
+          id: this.id,
+          anchor: p.anchor,
+          state: "non-conforming",
+          verdict: `${census.partial.map((x) => `${x.anchor} declares a context ceiling without ${x.missing.join(" and ")}`).join("; ")} (positive-control OK) -> declare both a global and a per-tool ceiling, as positive numbers (C-13)${unreadNote}`
+        };
+      }
+      if (census.unreadable.length > 0) {
+        const reason = `the context ceiling is declared in a form this run cannot read: ${census.unreadable.map((u) => u.reason).join("; ")} (C-13)`;
+        return {
+          id: this.id,
+          anchor: census.unreadable[0].anchor,
+          state: "could-not-judge",
+          reason,
+          verdict: `could not judge: ${reason}`
+        };
+      }
       return {
         id: this.id,
         anchor: tools[0].anchor,
         state: "non-conforming",
-        verdict: `${tools.length} tool(s) registered but no (global, perTool) context ceiling declared anywhere (positive-control OK) -> declare CONTEXT_CEILING = { global, perTool } (C-13)`
+        verdict: `${tools.length} tool(s) registered but no (global, perTool) context ceiling declared anywhere \u2014 read: the server manifest's contextCeiling (mcp.json / mcp-server.json) and a CONTEXT_CEILING / contextCeiling const or field in source (positive-control OK) -> declare contextCeiling: { global, perTool } in the server manifest (C-13)`
+      };
+    }
+    const ceiling = agreed(census);
+    if (!ceiling) {
+      const reason = `${census.readable.length} declared context ceilings disagree (${census.readable.map((c) => `${c.anchor} global ${c.global} perTool ${c.perTool}`).join("; ")}): which one governs is unknown (C-13)`;
+      return {
+        id: this.id,
+        anchor: census.readable[0].anchor,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
       };
     }
     let sum = 0;
@@ -4719,7 +5260,7 @@ var c13ContextCeiling = {
       id: this.id,
       anchor: ceiling.anchor,
       state: "present",
-      verdict: `${tools.length} tool(s) each declare tokensEstimeContexte within the declared per-tool ceiling (${ceiling.perTool}); sum ${sum} within global ceiling ${ceiling.global} (positive-control OK)`
+      verdict: `${tools.length} tool(s) each declare tokensEstimeContexte within the declared per-tool ceiling (${ceiling.perTool}); sum ${sum} within global ceiling ${ceiling.global}, declared at ${ceiling.anchor} (positive-control OK)${unreadNote}`
     };
   }
 };
@@ -4826,7 +5367,7 @@ var c14CatalogRegistration = guardUnreadablePackageJson(
 );
 
 // src/detectors/c15-annotations-untrusted.ts
-var READ_VERBS = /* @__PURE__ */ new Set(["list", "get", "search", "aggregate"]);
+var READ_VERBS = /* @__PURE__ */ new Set(["list", "get", "search", "aggregate", "prepare"]);
 var WRITE_VERBS = /* @__PURE__ */ new Set([
   "create",
   "update",
@@ -5086,7 +5627,7 @@ var c16UntrustedOutput = {
 };
 
 // src/detectors/c17-supply-chain.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6, readdirSync as readdirSync5 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync6, readdirSync as readdirSync5, statSync as statSync7 } from "fs";
 import { dirname as dirname3, join as join6, relative as relative4, resolve } from "path";
 var PIN4 = STANDARD_PIN;
 var LOCKFILES = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb"];
@@ -5110,8 +5651,8 @@ 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)`);
+  const esc3 = (x) => x.replace(/[.+*?^$()[\]{}|\\/]/g, "\\$&");
+  const named = new RegExp(`(?:^|[\\s(])${esc3(name)}@v?${esc3(version)}(?![\\w.-]*\\d)`);
   if (!named.test(body)) {
     return { ok: false, why: `it does not name ${name}@${version}, the artifact being published` };
   }
@@ -5120,15 +5661,26 @@ function judgeProvenanceRecord(line, name, version) {
   }
   return { ok: true, why: "" };
 }
-function findProvenanceRecord(root, name, version) {
+function findProvenanceRecord(root, name, version, unreadable) {
   let firstBad = null;
   for (const recordFile of PROVENANCE_RECORD_FILES) {
     const path = join6(root, recordFile);
     if (!existsSync5(path)) continue;
     let text;
     try {
+      if (!statSync7(path).isFile()) {
+        unreadable.push({
+          anchor: recordFile,
+          reason: `${recordFile} is not a regular file \u2014 not read`
+        });
+        continue;
+      }
       text = readFileSync6(path, "utf8");
-    } catch {
+    } catch (err) {
+      unreadable.push({
+        anchor: recordFile,
+        reason: `${recordFile} could not be read (${fsErrorCode(err)})`
+      });
       continue;
     }
     const lines = text.split("\n");
@@ -5181,7 +5733,7 @@ function findLockfile(root) {
   }
   return null;
 }
-function findProvenanceClaim(tree, root) {
+function findProvenanceClaim(tree, root, unreadable) {
   const pkg = tree.packageJson;
   if (pkg) {
     const publishConfig = pkg.json.publishConfig;
@@ -5195,16 +5747,29 @@ function findProvenanceClaim(tree, root) {
     let entries = [];
     try {
       entries = readdirSync5(workflowsDir).sort();
-    } catch {
+    } catch (err) {
+      unreadable.push({
+        anchor: relative4(root, workflowsDir) || WORKFLOW_DIR,
+        reason: `${relative4(root, workflowsDir) || WORKFLOW_DIR} cannot be listed (${fsErrorCode(err)})`
+      });
       continue;
     }
     for (const name of entries) {
       if (!/\.ya?ml$/.test(name)) continue;
       const path = join6(workflowsDir, name);
       let text;
+      const shown = `${relative4(root, workflowsDir) || WORKFLOW_DIR}/${name}`;
       try {
+        if (!statSync7(path).isFile()) {
+          unreadable.push({ anchor: shown, reason: `${shown} is not a regular file \u2014 not read` });
+          continue;
+        }
         text = readFileSync6(path, "utf8");
-      } catch {
+      } catch (err) {
+        unreadable.push({
+          anchor: shown,
+          reason: `${shown} could not be read (${fsErrorCode(err)})`
+        });
         continue;
       }
       const hit = workflowStatements(text).find(([, l]) => PROVENANCE_RE2.test(l));
@@ -5253,10 +5818,11 @@ var c17SupplyChainInner = {
         verdict: "no committed lockfile (package-lock.json/pnpm-lock.yaml/yarn.lock/bun.lock) found -> dependencies are not pinned; commit a lockfile (C-17a)"
       };
     }
-    const claim = findProvenanceClaim(tree, tree.root);
+    const unreadable = [];
+    const claim = findProvenanceClaim(tree, tree.root, unreadable);
     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);
+    const record = claim ? null : findProvenanceRecord(tree.root, pkgName, pkgVersion, unreadable);
     if (!claim && record?.ok) {
       return {
         id: this.id,
@@ -5273,6 +5839,13 @@ var c17SupplyChainInner = {
         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 && !record && unreadable.length > 0) {
+      return couldNotJudge(
+        this.id,
+        unreadable[0].anchor,
+        `no provenance claim in the readable places, but ${unreadable.length} candidate(s) were present and unread \u2014 ${unreadable.map((u) => u.reason).join("; ")} (C-17b)`
+      );
+    }
     if (!claim) {
       return {
         id: this.id,
@@ -5294,7 +5867,7 @@ var c17SupplyChain = guardUnreadablePackageJson(c17SupplyChainInner, {
 });
 
 // src/detectors/c18-structure-manifest.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync7, statSync as statSync8 } from "fs";
 import { join as join7 } from "path";
 var PIN5 = STANDARD_PIN;
 function manifestPath(root) {
@@ -5302,7 +5875,7 @@ function manifestPath(root) {
   if (existsSync6(extPath)) return { kind: "extension", path: extPath };
   return { kind: "server", path: join7(root, "mcp.json") };
 }
-var SERVER_MANIFEST_NAMES = ["mcp.json", "mcp-server.json"];
+var SERVER_MANIFEST_NAMES2 = ["mcp.json", "mcp-server.json"];
 function isObject(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -5316,19 +5889,34 @@ function classifyRootJson(json) {
 }
 function rootCandidates(root) {
   const out = [];
-  for (const name of SERVER_MANIFEST_NAMES) {
+  for (const name of SERVER_MANIFEST_NAMES2) {
     const path = join7(root, name);
     if (!existsSync6(path)) continue;
-    const json = readJson(path);
-    out.push({ name, path, role: classifyRootJson(json), json });
+    const { json, readError } = readJson(path);
+    out.push({
+      name,
+      path,
+      role: classifyRootJson(json),
+      json,
+      ...readError ? { readError } : {}
+    });
   }
   return out;
 }
 function readJson(path) {
+  let text;
+  try {
+    if (!statSync8(path).isFile()) {
+      return { json: null, readError: "not a regular file \u2014 not read" };
+    }
+    text = readFileSync7(path, "utf8");
+  } catch (err) {
+    return { json: null, readError: `could not be read (${fsErrorCode(err)})` };
+  }
   try {
-    return JSON.parse(readFileSync7(path, "utf8"));
+    return { json: JSON.parse(text) };
   } catch {
-    return null;
+    return { json: null };
   }
 }
 function c18PositiveControls() {
@@ -5387,6 +5975,14 @@ var c18StructureManifestInner = {
     let manifestName = kind === "extension" ? "extension.json" : "mcp.json";
     if (kind === "server") {
       const cands = rootCandidates(tree.root);
+      const unread = cands.find((c) => c.readError !== void 0);
+      if (unread) {
+        return couldNotJudge(
+          this.id,
+          unread.path,
+          `${unread.name} is present but ${unread.readError} \u2014 the server manifest cannot be judged (C-18)`
+        );
+      }
       const bad = cands.find((c) => c.role === "unparseable");
       if (bad) {
         return {
@@ -5427,7 +6023,15 @@ var c18StructureManifestInner = {
           verdict: "no extension.json found at the tree root -> the extension manifest is required (C-18)"
         };
       }
-      manifest = readJson(path);
+      const read = readJson(path);
+      if (read.readError !== void 0) {
+        return couldNotJudge(
+          this.id,
+          path,
+          `${manifestName} is present but ${read.readError} \u2014 the manifest cannot be judged (C-18)`
+        );
+      }
+      manifest = read.json;
       if (!manifest) {
         return {
           id: this.id,
@@ -5872,7 +6476,7 @@ var c21ProgressiveDisclosure = {
 };
 
 // src/detectors/c22-test-ratio-gate.ts
-import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync8, statSync as statSync9 } from "fs";
 import { join as join8 } from "path";
 var DOC_FILES2 = ["README.md", "README.fr.md", "CHANGELOG.md"];
 var RATIO_RE = /\b(?:coverage|ratio de tests?|test ratio|couverture)\b[^\n%]{0,40}?(\d{1,3}(?:\.\d+)?\s?%)/i;
@@ -5895,15 +6499,20 @@ function c22PositiveControls() {
     identifierClearsBareRatio: !IDENTIFIER_RE.test(bareSample)
   };
 }
-function findRatioCitations(root) {
+function findRatioCitations(root, unreadable) {
   const hits = [];
   for (const name of DOC_FILES2) {
     const path = join8(root, name);
     if (!existsSync7(path)) continue;
     let text;
     try {
+      if (!statSync9(path).isFile()) {
+        unreadable.push({ anchor: name, reason: `${name} is not a regular file \u2014 not read` });
+        continue;
+      }
       text = readFileSync8(path, "utf8");
-    } catch {
+    } catch (err) {
+      unreadable.push({ anchor: name, reason: `${name} could not be read (${fsErrorCode(err)})` });
       continue;
     }
     const lines = text.split("\n");
@@ -5921,44 +6530,48 @@ var c22TestRatioGate = {
   rule: "C-22",
   pin: STANDARD_PIN,
   run(tree) {
-    const controls = c22PositiveControls();
-    if (!controls.ratioMatcher.matched || !controls.identifierMatcher.matched) {
-      throw new Error(
-        `C22 positive control FAILED: ratio=${controls.ratioMatcher.matched} identifier=${controls.identifierMatcher.matched} \u2014 matcher broken, verdict untrustworthy`
-      );
-    }
-    if (!controls.identifierClearsBareRatio) {
-      throw new Error(
-        "C22 identifier-matcher control FAILED: must NOT flag a bare ratio with no identifier token \u2014 verdict untrustworthy"
-      );
-    }
-    const hits = findRatioCitations(tree.root);
-    if (hits.length === 0) {
-      return {
-        id: this.id,
-        anchor: "-",
-        state: "absent",
-        verdict: "no test/coverage ratio cited in README/CHANGELOG; test-ratio-gate check n/a"
-      };
-    }
-    const bare = hits.find((h) => !h.hasIdentifier);
-    if (bare) {
+    const unreadable = [];
+    const decided = (() => {
+      const controls = c22PositiveControls();
+      if (!controls.ratioMatcher.matched || !controls.identifierMatcher.matched) {
+        throw new Error(
+          `C22 positive control FAILED: ratio=${controls.ratioMatcher.matched} identifier=${controls.identifierMatcher.matched} \u2014 matcher broken, verdict untrustworthy`
+        );
+      }
+      if (!controls.identifierClearsBareRatio) {
+        throw new Error(
+          "C22 identifier-matcher control FAILED: must NOT flag a bare ratio with no identifier token \u2014 verdict untrustworthy"
+        );
+      }
+      const hits = findRatioCitations(tree.root, unreadable);
+      if (hits.length === 0) {
+        return {
+          id: this.id,
+          anchor: "-",
+          state: "absent",
+          verdict: "no test/coverage ratio cited in README/CHANGELOG; test-ratio-gate check n/a"
+        };
+      }
+      const bare = hits.find((h) => !h.hasIdentifier);
+      if (bare) {
+        return {
+          id: this.id,
+          anchor: `${bare.file}:${bare.line}`,
+          state: "non-conforming",
+          verdict: `ratio cited at ${bare.file}:${bare.line} ("${bare.raw.trim()}") carries no passage-identifier token (positive-control OK) -> cite the automatic run/commit identifier the ratio was produced by (C-22)`
+        };
+      }
+      const withId = hits[0];
+      const reason = `ratio cited at ${withId.file}:${withId.line} carries an identifier-shaped token, but whether it RESOLVES against a live CI run is the gate half of C-22 \u2014 this static-only run has no CI query surface and cannot confirm resolution`;
       return {
         id: this.id,
-        anchor: `${bare.file}:${bare.line}`,
-        state: "non-conforming",
-        verdict: `ratio cited at ${bare.file}:${bare.line} ("${bare.raw.trim()}") carries no passage-identifier token (positive-control OK) -> cite the automatic run/commit identifier the ratio was produced by (C-22)`
+        anchor: `${withId.file}:${withId.line}`,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
       };
-    }
-    const withId = hits[0];
-    const reason = `ratio cited at ${withId.file}:${withId.line} carries an identifier-shaped token, but whether it RESOLVES against a live CI run is the gate half of C-22 \u2014 this static-only run has no CI query surface and cannot confirm resolution`;
-    return {
-      id: this.id,
-      anchor: `${withId.file}:${withId.line}`,
-      state: "could-not-judge",
-      reason,
-      verdict: `could not judge: ${reason}`
-    };
+    })();
+    return settle(this.id, decided, unreadable);
   }
 };
 
@@ -6453,7 +7066,7 @@ import {
   readFileSync as readFileSync9,
   readdirSync as readdirSync6,
   rmSync,
-  statSync as statSync5,
+  statSync as statSync10,
   writeFileSync
 } from "fs";
 import { tmpdir } from "os";
@@ -6479,15 +7092,17 @@ function walkForConfigs(dir, depth, seen, onSkip) {
   let entries;
   try {
     entries = readdirSync6(dir);
-  } catch {
+  } catch (err) {
+    onSkip(dir, depth, `could not be listed (${fsErrorCode(err)}) \u2014 not read`);
     return;
   }
   for (const name of entries) {
     const full = join9(dir, name);
     let st;
     try {
-      st = statSync5(full);
-    } catch {
+      st = statSync10(full);
+    } catch (err) {
+      onSkip(full, depth + 1, `could not be read (${fsErrorCode(err)}) \u2014 not read`);
       continue;
     }
     if (st.isDirectory()) {
@@ -6497,6 +7112,10 @@ function walkForConfigs(dir, depth, seen, onSkip) {
       }
       walkForConfigs(full, depth + 1, seen, onSkip);
     } else if (DEPLOY_CONFIG_FILES.includes(name)) {
+      if (!st.isFile()) {
+        onSkip(full, depth + 1, "not a regular file (FIFO, socket or device) \u2014 not read");
+        continue;
+      }
       if (!seen.has(dir)) {
         seen.set(dir, { dir, configFile: name, configPath: full });
       }
@@ -6516,7 +7135,7 @@ function probeForCandidate(dir, depth) {
     const full = join9(dir, name);
     let st;
     try {
-      st = statSync5(full);
+      st = statSync10(full);
     } catch {
       continue;
     }
@@ -6558,12 +7177,12 @@ function resolveRailwayRootDirectory(configPath) {
 function c26DeriveScope(root, tree) {
   const seen = /* @__PURE__ */ new Map();
   const skipped = [];
-  const onSkip = (skippedDir, depth) => {
-    const entry = tree ? recordSkip(tree, skippedDir, root) : {
+  const onSkip = (skippedDir, depth, reason) => {
+    const entry = tree ? recordSkip(tree, skippedDir, root, reason) : {
       path: relative5(root, skippedDir).split(sep4).join("/"),
-      reason: SKIP_DIR_INFO[basename2(skippedDir)]?.reason ?? "skipped"
+      reason: reason ?? SKIP_DIR_INFO[basename2(skippedDir)]?.reason ?? "skipped"
     };
-    if (SKIP_DIR_INFO[basename2(skippedDir)]?.authored) {
+    if (reason === void 0 && SKIP_DIR_INFO[basename2(skippedDir)]?.authored) {
       const hit = probeForCandidate(skippedDir, depth);
       if (hit) entry.candidate = relative5(root, hit).split(sep4).join("/");
     }
@@ -6689,8 +7308,22 @@ function gateSite(site) {
   }
   const isolated = mkdtempSync(join9(tmpdir(), "mcp-doctor-c26-"));
   try {
-    const manifestText = readFileSync9(pkgPath, "utf8");
-    const lockText = readFileSync9(join9(site.dir, lock.name), "utf8");
+    let manifestText;
+    let lockText;
+    const lockPath = join9(site.dir, lock.name);
+    try {
+      for (const p of [pkgPath, lockPath]) {
+        if (!statSync10(p).isFile()) throw new Error(`${p} is not a regular file`);
+      }
+      manifestText = readFileSync9(pkgPath, "utf8");
+      lockText = readFileSync9(lockPath, "utf8");
+    } catch (err) {
+      return {
+        site,
+        status: "unreadable",
+        reason: `${site.dir}: package.json or ${lock.name} is present but cannot be read (${err instanceof Error ? err.message : String(err)}) \u2014 the frozen install was not run`
+      };
+    }
     writeFileSync(join9(isolated, "package.json"), manifestText);
     writeFileSync(join9(isolated, lock.name), lockText);
     let proc;
@@ -6751,6 +7384,7 @@ function renderCoverage(scope, verdicts) {
   return verdicts.map((v) => {
     const rel = relative5(process.cwd(), v.site.dir) || v.site.dir;
     if (v.status === "skipped") return `SKIPPED ${rel} (${v.reason})`;
+    if (v.status === "unreadable") return `UNREAD ${rel} (${v.reason})`;
     return `ANALYSED ${rel} -> ${v.ok ? "GREEN" : "RED"}: ${v.detail}`;
   }).join(" | ");
 }
@@ -6793,6 +7427,17 @@ var c26SubpackageLockfile = {
     const verdicts = scope.sites.map(gateSite);
     const inventory = renderCoverage(scope.sites, verdicts);
     const analysed = verdicts.filter((v) => v.status === "analysed");
+    const unread = verdicts.filter((v) => v.status === "unreadable");
+    if (unread.length > 0 && !analysed.some((v) => v.ok === false)) {
+      const reason = `${unread.length} deployable site(s) could not be read \u2014 ${unread.map((v) => v.reason).join("; ")}. Coverage: ${inventory}`;
+      return {
+        id: this.id,
+        anchor: unread[0].site.dir,
+        state: "could-not-judge",
+        reason,
+        verdict: `could not judge: ${reason}`
+      };
+    }
     if (analysed.length === 0) {
       if (hidden.length > 0) return unjudgedHidden("no analysable site; ");
       return {
@@ -6932,22 +7577,21 @@ var c27SubpackageTypes = {
     const workflows = governingWorkflows(tree);
     const reds = [];
     const oks = [];
+    const unreadDocs = [];
     for (const site of tsSites) {
       const siteRel = relative6(base, site.dir) || ".";
       const docs = [];
       const dockerfile = join10(site.dir, "Dockerfile");
       if (existsSync9(dockerfile)) {
-        docs.push({
-          where: `${siteRel}/Dockerfile`,
-          segments: dockerSegments(readText(dockerfile) ?? "")
-        });
+        const text = readText(dockerfile);
+        if (text === null) unreadDocs.push(`${siteRel}/Dockerfile`);
+        else docs.push({ where: `${siteRel}/Dockerfile`, segments: dockerSegments(text) });
       }
       const railway = join10(site.dir, "railway.json");
       if (existsSync9(railway)) {
-        docs.push({
-          where: `${siteRel}/railway.json`,
-          segments: railwayBuildCommand(readText(railway) ?? "")
-        });
+        const text = readText(railway);
+        if (text === null) unreadDocs.push(`${siteRel}/railway.json`);
+        else docs.push({ where: `${siteRel}/railway.json`, segments: railwayBuildCommand(text) });
       }
       for (const w of workflows) {
         if (siteRel === "." || w.text.includes(siteRel)) {
@@ -6960,6 +7604,7 @@ var c27SubpackageTypes = {
         oks.push(`${ok.d.where} (${siteRel})`);
         continue;
       }
+      if (unreadDocs.some((u) => u.startsWith(`${siteRel}/`))) continue;
       const unfrozen = verdicts.find((v) => v.phase === "unfrozen");
       const early = verdicts.find((v) => v.phase === "before-install");
       const why = unfrozen ? `a type check follows a non-frozen install at ${unfrozen.d.where} (the tree is not the lockfile's: use a frozen install)` : early ? `a type check at ${early.d.where} runs before any install (it checks the workspace's tree, not the isolation's)` : "no type check runs in the deployment isolation (no tsc / typecheck step after a frozen install)";
@@ -6972,6 +7617,13 @@ var c27SubpackageTypes = {
         `${reds.length} TypeScript deployable(s): ${reds.join("; ")} -> run the sub-package type check inside the isolation the deployment installs, after the frozen install (C-27)`
       );
     }
+    if (unreadDocs.length > 0) {
+      return couldNotJudge(
+        this.id,
+        `${unreadDocs[0]}:1`,
+        `${unreadDocs.map((u) => `\`${u}\``).join(", ")} is present but cannot be read (permission, or not a regular file): whether the deployment type-checks in its isolation is unread \u2014 never "no type check" (C-27)`
+      );
+    }
     return couldNotJudge(
       this.id,
       oks[0],
@@ -7201,7 +7853,7 @@ var c30SkillsOrgBound = {
 };
 
 // src/detectors/c31-plugin-installable.ts
-import { existsSync as existsSync10, readdirSync as readdirSync8, statSync as statSync6 } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync8, statSync as statSync11 } from "fs";
 import { basename as basename3, dirname as dirname4, join as join11, relative as relative8, sep as sep5 } from "path";
 var MIN_README_WORDS = 40;
 var KEBAB_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
@@ -7402,12 +8054,17 @@ function judgeFolder(tree, folder, manifestPath2, out) {
   }
   const hasLicenseField = typeof manifest.license === "string" && manifest.license.trim() !== "";
   let hasLicenseFile = false;
+  let folderListed = true;
   try {
     hasLicenseFile = readdirSync8(folder).some((n) => /^LICEN[CS]E/i.test(n));
-  } catch {
-    hasLicenseFile = false;
+  } catch (err) {
+    folderListed = false;
+    out.unreadable.push({
+      anchor: rel(folder),
+      reason: `${rel(folder)} cannot be listed (${fsErrorCode(err)}) \u2014 whether it carries a LICENSE file is unread`
+    });
   }
-  if (!hasLicenseField && !hasLicenseFile) {
+  if (!hasLicenseField && !hasLicenseFile && folderListed) {
     out.reds.push({
       anchor: a,
       text: "no licence: plugin.json has no `license` and the folder has no LICENSE file"
@@ -7415,7 +8072,12 @@ function judgeFolder(tree, folder, manifestPath2, out) {
   }
   const readmePath = join11(folder, "README.md");
   const readme = readText(readmePath);
-  if (readme === null) {
+  if (readme === null && existsSync10(readmePath)) {
+    out.unreadable.push({
+      anchor: rel(readmePath),
+      reason: `${rel(readmePath)} is present but cannot be read as text (permission, or not a regular file) \u2014 its length and credential content are unread`
+    });
+  } else if (readme === null) {
     out.reds.push({ anchor: rel(folder), text: "no README.md at the plugin folder root" });
   } else {
     const n = proseWordCount(readme);
@@ -7475,13 +8137,20 @@ function judgeFolder(tree, folder, manifestPath2, out) {
     judgeServers(servers, mcpAnchor, out);
   }
   try {
-    if (statSync6(join11(folder, "bin")).isDirectory()) {
+    if (statSync11(join11(folder, "bin")).isDirectory()) {
       out.reds.push({
         anchor: rel(join11(folder, "bin")),
         text: "a top-level bin/ directory (a plugin ships no bin/ at its top level)"
       });
     }
-  } catch {
+  } catch (err) {
+    const code = fsErrorCode(err);
+    if (code !== "ENOENT" && code !== "ENOTDIR") {
+      out.unreadable.push({
+        anchor: rel(join11(folder, "bin")),
+        reason: `${rel(join11(folder, "bin"))} could not be probed (${code}) \u2014 whether the plugin ships a top-level bin/ is unread`
+      });
+    }
   }
   const jsons = [[a, manifest]];
   if (servers) jsons.push([mcpAnchor, servers]);
@@ -8261,7 +8930,7 @@ var d7Inner = {
 var d7 = guardUnreadablePackageJson(d7Inner, { authoritative: true });
 
 // src/detectors/d8.ts
-import { existsSync as existsSync11, statSync as statSync7 } from "fs";
+import { existsSync as existsSync11, statSync as statSync12 } from "fs";
 import { dirname as dirname5, join as join12, relative as relative9 } from "path";
 var POSITIVE_CONTROL2 = 'server.registerTool("list_items", { ... }, handler);';
 function d8PositiveControl() {
@@ -8274,7 +8943,7 @@ function d8PositiveControl() {
 function resolveBaseDir(tree) {
   if (tree.packageJson) return dirname5(tree.packageJson.path);
   try {
-    return statSync7(tree.root).isDirectory() ? tree.root : dirname5(tree.root);
+    return statSync12(tree.root).isDirectory() ? tree.root : dirname5(tree.root);
   } catch {
     return tree.root;
   }
@@ -8408,6 +9077,13 @@ var d8 = {
         verdict: "server advertises no tools at runtime -> n/a for eval coverage"
       };
     }
+    if (runtime.evalsUnreadable) {
+      return couldNotJudge(
+        this.id,
+        `${runtime.root} (runtime tools/list)`,
+        `the eval file is present but unread \u2014 ${runtime.evalsUnreadable}; per-tool coverage is unknown, never zero (Server Rule 5)`
+      );
+    }
     const summary = runtime.tools.map((t) => `${t.name}=${t.evalCaseCount ?? 0}`).join(" ");
     const under = runtime.tools.filter((t) => (t.evalCaseCount ?? 0) < 3);
     if (under.length > 0) {
@@ -9033,7 +9709,7 @@ var d15 = {
 };
 
 // src/detectors/d16.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10, statSync as statSync8 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync10, statSync as statSync13 } from "fs";
 import { dirname as dirname8, join as join15 } 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/;
@@ -9355,10 +10031,11 @@ var d16 = {
 };
 function readPackageVersion(root) {
   try {
-    let dir = statSync8(root).isDirectory() ? root : dirname8(root);
+    let dir = statSync13(root).isDirectory() ? root : dirname8(root);
     for (let depth = 0; depth < 8; depth++) {
       const candidate = join15(dir, "package.json");
       if (existsSync14(candidate)) {
+        if (!statSync13(candidate).isFile()) return null;
         const pkg = JSON.parse(readFileSync10(candidate, "utf8"));
         return typeof pkg.version === "string" ? pkg.version : null;
       }
@@ -9373,7 +10050,7 @@ function readPackageVersion(root) {
 }
 
 // src/detectors/dAppI18n.ts
-import { existsSync as existsSync15, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync11, statSync as statSync14 } from "fs";
 import { dirname as dirname9, join as join16 } from "path";
 function flattenKeys(obj, prefix = "") {
   if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
@@ -9407,6 +10084,7 @@ function dAppI18nPositiveControls() {
 }
 function readJson2(path) {
   try {
+    if (!statSync14(path).isFile()) return { ok: false };
     return { ok: true, value: JSON.parse(readFileSync11(path, "utf8")) };
   } catch {
     return { ok: false };
@@ -9605,14 +10283,14 @@ var dDebugOptIn = {
 };
 
 // src/detectors/extManifests.ts
-import { readdirSync as readdirSync9, statSync as statSync9 } from "fs";
+import { readdirSync as readdirSync9, statSync as statSync15 } from "fs";
 import { join as join17 } from "path";
 function findExtensionManifests(tree) {
   const out = [];
   const root = tree.root;
   let base;
   try {
-    base = statSync9(root).isDirectory() ? root : join17(root, "..");
+    base = statSync15(root).isDirectory() ? root : join17(root, "..");
   } catch {
     return out;
   }
@@ -9620,15 +10298,17 @@ function findExtensionManifests(tree) {
     let entries;
     try {
       entries = readdirSync9(dir);
-    } catch {
+    } catch (err) {
+      recordSkip(tree, dir, base, `could not be listed (${fsErrorCode(err)}) \u2014 not read`);
       return;
     }
     for (const name of entries) {
       const full = join17(dir, name);
       let st;
       try {
-        st = statSync9(full);
-      } catch {
+        st = statSync15(full);
+      } catch (err) {
+        recordSkip(tree, full, base, `could not be read (${fsErrorCode(err)}) \u2014 not read`);
         continue;
       }
       if (st.isDirectory()) {
@@ -9638,6 +10318,10 @@ function findExtensionManifests(tree) {
         }
         walk2(full);
       } else if (name === "extension.json") {
+        if (!st.isFile()) {
+          recordSkip(tree, full, base, "not a regular file (FIFO, socket or device) \u2014 not read");
+          continue;
+        }
         out.push(full);
       }
     }
@@ -10254,8 +10938,8 @@ var dExt3 = {
 };
 
 // src/detectors/dExt4.ts
-import { readdirSync as readdirSync10, statSync as statSync10 } from "fs";
-import { join as join19 } from "path";
+import { readdirSync as readdirSync10, statSync as statSync16 } from "fs";
+import { join as join19, relative as relative10 } from "path";
 function canonical(name) {
   return name.replace(/[-_]/g, "").toLowerCase();
 }
@@ -10274,28 +10958,39 @@ function dExt4PositiveControls() {
     }
   };
 }
-function findHooksDirs(tree) {
+function findHooksDirs(tree, unreadable, gaps) {
   const root = tree.root;
   const out = [];
   let base;
   try {
-    base = statSync10(root).isDirectory() ? root : join19(root, "..");
+    base = statSync16(root).isDirectory() ? root : join19(root, "..");
   } catch {
     return out;
   }
+  const noteUnread = (path, what, err) => {
+    gaps.count++;
+    const anchor = relative10(base, path) || ".";
+    const reason = `${anchor} ${what} (${fsErrorCode(err)}) \u2014 a hooks/ directory under it may exist unseen, so the implemented hooks are unverifiable (Extension Rule 4)`;
+    if (!unreadable.some((u) => u.anchor === anchor && u.reason === reason)) {
+      unreadable.push({ anchor, reason });
+    }
+  };
   const walk2 = (dir) => {
     let entries;
     try {
       entries = readdirSync10(dir);
-    } catch {
+    } catch (err) {
+      noteUnread(dir, "could not be listed", err);
       return;
     }
     for (const name of entries) {
       const full = join19(dir, name);
       let st;
       try {
-        st = statSync10(full);
-      } catch {
+        st = statSync16(full);
+      } catch (err) {
+        if (fsErrorCode(err) !== "ENOENT" && fsErrorCode(err) !== "ELOOP")
+          noteUnread(full, "could not be read", err);
         continue;
       }
       if (!st.isDirectory()) continue;
@@ -10308,7 +11003,8 @@ function findHooksDirs(tree) {
         let files;
         try {
           files = readdirSync10(full);
-        } catch {
+        } catch (err) {
+          noteUnread(full, "could not be listed", err);
           files = [];
         }
         for (const f of files) {
@@ -10386,7 +11082,8 @@ var dExt4 = {
     }
     const unreadable = [];
     const decided = (() => {
-      const hooksDirs = findHooksDirs(tree);
+      const hooksDirGaps = { count: 0 };
+      const hooksDirs = findHooksDirs(tree, unreadable, hooksDirGaps);
       const { sites, unresolved } = findFactorySites(tree);
       for (const anchor of unresolved) {
         unreadable.push({
@@ -10430,6 +11127,7 @@ var dExt4 = {
           continue;
         }
         const phantom = [...declared].filter((h) => !implemented.has(h));
+        if (phantom.length > 0 && hooksDirGaps.count > 0) continue;
         if (phantom.length > 0) {
           return {
             id: this.id,
@@ -10817,30 +11515,41 @@ var dExt8 = {
 };
 
 // src/detectors/dExt9.ts
-import { readFileSync as readFileSync13, readdirSync as readdirSync11, statSync as statSync11 } from "fs";
-import { join as join23 } from "path";
-function collectHooksDirSources(tree, unreadable) {
+import { readFileSync as readFileSync13, readdirSync as readdirSync11, statSync as statSync17 } from "fs";
+import { join as join23, relative as relative11 } from "path";
+function collectHooksDirSources(tree, unreadable, gaps) {
   const root = tree.root;
   const out = [];
   let base;
   try {
-    base = statSync11(root).isDirectory() ? root : join23(root, "..");
+    base = statSync17(root).isDirectory() ? root : join23(root, "..");
   } catch {
     return out;
   }
+  const noteUnread = (path, what, err) => {
+    gaps.count++;
+    const anchor = relative11(base, path) || ".";
+    const reason = `${anchor} ${what} (${fsErrorCode(err)}) \u2014 a hooks/ directory under it may exist unseen, so the timeout guards are undeterminable (Extension Rule 9)`;
+    if (!unreadable.some((u) => u.anchor === anchor && u.reason === reason)) {
+      unreadable.push({ anchor, reason });
+    }
+  };
   const walk2 = (dir) => {
     let entries;
     try {
       entries = readdirSync11(dir);
-    } catch {
+    } catch (err) {
+      noteUnread(dir, "could not be listed", err);
       return;
     }
     for (const name of entries) {
       const full = join23(dir, name);
       let st;
       try {
-        st = statSync11(full);
-      } catch {
+        st = statSync17(full);
+      } catch (err) {
+        if (fsErrorCode(err) !== "ENOENT" && fsErrorCode(err) !== "ELOOP")
+          noteUnread(full, "could not be read", err);
         continue;
       }
       if (!st.isDirectory()) continue;
@@ -10852,7 +11561,8 @@ function collectHooksDirSources(tree, unreadable) {
         let files;
         try {
           files = readdirSync11(full);
-        } catch {
+        } catch (err) {
+          noteUnread(full, "could not be listed", err);
           files = [];
         }
         for (const f of files) {
@@ -10862,6 +11572,7 @@ function collectHooksDirSources(tree, unreadable) {
           const filePath = join23(full, f);
           let body;
           try {
+            if (!statSync17(filePath).isFile()) throw new Error("not a regular file");
             body = readFileSync13(filePath, "utf8");
           } catch {
             const shortPath = filePath.split("/").slice(-2).join("/");
@@ -10965,8 +11676,9 @@ var dExt9 = {
     }
     const unreadable = [];
     const decided = (() => {
+      const hooksDirGaps = { count: 0 };
       const hookSources = [
-        ...collectHooksDirSources(tree, unreadable),
+        ...collectHooksDirSources(tree, unreadable, hooksDirGaps),
         ...collectFactorySources(tree)
       ];
       const implByToken = /* @__PURE__ */ new Map();
@@ -11015,6 +11727,7 @@ var dExt9 = {
           const hasImplTimeout = implSources.some((s) => hasImplTimeoutGuard(s.body));
           if (!hasManifestTimeout && !hasImplTimeout) noTimeout.push(hook);
         }
+        if (noTimeout.length > 0 && hooksDirGaps.count > 0) continue;
         if (noTimeout.length > 0) {
           return {
             id: this.id,
@@ -12028,7 +12741,6 @@ var dServer14 = {
 };
 
 // src/detectors/e5-extension-isolation.ts
-import { readFileSync as readFileSync14 } from "fs";
 var GLOBAL_RES = [
   /\b(?:globalThis|global|window|self)\s*(?:\.\s*[\w$]+|\[[^\]]+\])\s*=(?!=)/,
   /Object\.(?:assign|defineProperty|defineProperties|setPrototypeOf)\(\s*(?:globalThis|global|window|self)\b/,
@@ -12059,11 +12771,8 @@ var e5ExtensionIsolation = {
     const manifests = findExtensionManifests(tree);
     const own = /* @__PURE__ */ new Set();
     for (const m of manifests) {
-      try {
-        const j = JSON.parse(readFileSync14(m, "utf8"));
-        if (typeof j.identifier === "string") own.add(j.identifier);
-      } catch {
-      }
+      const j = readJsonObject(m);
+      if (j && typeof j.identifier === "string") own.add(j.identifier);
     }
     const defined = tree.files.some(
       (f) => isProductSource(f.rel) && uncommentedLines(f).some((r) => /\bdefineExtension\s*\(/.test(r))
@@ -12493,8 +13202,8 @@ var e10MrtrOnly = {
 };
 
 // src/detectors/e11-surfaces-derived.ts
-import { existsSync as existsSync20, statSync as statSync12 } from "fs";
-import { dirname as dirname14, join as join24, relative as relative10, sep as sep6 } from "path";
+import { existsSync as existsSync20, statSync as statSync18 } from "fs";
+import { dirname as dirname14, join as join24, relative as relative12, sep as sep6 } from "path";
 var ALL = ["chat", "cowork", "claude-code"];
 function excludedSurfaces(c) {
   const cause = /* @__PURE__ */ new Map();
@@ -12510,10 +13219,17 @@ function excludedSurfaces(c) {
   if (c.localMcp) exclude("chat", "a local MCP command excludes chat");
   return cause;
 }
-function isDir(p) {
+function isDir(p, anchor, unreadable) {
   try {
-    return statSync12(p).isDirectory();
-  } catch {
+    return statSync18(p).isDirectory();
+  } catch (err) {
+    const code = fsErrorCode(err);
+    if (code !== "ENOENT" && code !== "ENOTDIR") {
+      unreadable.push({
+        anchor,
+        reason: `${anchor} could not be probed (${code}) \u2014 whether this component exists is unread`
+      });
+    }
     return false;
   }
 }
@@ -12552,7 +13268,7 @@ var e11SurfacesDerived = {
         continue;
       }
       const folder = dirname14(m.path);
-      const rel = (p) => relative10(tree.root, p).split(sep6).join("/") || ".";
+      const rel = (p) => relative12(tree.root, p).split(sep6).join("/") || ".";
       if (!Array.isArray(j.surfaces)) {
         reds.push({
           anchor: m.rel,
@@ -12588,9 +13304,9 @@ var e11SurfacesDerived = {
         }
       }
       const cause = excludedSurfaces({
-        bin: isDir(join24(folder, "bin")),
-        hooks: isDir(join24(folder, "hooks")),
-        agents: isDir(join24(folder, "agents")),
+        bin: isDir(join24(folder, "bin"), rel(join24(folder, "bin")), unreadable),
+        hooks: isDir(join24(folder, "hooks"), rel(join24(folder, "hooks")), unreadable),
+        agents: isDir(join24(folder, "agents"), rel(join24(folder, "agents")), unreadable),
         localMcp
       });
       for (const s of declared) {
@@ -14355,6 +15071,7 @@ var TRANSPORT_RE2 = /\bStreamableHTTPServerTransport\b|\bWebStandardStreamableHT
 var ORIGIN_READ_RE = /headers?\.get\(\s*["'`]origin["'`]|headers?\[\s*["'`]origin["'`]\s*\]|headers?\.origin\b|\.header\(\s*["'`]origin["'`]\s*\)/i;
 var PROTECT_FLAG_RE = /enableDnsRebindingProtection\s*:\s*true/;
 var ALLOWED_ORIGINS_RE = /\ballowedOrigins\s*:\s*/g;
+var TYPE_ANNOTATION_RE = /^(?:readonly\s+)?(?:string\s*\[\s*\]|(?:Readonly)?Array\s*<\s*string\s*>)\s*(?:\|\s*undefined\s*)?[;,]?\s*$/;
 var DISABLED_RE = /enableDnsRebindingProtection\s*:\s*false/;
 var REFUSE_RE = /\b403\b|Forbidden/;
 var WIDE_BIND_RE = /\.listen\s*\([^)]*["'`]0\.0\.0\.0["'`]|\bhost(?:name)?\s*:\s*["'`]0\.0\.0\.0["'`]/;
@@ -14462,12 +15179,14 @@ var s22OriginValidation = {
     );
   }
 };
-function resolveConstLiteral(tree, name) {
+function resolveConstLiteral(tree, name, file) {
   const re = new RegExp(
     `\\b(?:const|let|var)\\s+${name.replace(/[$]/g, "\\$&")}\\b[^=\\n]*=\\s*`,
     "g"
   );
-  for (const site of codeSites(tree, re)) {
+  const sites = codeSites(tree, re);
+  const ordered = file ? [...sites.filter((x) => x.file === file), ...sites.filter((x) => x.file !== file)] : sites;
+  for (const site of ordered) {
     const after = site.col + site.match[0].length;
     const ch = site.line.raw[after];
     if (ch === "[") {
@@ -14483,10 +15202,11 @@ function classifyAllowedOrigins(tree) {
   const out = { sites: 0, first: "", ok: [], reds: [], unresolved: [] };
   for (const site of codeSites(tree, ALLOWED_ORIGINS_RE)) {
     if (!isProductSource(site.file.rel)) continue;
-    out.sites++;
-    out.first ||= site.anchor;
     const after = site.col + site.match[0].length;
     const rest = site.line.raw.slice(after);
+    if (TYPE_ANNOTATION_RE.test(rest)) continue;
+    out.sites++;
+    out.first ||= site.anchor;
     let value;
     if (rest.startsWith("[")) {
       const b = balancedBlock(site.file, site.line.n, after, "[", "]");
@@ -14494,7 +15214,7 @@ function classifyAllowedOrigins(tree) {
     } else {
       value = (rest.match(/^(?:"[^"]*"|'[^']*'|`[^`]*`|[A-Za-z_$][\w$.]*)/) ?? [rest.trim()])[0];
     }
-    const verdict = classifyOriginValue(tree, value);
+    const verdict = classifyOriginValue(tree, value, site.file);
     if (verdict.kind === "wildcard") {
       out.reds.push({
         anchor: site.anchor,
@@ -14513,31 +15233,42 @@ function classifyAllowedOrigins(tree) {
   }
   return out;
 }
-function classifyOriginValue(tree, value, depth = 0) {
-  const v = value.trim();
-  const str = v.match(/^(["'`])(.*)\1$/);
-  if (str)
-    return str[2].includes("*") ? { kind: "wildcard", detail: str[0] } : { kind: "ok", detail: str[0] };
-  if (v.startsWith("[")) {
-    const elements = splitTopLevel(v.slice(1, -1));
-    if (elements.length === 0) return { kind: "empty", detail: "[]" };
-    let unresolved = "";
-    for (const el of elements) {
-      const lit = el.match(/^(["'`])(.*)\1$/);
-      if (!lit) {
-        unresolved ||= el;
-        continue;
-      }
-      if (lit[2].includes("*")) return { kind: "wildcard", detail: lit[0] };
+function leavesOf(tree, v, file, depth) {
+  const out = { strings: [], unresolved: "" };
+  const t = v.trim();
+  const str = t.match(/^(["'`])(.*)\1$/s);
+  if (str) {
+    out.strings.push(str[0]);
+    return out;
+  }
+  if (t.startsWith("[")) {
+    for (const el of splitTopLevel(t.slice(1, -1))) {
+      const inner = leavesOf(tree, el.startsWith("...") ? el.slice(3) : el, file, depth);
+      out.strings.push(...inner.strings);
+      out.unresolved ||= inner.unresolved;
     }
-    return unresolved ? { kind: "unresolved", detail: unresolved } : { kind: "ok", detail: v };
+    return out;
   }
-  if (/^[A-Za-z_$][\w$]*$/.test(v) && depth < 3) {
-    const lit = resolveConstLiteral(tree, v);
-    if (lit === null) return { kind: "unresolved", detail: v };
-    return classifyOriginValue(tree, lit, depth + 1);
+  if (/^[A-Za-z_$][\w$]*$/.test(t) && depth < 3) {
+    const lit = resolveConstLiteral(tree, t, file);
+    if (lit === null) {
+      out.unresolved = t;
+      return out;
+    }
+    return leavesOf(tree, lit, file, depth + 1);
   }
-  return { kind: "unresolved", detail: v };
+  out.unresolved = t;
+  return out;
+}
+function classifyOriginValue(tree, value, file) {
+  const v = value.trim();
+  const leaves = leavesOf(tree, v, file, 0);
+  const wild = leaves.strings.find((x) => x.slice(1, -1).includes("*"));
+  if (wild) return { kind: "wildcard", detail: wild };
+  if (leaves.unresolved) return { kind: "unresolved", detail: leaves.unresolved };
+  if (leaves.strings.length === 0)
+    return { kind: "empty", detail: v.startsWith("[") ? v : `${v} (an empty list)` };
+  return { kind: "ok", detail: v };
 }
 
 // src/detectors/s23-protocol-version-header.ts
@@ -14921,8 +15652,8 @@ var s27ElicitationFloor = {
 };
 
 // src/detectors/s28-claim-forwarded.ts
-import { existsSync as existsSync21, readFileSync as readFileSync15, readdirSync as readdirSync12, statSync as statSync13 } from "fs";
-import { dirname as dirname15, join as join25, relative as relative11 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync14, readdirSync as readdirSync12, statSync as statSync19 } from "fs";
+import { dirname as dirname15, join as join25, relative as relative13 } from "path";
 var PIN11 = STANDARD_PIN;
 var CLAIM_TOKEN = /\bverified(?:Org|Person)\b/;
 var ANY_CLAIM = /\bverified(?:Actor|Org|Person)\b/g;
@@ -14980,11 +15711,12 @@ function splitTop(m, from, to) {
   if (start < to && m.slice(start, to).trim() !== "") parts.push([start, to]);
   return parts;
 }
-function listTs(dir, out = []) {
+function listTs(dir, unread, out = []) {
   let names;
   try {
     names = readdirSync12(dir);
-  } catch {
+  } catch (err) {
+    unread.push(`${dir} could not be listed (${fsErrorCode(err)})`);
     return out;
   }
   for (const n of names) {
@@ -14992,19 +15724,23 @@ function listTs(dir, out = []) {
     const p = join25(dir, n);
     let st;
     try {
-      st = statSync13(p);
-    } catch {
+      st = statSync19(p);
+    } catch (err) {
+      unread.push(`${p} could not be read (${fsErrorCode(err)})`);
       continue;
     }
-    if (st.isDirectory()) listTs(p, out);
-    else if (n.endsWith(".ts") && !n.endsWith(".test.ts") && !n.endsWith(".d.ts")) out.push(p);
+    if (st.isDirectory()) listTs(p, unread, out);
+    else if (n.endsWith(".ts") && !n.endsWith(".test.ts") && !n.endsWith(".d.ts")) {
+      if (!st.isFile()) unread.push(`${p} is not a regular file \u2014 not read`);
+      else out.push(p);
+    }
   }
   return out;
 }
 function discoverBackend(root) {
   let dir = root;
   try {
-    if (!statSync13(root).isDirectory()) dir = dirname15(root);
+    if (!statSync19(root).isDirectory()) dir = dirname15(root);
   } catch {
     return void 0;
   }
@@ -15017,22 +15753,23 @@ function discoverBackend(root) {
   }
   return void 0;
 }
-function readDoors(backendRoot) {
+function readDoors(backendRoot, unread) {
   const doors = /* @__PURE__ */ new Map();
-  for (const path of listTs(backendRoot)) {
+  for (const path of listTs(backendRoot, unread)) {
     let text;
     try {
-      text = readFileSync15(path, "utf8");
-    } catch {
+      text = readFileSync14(path, "utf8");
+    } catch (err) {
+      unread.push(`${path} could not be read (${fsErrorCode(err)})`);
       continue;
     }
     const file = {
       path,
-      rel: relative11(backendRoot, path),
+      rel: relative13(backendRoot, path),
       lines: text.split("\n").map((raw, i) => ({ n: i + 1, raw, comment: false }))
     };
     const m = masked(file);
-    const module = relative11(backendRoot, path).replace(/\.ts$/, "").split("\\").join("/");
+    const module = relative13(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;
@@ -15086,8 +15823,8 @@ function readDoors(backendRoot) {
   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)`);
+  const esc3 = name.replace(/\$/g, "\\$");
+  const re = new RegExp(`(?:\\b(?:const|let|var)\\s+${esc3}\\b|\\bfunction\\s+${esc3}\\b)`);
   for (const f of files) {
     const hit = re.exec(f.m);
     if (!hit) continue;
@@ -15145,7 +15882,9 @@ 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 unread = [];
+  const doors = backendRoot ? readDoors(backendRoot, unread) : void 0;
+  const unreadNote = unread.length > 0 ? `; backend source NOT read: ${unread.join("; ")}` : "";
   const files = tree.files.map((f) => ({ f, text: rawText(f), m: masked(f) }));
   const actorDoors = /* @__PURE__ */ new Set();
   for (const { text } of files) {
@@ -15265,7 +16004,7 @@ function scanS28(tree) {
       if (!info) {
         scan.cnj.push(
           site(
-            `forwards no verified claim and the door ${door} is not defined in the supplied backend (${backendRoot})`
+            `forwards no verified claim and the door ${door} is not defined in the supplied backend (${backendRoot})${unreadNote}`
           )
         );
         continue;
@@ -15654,6 +16393,329 @@ var s34AccessRecheck = {
   }
 };
 
+// src/detectors/s35-scope-in-read.ts
+var CALL_RE2 = /\b([A-Za-z_$][\w$]*)\s*\.\s*(query|action)\s*\(/g;
+var NARROW_WORD = /\b(?:org|orgId|orgSlug|organizationId|organisationId|organization|organisation|tenantId|namespace|recipient|recipientId|owner|ownerId|createdBy|assignedTo|oauthCtx|fromAllowList)\b/;
+var CARRY_WORD = /\b(?:orgId|organizationId|organisationId|tenantId|verifiedOrg|verifiedPerson|verifiedActor|oauthCtx)\b/;
+var PAGINATION_WORD = /\b(?:nextCursor|truncated|hasMore|total)\b/;
+function masked2(file) {
+  return file.lines.map((line) => {
+    let row = "";
+    for (let c = 0; c < line.raw.length; c++) {
+      const ch = line.raw[c];
+      row += line.comment ? " " : ch === " " || isCodeAt(file, line.n, c) ? ch : " ";
+    }
+    return row;
+  }).join("\n");
+}
+var CLOSE = { "(": ")", "[": "]", "{": "}" };
+function matchClose2(m, open) {
+  const stack = [];
+  for (let i = open; i < m.length; i++) {
+    const ch = m[i];
+    if (CLOSE[ch] !== void 0) stack.push(CLOSE[ch]);
+    else if (ch === ")" || ch === "]" || ch === "}") {
+      if (stack.pop() !== ch) return -1;
+      if (stack.length === 0) return i;
+    }
+  }
+  return -1;
+}
+function splitTop2(m, from, to) {
+  const out = [];
+  let depth = 0;
+  let start = from;
+  for (let i = from; i < to; i++) {
+    const ch = m[i];
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") depth--;
+    else if (ch === "," && depth === 0) {
+      out.push([start, i]);
+      start = i + 1;
+    }
+  }
+  if (m.slice(start, to).trim() !== "") out.push([start, to]);
+  return out;
+}
+function blockEnd(m, at) {
+  let depth = 0;
+  for (let i = at - 1; i >= 0; i--) {
+    const ch = m[i];
+    if (ch === "}") depth++;
+    else if (ch === "{") {
+      if (depth === 0) {
+        const close = matchClose2(m, i);
+        return close < 0 ? m.length : close;
+      }
+      depth--;
+    }
+  }
+  return m.length;
+}
+var lineAt2 = (m, offset) => m.slice(0, offset).split("\n").length;
+var esc2 = (s) => s.replace(/\$/g, "\\$");
+function boundNames(m, callStart) {
+  const lineStart = m.lastIndexOf("\n", callStart - 1) + 1;
+  const before = m.slice(lineStart, callStart);
+  const simple = before.match(
+    /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::[^=]+)?=\s*(?:await\s+)?$/
+  );
+  if (simple) return [simple[1]];
+  const destr = before.match(/\b(?:const|let|var)\s+\{([^}]*)\}\s*=\s*(?:await\s+)?$/);
+  if (destr) {
+    return destr[1].split(",").map((p) => p.trim()).filter((p) => p !== "" && !p.startsWith("...")).map((p) => (p.includes(":") ? p.split(":")[1] : p).replace(/=.*$/, "").trim()).filter((p) => /^[A-Za-z_$][\w$]*$/.test(p));
+  }
+  return [];
+}
+function inlineNarrowing(m, start, close, end) {
+  let pos = m.slice(0, start).replace(/\bawait\s+$/, "").length;
+  let grouped = 0;
+  for (; ; ) {
+    let depth = 0;
+    let open2 = -1;
+    for (let i = pos - 1; i >= 0; i--) {
+      const ch = m[i];
+      if (ch === ")" || ch === "]" || ch === "}") depth++;
+      else if (ch === "(" || ch === "[" || ch === "{") {
+        if (depth === 0) {
+          open2 = ch === "(" ? i : -2;
+          break;
+        }
+        depth--;
+      } else if (ch === ";" && depth === 0) break;
+    }
+    if (open2 < 0) break;
+    const ident = /([A-Za-z_$][\w$]*)\s*$/.exec(m.slice(0, open2));
+    if (ident) {
+      if (ident[1] === "scopeFilterList" || ident[1] === "scopeFilterGet") {
+        return {
+          narrowing: { offset: open2 - ident[0].trimEnd().length, form: ident[1] }
+        };
+      }
+      break;
+    }
+    if (!/^\s*(?:await\s+)?$/.test(m.slice(open2 + 1, start))) break;
+    grouped++;
+    pos = m.slice(0, open2).replace(/\bawait\s+$/, "").length;
+  }
+  let p = close + 1;
+  for (let g = 0; g < grouped; g++) {
+    const rest = m.slice(p);
+    const skip = /^\s*\)/.exec(rest);
+    if (!skip) return null;
+    p += skip[0].length;
+  }
+  const chain = /^\s*(?:\??\.\s*(?!filter\b|then\b)[A-Za-z_$][\w$]*\s*)*\??\.\s*(filter|then)\s*\(/.exec(
+    m.slice(p, end)
+  );
+  if (!chain) return null;
+  const open = p + chain[0].length - 1;
+  const cbClose = matchClose2(m, open);
+  if (cbClose < 0) return { unreadable: `a .${chain[1]}( whose closing paren is not found` };
+  const argSpans = splitTop2(m, open + 1, cbClose);
+  const cbSpan = argSpans[0];
+  const cb = cbSpan ? m.slice(cbSpan[0], cbSpan[1]) : "";
+  if (chain[1] === "filter") {
+    return NARROW_WORD.test(cb) ? { narrowing: { offset: p + chain[0].indexOf("."), form: ".filter" } } : null;
+  }
+  const head = /^\s*(?:async\s+)?(?:\(\s*([A-Za-z_$][\w$]*)\s*(?::[^)]*)?\)|([A-Za-z_$][\w$]*))\s*=>\s*/.exec(
+    cb
+  ) ?? /^\s*(?:async\s+)?function\s*[\w$]*\s*\(\s*([A-Za-z_$][\w$]*)[^)]*\)\s*(?=\{)/.exec(cb);
+  const param = head ? head[1] ?? head[2] : void 0;
+  if (!head || param === void 0) {
+    return {
+      unreadable: `a .then callback (\`${cb.trim().slice(0, 40)}\`) whose body the scan does not read`
+    };
+  }
+  const bodyFrom = (cbSpan?.[0] ?? 0) + head[0].length;
+  const bodyTo = cbSpan?.[1] ?? bodyFrom;
+  const found = narrowingsOver(m, [param], bodyFrom, bodyTo);
+  return found.length > 0 ? { narrowing: found[0] } : null;
+}
+function rebound(m, names, from, to) {
+  const out = [];
+  const region = m.slice(from, to);
+  for (const name of names) {
+    for (const hit of region.matchAll(
+      new RegExp(
+        `\\b(?:const|let|var)\\s+([A-Za-z_$][\\w$]*)\\s*(?::[^=]+)?=\\s*${esc2(name)}\\s*(?:;|$)`,
+        "gm"
+      )
+    )) {
+      out.push(hit[1]);
+    }
+  }
+  return out;
+}
+function narrowingsOver(m, names, from, to) {
+  const out = [];
+  const region = m.slice(from, to);
+  for (const name of names) {
+    const n = esc2(name);
+    for (const hit of region.matchAll(/\bscopeFilter(List|Get)\s*\(/g)) {
+      const open = from + (hit.index ?? 0) + hit[0].length - 1;
+      const close = matchClose2(m, open);
+      const args = m.slice(open + 1, close < 0 ? to : close);
+      if (new RegExp(`\\b${n}\\b`).test(args)) {
+        out.push({ offset: from + (hit.index ?? 0), form: `scopeFilter${hit[1]}` });
+      }
+    }
+    for (const hit of region.matchAll(
+      new RegExp(`\\b${n}(?:\\s*\\??\\.\\s*[A-Za-z_$][\\w$]*)*\\s*\\??\\.\\s*filter\\s*\\(`, "g")
+    )) {
+      const open = from + (hit.index ?? 0) + hit[0].length - 1;
+      const close = matchClose2(m, open);
+      const cb = m.slice(open + 1, close < 0 ? to : close);
+      if (NARROW_WORD.test(cb)) out.push({ offset: from + (hit.index ?? 0), form: ".filter" });
+    }
+    for (const hit of region.matchAll(
+      new RegExp(
+        `\\bfor\\s*\\(\\s*(?:const|let|var)\\s+[A-Za-z_$][\\w$]*\\s+of\\s+${n}(?:\\s*\\??\\.\\s*[A-Za-z_$][\\w$]*)*\\s*\\)\\s*\\{`,
+        "g"
+      )
+    )) {
+      const open = from + (hit.index ?? 0) + hit[0].length - 1;
+      const close = matchClose2(m, open);
+      const body = m.slice(open + 1, close < 0 ? to : close);
+      for (const cond of body.matchAll(/\bif\s*\(/g)) {
+        const co = open + 1 + (cond.index ?? 0) + cond[0].length - 1;
+        const cc = matchClose2(m, co);
+        if (cc < 0) continue;
+        const after = m.slice(cc + 1, cc + 40);
+        if (NARROW_WORD.test(m.slice(co, cc)) && /^\s*(?:\{\s*)?continue\b/.test(after)) {
+          out.push({ offset: from + (hit.index ?? 0), form: "a skipping branch in a loop" });
+          break;
+        }
+      }
+    }
+  }
+  return out.sort((a, b) => a.offset - b.offset);
+}
+function scanS35(tree) {
+  const res = { calls: 0, red: [], cnj: [], ok: [] };
+  for (const file of tree.files) {
+    if (!isProductSource(file.rel)) continue;
+    const m = masked2(file);
+    const raw = file.lines.map((l) => l.raw).join("\n");
+    for (const hit of m.matchAll(CALL_RE2)) {
+      if (!/convex|client/i.test(hit[1])) continue;
+      const start = hit.index ?? 0;
+      const open = start + hit[0].length - 1;
+      const close = matchClose2(m, open);
+      if (close < 0) continue;
+      res.calls++;
+      const anchor = `${file.rel}:${lineAt2(m, start)}`;
+      const parts = splitTop2(m, open + 1, close);
+      const first = parts[0] ? raw.slice(parts[0][0], parts[0][1]) : "";
+      const cast = String.raw`(?:\s+as\s+[\w$.<>[\] ]+)?\s*$`;
+      const lit = new RegExp(String.raw`^\s*["'\x60]([\w/]+:[\w]+)["'\x60]${cast}`).exec(first);
+      const ref = new RegExp(String.raw`^\s*(?:api|internal)\.([\w]+)\.([\w]+)${cast}`).exec(first);
+      const door = lit ? lit[1] : ref ? `${ref[1]}:${ref[2]}` : void 0;
+      if (door === void 0) {
+        res.cnj.push({
+          anchor,
+          note: `${anchor} names its door by an expression (\`${first.trim().slice(0, 40)}\`): which door, and so which arguments it accepts, is unknown`
+        });
+        continue;
+      }
+      const argText = parts.slice(1).map(([a, b]) => m.slice(a, b)).join(",");
+      const carried = CARRY_WORD.test(argText);
+      const names = boundNames(m, start);
+      const end = blockEnd(m, start);
+      const inline = inlineNarrowing(m, start, close, end);
+      const narrowings = [
+        ...inline && "narrowing" in inline ? [inline.narrowing] : [],
+        ...narrowingsOver(m, [...names, ...rebound(m, names, close + 1, end)], close + 1, end)
+      ].sort((a, b) => a.offset - b.offset);
+      if (narrowings.length === 0 && inline && "unreadable" in inline && !carried) {
+        res.cnj.push({
+          anchor,
+          note: `${anchor} ${door} is followed by ${inline.unreadable}: whether it narrows the result is unread`
+        });
+        continue;
+      }
+      if (narrowings.length === 0 || carried) {
+        res.ok.push({
+          anchor,
+          note: names.length === 0 && !inline ? `${anchor} ${door}: result not bound, nothing narrows it` : `${anchor} ${door}`
+        });
+        continue;
+      }
+      const spread = /\.\.\.\s*[A-Za-z_$]/.test(argText);
+      const n = narrowings[0];
+      const at = `${file.rel}:${lineAt2(m, n.offset)}`;
+      if (spread) {
+        res.cnj.push({
+          anchor,
+          note: `${anchor} ${door} spreads its arguments from a value the scan does not read, and ${at} narrows the result (${n.form}): whether the read carried the predicate is unread`
+        });
+        continue;
+      }
+      const paged = PAGINATION_WORD.test(m.slice(n.offset, end));
+      res.red.push({
+        anchor: at,
+        note: `${at} narrows (${n.form}) the rows of ${anchor} ${door}, whose arguments carry no scope predicate${paged ? "; a pagination value (nextCursor/truncated/hasMore/total) is served after the narrowing" : ""}`
+      });
+    }
+  }
+  return res;
+}
+function s35Controls() {
+  const red = scanS35Text(
+    'const rows = await client.query("t:list", { limit });\nconst mine = scopeFilterList(rows, oauthCtx);\n'
+  );
+  const green = scanS35Text(
+    'const rows = await client.query("t:list", { limit, orgId: oauthCtx.orgId });\nconst mine = scopeFilterList(rows, oauthCtx);\n'
+  );
+  return { sees: red, spares: !green };
+}
+function scanS35Text(text) {
+  const call = /\bclient\.query\(([^)]*)\)/.exec(text);
+  if (!call) return false;
+  const carried = CARRY_WORD.test(call[1].split(",").slice(1).join(","));
+  return !carried && narrowingsOver(text, ["rows"], call.index + call[0].length, text.length).length > 0;
+}
+var s35ScopeInRead = {
+  id: "S35 scope-in-read",
+  rule: "S-35",
+  pin: STANDARD_PIN,
+  run(tree) {
+    const ctl = s35Controls();
+    if (!ctl.sees || !ctl.spares) {
+      throw new Error(
+        `S35 positive control FAILED: ${JSON.stringify(ctl)} \u2014 the narrowing matcher cannot tell a filter after an unscoped read from a repeated one, verdict untrustworthy`
+      );
+    }
+    const scan = scanS35(tree);
+    if (scan.calls === 0) {
+      return absentResult(
+        this.id,
+        "-",
+        "no backend call (<client>.query|action) in product source (positive control OK) \u2014 S-35 n/a"
+      );
+    }
+    if (scan.red.length > 0) {
+      return redResult(
+        this.id,
+        scan.red[0].anchor,
+        `${scan.red.map((s) => s.note).join("; ")} -> pass the scope predicate to the door as an argument and forward its pagination unchanged (S-35)`
+      );
+    }
+    if (scan.cnj.length > 0) {
+      return couldNotJudge(
+        this.id,
+        scan.cnj[0].anchor,
+        `${scan.cnj.map((s) => s.note).join("; ")} (S-35)`
+      );
+    }
+    return presentResult(
+      this.id,
+      scan.ok[0].anchor,
+      `${scan.calls} backend call(s) read; no scope narrowing over an unscoped result (positive control OK). Not decided here: a narrowing in a helper the scan cannot find, and the door applying the predicate (R-11, R-55) (S-35)`
+    );
+  }
+};
+
 // src/detectors/index.ts
 var registered = [
   d2,
@@ -15752,6 +16814,7 @@ var registered = [
   s25ResourceDiscipline,
   s26ListChangedParity,
   s27ElicitationFloor,
+  s35ScopeInRead,
   e5ExtensionIsolation,
   a3SandboxRespected,
   a4WcagGate,
@@ -15778,6 +16841,7 @@ var READS_CODE = /* @__PURE__ */ new Set([
   "S-25",
   "S-26",
   "S-27",
+  "S-35",
   "E-5",
   "A-3"
 ]);
@@ -15787,12 +16851,12 @@ var detectors = registered.map(
 
 // src/runtime/launch.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync22, readFileSync as readFileSync16, statSync as statSync14 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync15, statSync as statSync20 } from "fs";
 import { dirname as dirname16, isAbsolute, join as join26, resolve as resolve2 } from "path";
 function findPackageDir(target) {
   let dir;
   try {
-    dir = statSync14(target).isDirectory() ? target : dirname16(target);
+    dir = statSync20(target).isDirectory() ? target : dirname16(target);
   } catch {
     return null;
   }
@@ -15822,7 +16886,10 @@ function deriveLaunchPlan(target) {
   }
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync16(join26(pkgDir, "package.json"), "utf8"));
+    if (!statSync20(join26(pkgDir, "package.json")).isFile()) {
+      return { error: `${join26(pkgDir, "package.json")} is not a regular file \u2014 not read` };
+    }
+    pkg = JSON.parse(readFileSync15(join26(pkgDir, "package.json"), "utf8"));
   } catch (err) {
     return {
       error: `could not parse ${join26(pkgDir, "package.json")}: ${err instanceof Error ? err.message : String(err)}`
@@ -15856,6 +16923,7 @@ function deriveLaunchPlan(target) {
 var INTROSPECTOR = String.raw`
 import { spawn } from "node:child_process";
 const plan = JSON.parse(process.env.MCP_DOCTOR_PLAN);
+const INVALID_CURSOR = "mcp-doctor:invalid-cursor:%%%";
 const done = (o) => { process.stdout.write(JSON.stringify(o)); process.exit(0); };
 let child;
 try {
@@ -15865,11 +16933,35 @@ try {
 }
 let settled = false;
 let serverInfo;
+let capabilities = {};
+let tools;
+const probes = [];
+const pending = new Map();
+let nextId = 10;
+let probeTimer;
 const fail = (msg) => { if (settled) return; settled = true; try { child.kill(); } catch {} done({ launchError: msg }); };
-const to = setTimeout(() => fail("timeout: server did not answer initialize+tools/list within the deadline"), 12000);
+const finish = (why) => {
+  if (settled) return; settled = true; clearTimeout(to); clearTimeout(probeTimer);
+  for (const idx of pending.values()) probes[idx].outcome = { kind: "no-answer", reason: why };
+  try { child.kill(); } catch {}
+  done({ tools, serverInfo, cursorProbes: probes });
+};
+const to = setTimeout(() => {
+  if (tools) finish("no answer before the introspection deadline");
+  else fail("timeout: server did not answer initialize+tools/list within the deadline");
+}, 12000);
 child.on("error", (e) => fail("spawn error: " + (e && e.message ? e.message : String(e))));
-child.on("exit", (code) => fail("server exited (code " + code + ") before completing the MCP handshake"));
+child.on("exit", (code) => {
+  if (tools) finish("the server exited (code " + code + ") before answering");
+  else fail("server exited (code " + code + ") before completing the MCP handshake");
+});
 const send = (o) => { try { child.stdin.write(JSON.stringify(o) + "\n"); } catch (e) { fail("write failed: " + e.message); } };
+const probe = (target, surface, method, params) => {
+  const id = nextId++;
+  pending.set(id, probes.length);
+  probes.push({ target, surface });
+  send({ jsonrpc: "2.0", id, method, params });
+};
 let buf = "";
 child.stdout.on("data", (d) => {
   buf += d.toString();
@@ -15878,6 +16970,8 @@ child.stdout.on("data", (d) => {
     const line = buf.slice(0, i); buf = buf.slice(i + 1);
     if (!line.trim()) continue;
     let msg; try { msg = JSON.parse(line); } catch { continue; }
+    // A request or notification FROM the server carries a method: it is not an answer.
+    if (msg.method !== undefined) continue;
     if (msg.id === 1) {
       // The initialize response's serverInfo is the SAME non-authenticated
       // discovery surface a client reads version from (S-7); captured here
@@ -15885,13 +16979,46 @@ child.stdout.on("data", (d) => {
       // alongside it, additively -- every existing consumer of the
       // tools-only introspector output is unaffected.
       serverInfo = msg.result && msg.result.serverInfo;
+      capabilities = (msg.result && msg.result.capabilities) || {};
       send({ jsonrpc: "2.0", method: "notifications/initialized" });
       send({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} });
     } else if (msg.id === 2) {
-      if (settled) return; settled = true; clearTimeout(to);
-      const tools = (msg.result && Array.isArray(msg.result.tools) ? msg.result.tools : []).map((t) => ({ name: String(t && t.name), description: t && typeof t.description === "string" ? t.description : undefined }));
-      try { child.kill(); } catch {}
-      done({ tools, serverInfo });
+      if (settled) return;
+      const served = msg.result && Array.isArray(msg.result.tools) ? msg.result.tools : [];
+      const schemaOf = (t) => (t && t.inputSchema && typeof t.inputSchema === "object" ? t.inputSchema : {});
+      const takesCursor = (t) => {
+        const props = schemaOf(t).properties;
+        return Boolean(props && typeof props === "object" && Object.prototype.hasOwnProperty.call(props, "cursor"));
+      };
+      tools = served.map((t) => ({ name: String(t && t.name), description: t && typeof t.description === "string" ? t.description : undefined, cursorArgument: takesCursor(t) }));
+      const lists = ["tools/list"];
+      if (capabilities.resources) lists.push("resources/list", "resources/templates/list");
+      if (capabilities.prompts) lists.push("prompts/list");
+      for (const m of lists) probe(m, "list-method", m, { cursor: INVALID_CURSOR });
+      for (const t of served) {
+        if (!takesCursor(t)) continue;
+        const name = String(t && t.name);
+        const required = Array.isArray(schemaOf(t).required) ? schemaOf(t).required.filter((r) => r !== "cursor") : [];
+        if (required.length > 0) {
+          probes.push({ target: name, surface: "tool-argument", outcome: { kind: "not-sent", reason: "the tool requires " + required.join(", ") + " beside the cursor; the probe never invents a value for them" } });
+          continue;
+        }
+        probe(name, "tool-argument", "tools/call", { name, arguments: { cursor: INVALID_CURSOR } });
+      }
+      if (pending.size === 0) { finish("no probe pending"); return; }
+      probeTimer = setTimeout(() => finish("no answer within the 5 s probe deadline"), 5000);
+    } else if (pending.has(msg.id)) {
+      const idx = pending.get(msg.id); pending.delete(msg.id);
+      if (msg.error && typeof msg.error === "object") {
+        probes[idx].outcome = { kind: "error", code: msg.error.code, message: typeof msg.error.message === "string" ? msg.error.message : undefined };
+      } else if (msg.result && typeof msg.result === "object") {
+        const sc = msg.result.structuredContent;
+        const err = sc && typeof sc === "object" ? sc.error : undefined;
+        probes[idx].outcome = { kind: "result", isError: msg.result.isError === true, errorCode: err && typeof err === "object" ? err.code : undefined };
+      } else {
+        probes[idx].outcome = { kind: "no-answer", reason: "an answer with neither result nor error" };
+      }
+      if (pending.size === 0) finish("no probe pending");
     }
   }
 });
@@ -15900,29 +17027,41 @@ send({ jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "
 function readEvalCounts(target) {
   const counts = /* @__PURE__ */ new Map();
   const pkgDir = findPackageDir(target) ?? (statSyncSafe(target) ? target : null);
-  if (!pkgDir) return counts;
+  if (!pkgDir) return { counts };
   let dir = pkgDir;
   for (let depth = 0; depth < 8; depth++) {
     const candidate = join26(dir, "evals", "evals.json");
     if (existsSync22(candidate)) {
+      let text;
+      try {
+        if (!statSync20(candidate).isFile()) {
+          return { counts, unreadable: `${candidate} is not a regular file \u2014 not read` };
+        }
+        text = readFileSync15(candidate, "utf8");
+      } catch (err) {
+        return {
+          counts,
+          unreadable: `${candidate} could not be read (${fsErrorCode(err)})`
+        };
+      }
       try {
-        const parsed = JSON.parse(readFileSync16(candidate, "utf8"));
+        const parsed = JSON.parse(text);
         for (const c of parsed.cases ?? []) {
           if (c && typeof c.tool === "string") counts.set(c.tool, (counts.get(c.tool) ?? 0) + 1);
         }
       } catch {
       }
-      return counts;
+      return { counts };
     }
     const parent = dirname16(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return counts;
+  return { counts };
 }
 function statSyncSafe(p) {
   try {
-    return statSync14(p).isDirectory();
+    return statSync20(p).isDirectory();
   } catch {
     return false;
   }
@@ -15942,6 +17081,54 @@ function deriveExpectedCommit(cwd) {
   }
   return void 0;
 }
+function readCursorProbe(raw) {
+  const r = raw ?? {};
+  const target = typeof r.target === "string" ? r.target : "<unnamed>";
+  const surface = r.surface === "tool-argument" ? "tool-argument" : "list-method";
+  const o = r.outcome ?? {};
+  const unreadable = (what) => ({
+    target,
+    surface,
+    outcome: { kind: "no-answer", reason: `unreadable probe record (${what})` }
+  });
+  if (r.surface !== "tool-argument" && r.surface !== "list-method") {
+    return unreadable(`surface ${JSON.stringify(r.surface)}`);
+  }
+  switch (o.kind) {
+    case "error":
+      return {
+        target,
+        surface,
+        outcome: {
+          kind: "error",
+          code: o.code,
+          ...typeof o.message === "string" ? { message: o.message } : {}
+        }
+      };
+    case "result":
+      return {
+        target,
+        surface,
+        outcome: {
+          kind: "result",
+          isError: o.isError === true,
+          ...o.errorCode !== void 0 ? { errorCode: o.errorCode } : {}
+        }
+      };
+    case "no-answer":
+    case "not-sent":
+      return {
+        target,
+        surface,
+        outcome: {
+          kind: o.kind,
+          reason: typeof o.reason === "string" ? o.reason : "no reason given"
+        }
+      };
+    default:
+      return unreadable(`outcome kind ${JSON.stringify(o.kind)}`);
+  }
+}
 function launchAndIntrospect(target) {
   const plan = deriveLaunchPlan(target);
   if ("error" in plan) {
@@ -15982,19 +17169,22 @@ function launchAndIntrospect(target) {
   if (parsed.launchError) {
     return { root: target, tools: [], launchError: parsed.launchError };
   }
-  const evalCounts = readEvalCounts(target);
+  const { counts: evalCounts, unreadable: evalsUnreadable } = readEvalCounts(target);
   const tools = (parsed.tools ?? []).map((t) => {
     const name = t.name;
     const count = evalCounts.get(name);
     const base = t.description ? { name, description: t.description } : { name };
-    return count === void 0 ? base : { ...base, evalCaseCount: count };
+    const withCursor = t.cursorArgument === true ? { ...base, cursorArgument: true } : base;
+    return count === void 0 ? withCursor : { ...withCursor, evalCaseCount: count };
   });
   const expectedCommit = deriveExpectedCommit(plan.cwd);
   return {
     root: target,
     tools,
     ...parsed.serverInfo ? { serverInfo: parsed.serverInfo } : {},
-    ...expectedCommit ? { expectedCommit } : {}
+    ...expectedCommit ? { expectedCommit } : {},
+    ...evalsUnreadable ? { evalsUnreadable } : {},
+    ...Array.isArray(parsed.cursorProbes) ? { cursorProbes: parsed.cursorProbes.map(readCursorProbe) } : {}
   };
 }
 
@@ -16246,12 +17436,13 @@ var USAGE = [
   "  --version       print the version and exit",
   "  --help          print this and exit",
   "",
-  "exit: 0 clean, 1 a violation, 2 an abstention with no violation"
+  "exit: 0 clean, 1 a violation, 2 an abstention with no violation (including a target",
+  "      that names nothing readable: missing, empty, or not a source tree)"
 ].join("\n");
 function readVersion() {
   try {
     const here = dirname17(fileURLToPath2(import.meta.url));
-    const manifest = JSON.parse(readFileSync17(join27(here, "..", "package.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync16(join27(here, "..", "package.json"), "utf8"));
     return manifest.version ?? null;
   } catch {
     return null;
@@ -16297,10 +17488,28 @@ function main() {
     detectorList = detectors.map((d) => d === localIdentity ? ratchet : d);
   }
   const backend = backendArg ? backendArg.slice("--backend=".length) : void 0;
-  const { results, skipped } = runDoctorReport(target, detectorList, {
-    mode,
-    ...backend !== void 0 ? { backend } : {}
-  });
+  let report;
+  try {
+    report = runDoctorReport(target, detectorList, {
+      mode,
+      ...backend !== void 0 ? { backend } : {}
+    });
+  } catch (err) {
+    if (!(err instanceof SubjectUnreadableError)) throw err;
+    if (args.includes("--json")) {
+      console.log(
+        JSON.stringify(
+          { surface: target, exitCode: 2, subjectUnreadable: err.form, results: [], skipped: [] },
+          null,
+          2
+        )
+      );
+    }
+    console.error(err.message);
+    process.exitCode = 2;
+    return;
+  }
+  const { results, skipped } = report;
   console.log(
     args.includes("--json") ? renderJson(target, results, skipped) : renderTable(target, results, skipped)
   );
@@ -16323,6 +17532,7 @@ function isDirectInvocation() {
 }
 if (isDirectInvocation()) main();
 export {
+  SubjectUnreadableError,
   computeExitCode,
   countOwedHumanVerdicts,
   isLiveDetector,