@vantageos/mcp-doctor 0.8.0 → 0.8.1

package/dist/doctor.js

@@ -6,7 +6,7 @@ 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;
 }
@@ -477,8 +562,180 @@ function guardUnreadablePackageJson(inner, opts) {
   };
 }
 
+// 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/standardPin.ts
-var STANDARD_PIN = "b714129a110237c5521d5269ee61ab919408a17f";
+var STANDARD_PIN = "6d463a1ecc5256cd59dd1afe5aa5e335accacc90";
 
 // src/detectors/dLocalIdentity.ts
 var CLOUD_IDENTITY_PACKAGE = "@vantageos/cloud-identity";
@@ -601,21 +858,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 +1247,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 +1580,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");
@@ -1937,46 +2157,74 @@ function findUnresolvedToolSites(tree) {
   return [...kept, ...wrappers.unresolved];
 }
 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 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
-        });
-      }
+  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) {
@@ -4224,6 +4472,7 @@ var VERB_SET = /* @__PURE__ */ new Set([
   "get",
   "search",
   "aggregate",
+  "prepare",
   "create",
   "update",
   "delete",
@@ -4239,6 +4488,7 @@ function c9PositiveControls() {
   return {
     fieldMatcher: field,
     setAcceptsCreate: VERB_SET.has("create"),
+    setAcceptsPrepare: VERB_SET.has("prepare"),
     setRejectsRpc: !VERB_SET.has("rpc")
   };
 }
@@ -4253,9 +4503,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 +4552,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 +4725,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 +4741,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 toolProbes = probes.filter((p) => p.surface === "tool-argument").length;
+    return {
+      id: this.id,
+      anchor,
+      state: "present",
+      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)})`
       };
     }
-    const names = paginable.map((t) => t.name).join(", ");
-    return {
-      id: this.id,
-      anchor: `${runtime.root} (runtime tools/list)`,
-      state: "present",
-      verdict: `runtime confirms paginable tool(s) actually served: ${names}. The invalid-cursor -> -32602 round trip is NOT performed by this snapshot surface (needs Session.callTool with a cursor argument, not yet exposed \u2014 see types.ts Session doc); this dynamic half asserts service reachability, not the full cursor-handling guarantee.`
-    };
   }
-};
+}
 
 // src/detectors/c12-no-duplicates.ts
 function tripletKey(t) {
@@ -4607,37 +4947,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 +5118,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 +5143,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 +5215,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 +5322,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",
@@ -5110,8 +5606,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` };
   }
@@ -5302,7 +5798,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,7 +5812,7 @@ 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);
@@ -14355,6 +14851,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 +14959,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 +14982,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 +14994,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 +15013,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
@@ -15086,8 +15597,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;
@@ -15654,6 +16165,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 +16586,7 @@ var registered = [
   s25ResourceDiscipline,
   s26ListChangedParity,
   s27ElicitationFloor,
+  s35ScopeInRead,
   e5ExtensionIsolation,
   a3SandboxRespected,
   a4WcagGate,
@@ -15778,6 +16613,7 @@ var READS_CODE = /* @__PURE__ */ new Set([
   "S-25",
   "S-26",
   "S-27",
+  "S-35",
   "E-5",
   "A-3"
 ]);
@@ -15856,6 +16692,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 +16702,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 +16739,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 +16748,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");
     }
   }
 });
@@ -15942,6 +16838,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) {
@@ -15987,14 +16931,16 @@ function launchAndIntrospect(target) {
     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 } : {},
+    ...Array.isArray(parsed.cursorProbes) ? { cursorProbes: parsed.cursorProbes.map(readCursorProbe) } : {}
   };
 }
 
@@ -16246,7 +17192,8 @@ 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 {
@@ -16297,10 +17244,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 +17288,7 @@ function isDirectInvocation() {
 }
 if (isDirectInvocation()) main();
 export {
+  SubjectUnreadableError,
   computeExitCode,
   countOwedHumanVerdicts,
   isLiveDetector,