canship 0.1.1 → 0.2.1

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { resolve as resolve2 } from "path";
-import { existsSync as existsSync2, statSync as statSync3, writeFileSync } from "fs";
+import { isAbsolute as isAbsolute2, relative as relative_, resolve as resolve2 } from "path";
+import { existsSync as existsSync3, realpathSync as realpathSync2, statSync as statSync5, writeFileSync as writeFileSync2 } from "fs";
 
 // src/rules/patterns.ts
 var IRRELEVANT_HOSTS = /^(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\]|host\.docker\.internal|.*\.?example\.(?:com|org|net)|.*\.(?:test|invalid|localhost))$/i;
@@ -47,13 +47,7 @@ var SECRET_PATTERNS = [
   {
     id: "npm-token",
     name: "npm access token",
-    // Shape only, though npm encodes a CRC32 of the token into its last six
-    // characters and this could verify it. The github-token entry above uses
-    // the same scheme and does not verify it either, for the reason that
-    // settles it: if the algorithm ever changes, a checksum test turns a real
-    // leaked token into a silent pass. A false positive costs a glance. This
-    // particular false negative costs the account, and every account that
-    // installs anything published from it afterwards.
+    // 仅检查令牌形状，不校验其校验码。
     pattern: /\bnpm_[A-Za-z0-9]{36}\b/g,
     impact: "Publishes packages under your account. Anyone who installs one afterwards runs whatever that version contains.",
     rotateAt: "https://docs.npmjs.com/creating-and-viewing-access-tokens"
@@ -64,13 +58,7 @@ var SECRET_PATTERNS = [
     pattern: /\bAIza[0-9A-Za-z_-]{35}\b/g,
     impact: "Depending on its scope, this can be used to run up billed usage on Google Cloud services.",
     rotateAt: "https://console.cloud.google.com/apis/credentials",
-    // Unlike every other pattern in this table, an AIza-format key is not a
-    // bearer credential: it identifies a Firebase project or a Maps Platform
-    // caller, and Google's own docs say it belongs in client code. Flagging
-    // it as "exposed to the browser — rotate this" was a false positive on
-    // every ordinary Firebase or Maps front-end, and the actual protection
-    // (application/API restrictions in the Cloud console) is not something a
-    // static scan of the repository can confirm one way or the other.
+    // Google 项目标识符不直接作为私密凭据报告。
     publicByDesign: true
   },
   {
@@ -91,17 +79,7 @@ var SECRET_PATTERNS = [
     id: "supabase-secret-key",
     name: "Supabase secret key",
     rotateLabel: "Supabase secret key",
-    // Supabase's newer key format. The prefix settles it: sb_secret_ is the
-    // server-side half, sb_publishable_ is the one meant for browsers, and the
-    // two are never confusable.
-    //
-    // framework.ts has recognised this format since the day it was written —
-    // but only for deciding whether a *client-exposed* value is the admin key.
-    // It was never in this table, and this table is what the hardcoded-secret
-    // rule and the output-boundary redaction both walk. So a project with one
-    // of these in its source got a clean report, and a project with one beside
-    // another credential had it printed in full: the redaction pass could not
-    // mask a format it did not know.
+    // 共享新版 Supabase 私密密钥模式，与公开密钥区分。
     pattern: new RegExp(String.raw`\b${SB_SECRET_SOURCE}\b`, "g"),
     impact: "This is the server-side Supabase key. It bypasses every Row Level Security policy \u2014 it is effectively your database root password.",
     rotateAt: "your Supabase dashboard, Project Settings -> API Keys"
@@ -117,22 +95,9 @@ var SECRET_PATTERNS = [
     id: "db-connection-string",
     name: "Database connection string with password",
     pattern: /\b(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|amqp):\/\/[^\s:@/'"`]+:([^\s@/'"`]+)@(\[[^\]\s]+\]|[^\s'"`/:]+)(?::\d+)?(?:[/?#][^\s'"`]*)?/g,
-    // Check only the password group for placeholders, so an "example" or "test"
-    // in the host does not cause a miss.
+    // 仅用密码组判断占位符，避免主机名影响判断。
     secretGroup: 1,
-    // But if the host itself is an example domain or a local address, the
-    // connection string is worthless and not worth reporting.
-    //
-    // The host alternative takes a bracketed form first so IPv6 survives:
-    // `[^\s'"/:]+` stops at the first colon, so `@[::1]:5432` captured a lone
-    // `[`, which matches no entry below — an IPv6 loopback string was reported
-    // P0 while the identical `localhost` one was correctly ignored.
-    //
-    // The backtick is excluded for the same reason. It is the third string
-    // delimiter in JavaScript and the only one this pattern had never heard of,
-    // so a connection string written in a template literal handed the host
-    // group a trailing backtick and defeated the check below. canship found
-    // that one on its own source, in the comment above.
+    // 支持 IPv6，并排除示例和本地地址。
     ignoreIf: (m) => IRRELEVANT_HOSTS.test(m[2] ?? ""),
     rotateLabel: "database password",
     impact: "This contains your database username AND password. Anyone with it can read, modify, or delete your entire database."
@@ -205,8 +170,8 @@ function redactSecret(secret) {
 }
 function redactLine(line, secret) {
   const trimmed = line.trim();
-  if (!secret) return truncate(trimmed);
-  return truncate(trimmed.split(secret).join(redactSecret(secret)));
+  if (!secret) return trimmed;
+  return trimmed.split(secret).join(redactSecret(secret));
 }
 var JWT_SHAPED = new RegExp(String.raw`\b${JWT_SOURCE}\b`, "g");
 function redactAll(text) {
@@ -233,6 +198,7 @@ import { execFileSync } from "child_process";
 import { accessSync, constants, existsSync, lstatSync, readFileSync, realpathSync, statSync } from "fs";
 import { delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "path";
 var MAX_GIT_OUTPUT = 32 * 1024 * 1024;
+var GIT_TIMEOUT_MS = 3e4;
 function canonical(path) {
   try {
     return realpathSync.native(path);
@@ -421,35 +387,47 @@ function gitEnvironment() {
   env.PAGER = "";
   return env;
 }
-function execGitSync(executable, root, args, options = {}) {
+function hardeningArgs(root) {
   const worktree = gitRootAbove(root) ?? root;
   const noHooks = process.platform === "win32" ? "NUL" : "/dev/null";
-  return execFileSync(
-    executable,
-    [
-      "-c",
-      `core.worktree=${worktree}`,
-      "-c",
-      "core.bare=false",
-      "-c",
-      "core.fsmonitor=false",
-      "-c",
-      `core.hooksPath=${noHooks}`,
-      ...args
-    ],
-    {
-      cwd: root,
-      encoding: "utf8",
-      maxBuffer: options.maxBuffer ?? MAX_GIT_OUTPUT,
-      stdio: ["ignore", "pipe", options.stderr ?? "ignore"],
-      windowsHide: true,
-      env: gitEnvironment()
-    }
-  );
+  return [
+    "-c",
+    `core.worktree=${worktree}`,
+    "-c",
+    "core.bare=false",
+    "-c",
+    "core.fsmonitor=false",
+    "-c",
+    `core.hooksPath=${noHooks}`
+  ];
+}
+function execGitSync(executable, root, args, options = {}) {
+  return execFileSync(executable, [...hardeningArgs(root), ...args], {
+    timeout: GIT_TIMEOUT_MS,
+    cwd: root,
+    encoding: "utf8",
+    maxBuffer: options.maxBuffer ?? MAX_GIT_OUTPUT,
+    stdio: ["ignore", "pipe", options.stderr ?? "ignore"],
+    windowsHide: true,
+    env: gitEnvironment()
+  });
+}
+function execGitBatch(executable, root, args, input, options = {}) {
+  return execFileSync(executable, [...hardeningArgs(root), ...args], {
+    timeout: GIT_TIMEOUT_MS,
+    cwd: root,
+    input,
+    maxBuffer: options.maxBuffer ?? MAX_GIT_OUTPUT,
+    stdio: ["pipe", "pipe", options.stderr ?? "ignore"],
+    windowsHide: true,
+    env: gitEnvironment()
+  });
 }
 
 // src/walker.ts
 var MAX_FILE_BYTES = 2 * 1024 * 1024;
+var MAX_SCAN_BYTES = 128 * 1024 * 1024;
+var MAX_SCAN_FILES = 1e4;
 var MAX_WALK_DEPTH = 16;
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -468,8 +446,7 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   ".venv",
   "venv",
   ".cache",
-  // Build output and tool caches from ecosystems beyond JavaScript. Walking
-  // these to look for credential files is pure cost.
+  // 排除其他生态的构建产物和工具缓存。
   ".dart_tool",
   ".gradle",
   "Pods",
@@ -507,7 +484,7 @@ var SCAN_EXTENSIONS = /* @__PURE__ */ new Set([
   ".yml",
   ".toml",
   ".sql",
-  // Firebase security rules (firestore.rules / storage.rules)
+  // Firebase 规则文件。
   ".rules",
   ".env",
   ".sh",
@@ -535,10 +512,29 @@ var CREDENTIAL_FILENAMES = /* @__PURE__ */ new Set([
   "id_ed25519"
 ]);
 var PROBE_BYTES = 4096;
-var IGNORE_FILE_MARKER = /^\s*(?:\/\/|#|--|\*\/?|\/\*|<!--)?\s*canship-ignore-file\s*(?:\*\/|-->)?\s*$/;
+var IGNORE_FILE_MARKER = /^\s*(?:(?:\/\/|#|--|\*\/?|\/\*|<!--)\s*)?canship-ignore-file(?:\s*(?:\*\/|-->))?\s*$/;
 function hasIgnoreMarker(lines) {
   return lines.some((line) => IGNORE_FILE_MARKER.test(line));
 }
+var IGNORE_LINE_MARKER = /^\s*(?:(?:\/\/|#|--|\*\/?|\/\*|<!--)\s*)?canship-ignore-next-line(?:\s+([\w./-]+))?(?:\s*(?:\*\/|-->))?\s*$/;
+function ignoredLinesOf(lines) {
+  const found = /* @__PURE__ */ new Map();
+  lines.forEach((line, index) => {
+    const match = IGNORE_LINE_MARKER.exec(line);
+    if (match === null) return;
+    const governed = index + 2;
+    const ruleId = match[1];
+    if (ruleId === void 0) {
+      found.set(governed, null);
+      return;
+    }
+    if (found.has(governed) && found.get(governed) === null) return;
+    const rules = found.get(governed) ?? /* @__PURE__ */ new Set();
+    rules.add(ruleId);
+    found.set(governed, rules);
+  });
+  return found;
+}
 var SKIP_FILENAMES = /* @__PURE__ */ new Set(["bun.lockb"]);
 function isEnvFile(name) {
   const lower = name.toLowerCase();
@@ -783,7 +779,7 @@ function isExampleContext(relPath) {
   if (/\.(test|spec)\.[jt]sx?$/i.test(name)) return true;
   return false;
 }
-function collectFiles(root, isGitRepo, gitExecutable = resolveGitExecutable(root)) {
+function collectFiles(root, isGitRepo, gitExecutable = resolveGitExecutable(root), limits = {}) {
   const skipped = [];
   const ignored = [];
   const fromGit = isGitRepo ? listViaGit(root, gitExecutable) : null;
@@ -812,6 +808,10 @@ function collectFiles(root, isGitRepo, gitExecutable = resolveGitExecutable(root
     forced.add(hidden);
   }
   const files = [];
+  let bytesRead = 0;
+  let filesRead = 0;
+  const maxBytes = limits.maxBytes ?? MAX_SCAN_BYTES;
+  const maxFiles = limits.maxFiles ?? MAX_SCAN_FILES;
   for (const relPath of candidates) {
     if (!forced.has(relPath) && !shouldScan(relPath)) continue;
     const absPath = join2(root, relPath);
@@ -832,7 +832,22 @@ function collectFiles(root, isGitRepo, gitExecutable = resolveGitExecutable(root
         });
         continue;
       }
-      content = decodeText(readFileSync2(absPath));
+      if (filesRead >= maxFiles || bytesRead + size > maxBytes) {
+        skipped.push({
+          path: relPath,
+          reason: "too-large",
+          detail: `scan read budget exceeded (${maxFiles} files, ${maxBytes} bytes); remaining candidates were not read`
+        });
+        break;
+      }
+      const bytes = readFileSync2(absPath);
+      bytesRead += bytes.length;
+      filesRead++;
+      if (bytesRead > maxBytes) {
+        skipped.push({ path: relPath, reason: "too-large", detail: "scan read budget exceeded during file read" });
+        break;
+      }
+      content = decodeText(bytes);
     } catch (err) {
       if (!isMissing(err)) {
         skipped.push({
@@ -892,68 +907,100 @@ function parseEnvLine(raw) {
 }
 
 // src/mask.ts
+var SLASH = 47;
+var STAR = 42;
+var DOUBLE_QUOTE = 34;
+var SINGLE_QUOTE = 39;
+var BACKTICK = 96;
+var BACKSLASH = 92;
+var DOLLAR = 36;
+var OPEN_BRACE = 123;
+var CLOSE_BRACE = 125;
+var NEWLINE = 10;
+var SPACE = 32;
+function codesOf(src) {
+  const out = new Uint16Array(src.length);
+  for (let i = 0; i < src.length; i++) out[i] = src.charCodeAt(i);
+  return out;
+}
+var CHUNK = 8192;
+function stringOf(out) {
+  let text = "";
+  for (let i = 0; i < out.length; i += CHUNK) {
+    const end = i + CHUNK < out.length ? i + CHUNK : out.length;
+    text += String.fromCharCode.apply(null, out.subarray(i, end));
+  }
+  return text;
+}
 function blank(out, from, to) {
-  for (let i = from; i < to && i < out.length; i++) {
-    if (out[i] !== "\n") out[i] = " ";
+  const end = to < out.length ? to : out.length;
+  for (let i = from; i < end; i++) {
+    if (out[i] !== NEWLINE) out[i] = SPACE;
   }
 }
 function endOfString(src, start, quote) {
+  const length = src.length;
   let i = start + 1;
-  while (i < src.length) {
-    if (src[i] === "\\") {
+  while (i < length) {
+    const ch = src.charCodeAt(i);
+    if (ch === BACKSLASH) {
       i += 2;
       continue;
     }
-    if (src[i] === quote) return i + 1;
+    if (ch === quote) return i + 1;
     i++;
   }
-  return src.length;
+  return length;
 }
 function maskTemplate(src, out, start) {
+  const length = src.length;
   let i = start + 1;
   let literalFrom = i;
-  while (i < src.length) {
-    if (src[i] === "\\") {
+  while (i < length) {
+    const ch = src.charCodeAt(i);
+    if (ch === BACKSLASH) {
       i += 2;
       continue;
     }
-    if (src[i] === "`") {
+    if (ch === BACKTICK) {
       blank(out, literalFrom, i);
       return i + 1;
     }
-    if (src[i] === "$" && src[i + 1] === "{") {
+    if (ch === DOLLAR && src.charCodeAt(i + 1) === OPEN_BRACE) {
       blank(out, literalFrom, i);
       let depth = 0;
       let j = i + 1;
-      while (j < src.length) {
-        const ch = src[j];
-        const pair = src.slice(j, j + 2);
-        if (pair === "//") {
-          const end = src.indexOf("\n", j);
-          const stop = end === -1 ? src.length : end;
-          blank(out, j, stop);
-          j = stop;
-          continue;
-        }
-        if (pair === "/*") {
-          const close = src.indexOf("*/", j + 2);
-          const stop = close === -1 ? src.length : close + 2;
-          blank(out, j, stop);
-          j = stop;
-          continue;
+      while (j < length) {
+        const inner = src.charCodeAt(j);
+        if (inner === SLASH) {
+          const next = src.charCodeAt(j + 1);
+          if (next === SLASH) {
+            const end = src.indexOf("\n", j);
+            const stop = end === -1 ? length : end;
+            blank(out, j, stop);
+            j = stop;
+            continue;
+          }
+          if (next === STAR) {
+            const close = src.indexOf("*/", j + 2);
+            const stop = close === -1 ? length : close + 2;
+            blank(out, j, stop);
+            j = stop;
+            continue;
+          }
         }
-        if (ch === '"' || ch === "'") {
-          const stop = endOfString(src, j, ch);
+        if (inner === DOUBLE_QUOTE || inner === SINGLE_QUOTE) {
+          const stop = endOfString(src, j, inner);
           blank(out, j + 1, stop - 1);
           j = stop;
           continue;
         }
-        if (ch === "`") {
+        if (inner === BACKTICK) {
           j = maskTemplate(src, out, j);
           continue;
         }
-        if (ch === "{") depth++;
-        else if (ch === "}") {
+        if (inner === OPEN_BRACE) depth++;
+        else if (inner === CLOSE_BRACE) {
           depth--;
           if (depth === 0) {
             j++;
@@ -968,70 +1015,76 @@ function maskTemplate(src, out, start) {
     }
     i++;
   }
-  blank(out, literalFrom, src.length);
-  return src.length;
+  blank(out, literalFrom, length);
+  return length;
 }
 function maskJsComments(src) {
-  const out = src.split("");
+  const length = src.length;
+  const out = codesOf(src);
   let i = 0;
-  while (i < src.length) {
-    const ch = src[i];
-    const two = src.slice(i, i + 2);
-    if (two === "//") {
-      const end = src.indexOf("\n", i);
-      const stop = end === -1 ? src.length : end;
-      blank(out, i, stop);
-      i = stop;
-      continue;
-    }
-    if (two === "/*") {
-      const close = src.indexOf("*/", i + 2);
-      const stop = close === -1 ? src.length : close + 2;
-      blank(out, i, stop);
-      i = stop;
-      continue;
+  while (i < length) {
+    const ch = src.charCodeAt(i);
+    if (ch === SLASH) {
+      const next = src.charCodeAt(i + 1);
+      if (next === SLASH) {
+        const end = src.indexOf("\n", i);
+        const stop = end === -1 ? length : end;
+        blank(out, i, stop);
+        i = stop;
+        continue;
+      }
+      if (next === STAR) {
+        const close = src.indexOf("*/", i + 2);
+        const stop = close === -1 ? length : close + 2;
+        blank(out, i, stop);
+        i = stop;
+        continue;
+      }
     }
-    if (ch === '"' || ch === "'" || ch === "`") {
+    if (ch === DOUBLE_QUOTE || ch === SINGLE_QUOTE || ch === BACKTICK) {
       i = endOfString(src, i, ch);
       continue;
     }
     i++;
   }
-  return out.join("");
+  return stringOf(out);
 }
 function maskJsNoise(src) {
-  const out = src.split("");
+  const length = src.length;
+  const out = codesOf(src);
   let i = 0;
-  while (i < src.length) {
-    const ch = src[i];
-    const two = src.slice(i, i + 2);
-    if (two === "//") {
-      const end = src.indexOf("\n", i);
-      const stop = end === -1 ? src.length : end;
-      blank(out, i, stop);
-      i = stop;
-      continue;
-    }
-    if (two === "/*") {
-      const close = src.indexOf("*/", i + 2);
-      const stop = close === -1 ? src.length : close + 2;
-      blank(out, i, stop);
-      i = stop;
-      continue;
+  while (i < length) {
+    const ch = src.charCodeAt(i);
+    if (ch === SLASH) {
+      const next = src.charCodeAt(i + 1);
+      if (next === SLASH) {
+        const end = src.indexOf("\n", i);
+        const stop = end === -1 ? length : end;
+        blank(out, i, stop);
+        i = stop;
+        continue;
+      }
+      if (next === STAR) {
+        const close = src.indexOf("*/", i + 2);
+        const stop = close === -1 ? length : close + 2;
+        blank(out, i, stop);
+        i = stop;
+        continue;
+      }
     }
-    if (ch === '"' || ch === "'") {
+    if (ch === DOUBLE_QUOTE || ch === SINGLE_QUOTE) {
       const stop = endOfString(src, i, ch);
       blank(out, i + 1, stop - 1);
       i = stop;
       continue;
     }
-    if (ch === "`") {
+    if (ch === BACKTICK) {
       i = maskTemplate(src, out, i);
       continue;
     }
     i++;
   }
-  return out.join("");
+  return stringOf(out);
 }
 var commentCache = /* @__PURE__ */ new WeakMap();
 var noiseCache = /* @__PURE__ */ new WeakMap();
@@ -1122,12 +1175,14 @@ function isClientCode(file) {
   }
   return false;
 }
-function isSupabaseProject(ctx) {
+var MENTIONS_SUPABASE = /supabase/i;
+function isSupabaseProject(ctx, files = ctx.files, scope = "") {
   const isSupabaseUrlName = (name) => name === "SUPABASE_URL" || name.endsWith("_SUPABASE_URL");
-  for (const file of ctx.files) {
-    if (file.path === "supabase" || file.path.startsWith("supabase/")) return true;
-    if (file.path.includes("/supabase/migrations/")) return true;
-    const name = file.path.slice(file.path.lastIndexOf("/") + 1);
+  for (const file of files) {
+    const path = scope === "" ? file.path : file.path.slice(scope.length + 1);
+    if (path === "supabase" || path.startsWith("supabase/")) return true;
+    if (path.includes("/supabase/migrations/")) return true;
+    const name = path.slice(path.lastIndexOf("/") + 1);
     if (isEnvFile(name)) {
       for (const line of file.lines) {
         const entry = parseEnvLine(line);
@@ -1148,6 +1203,7 @@ function isSupabaseProject(ctx) {
       }
       continue;
     }
+    if (!MENTIONS_SUPABASE.test(file.content)) continue;
     const commentsRemoved = commentsMaskedOf(file);
     const code = noiseMaskedOf(file);
     const supabaseImport = /(?:\bfrom\s*|\bimport\s*\(\s*|\brequire\s*\(\s*|\bimport\s*)['"]@supabase\/(?:supabase-js|ssr)(?:\/[^'"]*)?['"]/g;
@@ -1223,18 +1279,17 @@ var secretsRule = {
       if (pat.publicByDesign) continue;
       pat.pattern.lastIndex = 0;
       let match;
-      if (findings.length >= MAX_FINDINGS_PER_FILE) break;
       while ((match = pat.pattern.exec(file.content)) !== null) {
+        const secret = match[0];
+        if (isPlaceholder(secretPartOf(match, pat))) continue;
+        if (pat.ignoreIf?.(match)) continue;
         if (findings.length >= MAX_FINDINGS_PER_FILE) {
           ctx.reportIncomplete(
             "secrets/hardcoded",
             `${file.path} holds more than ${MAX_FINDINGS_PER_FILE} credential-shaped strings; the rest were not reported`
           );
-          break;
+          return findings;
         }
-        const secret = match[0];
-        if (isPlaceholder(secretPartOf(match, pat))) continue;
-        if (pat.ignoreIf?.(match)) continue;
         const line = lineNumberAt(lineStarts, match.index);
         const rawLine = file.lines[line - 1] ?? "";
         const clientSide = isClientCode(file);
@@ -1283,6 +1338,20 @@ var secretsRule = {
 // src/rules/exposure.ts
 import { basename as basename3 } from "path";
 var JWT_SHAPED2 = new RegExp(String.raw`\b${JWT_SOURCE}\b`, "g");
+var FindingBuffer = class {
+  items = [];
+  overflow = false;
+  push(finding) {
+    if (this.items.length < MAX_FINDINGS_PER_FILE) {
+      this.items.push(finding);
+      return;
+    }
+    this.overflow = true;
+    if (finding.confidence !== "certain") return;
+    const index = this.items.findIndex((item) => item.confidence === "likely");
+    if (index !== -1) this.items[index] = finding;
+  }
+};
 function parseEnv(file) {
   const entries = [];
   file.lines.forEach((raw, i) => {
@@ -1299,35 +1368,20 @@ var exposureRule = {
     if (isEnvFile(name)) return true;
     return /\.(ts|tsx|js|jsx|mjs|cjs|svelte|vue|astro)$/.test(name);
   },
-  /**
-   * The ceiling, applied here rather than inside each branch.
-   *
-   * This rule was the last one without one. secrets.ts, firebase.ts and
-   * supabase.ts all cap and all say so — the constant was pulled into limits.ts
-   * precisely so the reasoning would not have to be rediscovered — and exposure
-   * never adopted it. A `.env` holding 3,000 public-prefixed credential names
-   * produced 3,000 findings, 2.36 MB of JSON and 48,046 lines of terminal
-   * output, with `partial` false and `errors` empty: the identical shape of the
-   * bug firebase.ts records in its own comment.
-   *
-   * At the entry point because there are two branches and a future third would
-   * have to remember. Truncating after the fact rather than stopping the loop
-   * keeps that single place honest: the input is already bounded by
-   * MAX_FILE_BYTES, so what this protects is the report, not the scan.
-   */
+  /** 使用有界缓冲区保留结果，超限时记录扫描缺口。 */
   check(file, ctx) {
     const name = basename3(file.path);
     const findings = isEnvFile(name) ? checkEnvFile(file) : checkSourceFile(file);
-    if (findings.length <= MAX_FINDINGS_PER_FILE) return findings;
+    if (!findings.overflow) return findings.items;
     ctx.reportIncomplete(
       "exposure/public-env",
       `${file.path} holds more than ${MAX_FINDINGS_PER_FILE} values exposed to the browser; the rest were not reported`
     );
-    return findings.slice(0, MAX_FINDINGS_PER_FILE);
+    return findings.items;
   }
 };
 function checkEnvFile(file) {
-  const findings = [];
+  const findings = new FindingBuffer();
   for (const entry of parseEnv(file)) {
     const prefix = publicPrefixOf(entry.key);
     if (!prefix) continue;
@@ -1406,7 +1460,7 @@ function checkEnvFile(file) {
   return findings;
 }
 function checkSourceFile(file) {
-  const findings = [];
+  const findings = new FindingBuffer();
   const clientSide = isClientCode(file);
   const commentless = commentsMaskedOf(file).split(/\r?\n/);
   file.lines.forEach((line, i) => {
@@ -1468,6 +1522,7 @@ function checkSourceFile(file) {
 
 // src/rules/gitleak.ts
 import { basename as basename4 } from "path";
+import { createHash } from "crypto";
 function isEnvTemplate(path) {
   return isTemplateName(path);
 }
@@ -1509,6 +1564,41 @@ function git(root, gitExecutable, args) {
     return null;
   }
 }
+function batchBlobs(root, gitExecutable, specs) {
+  if (gitExecutable === null || specs.length === 0) return specs.map(() => null);
+  if (specs.some((spec) => spec.includes("\n") || spec.includes("\r"))) {
+    return specs.map((spec) => git(root, gitExecutable, ["show", "--no-ext-diff", "--no-textconv", spec]));
+  }
+  let out;
+  try {
+    out = execGitBatch(
+      gitExecutable,
+      root,
+      ["cat-file", "--batch", "--buffer"],
+      `${specs.join("\n")}
+`
+    );
+  } catch {
+    return specs.map(() => null);
+  }
+  const blobs = [];
+  let at = 0;
+  for (let i = 0; i < specs.length; i++) {
+    const newline = out.indexOf(10, at);
+    if (newline === -1) break;
+    const header = out.toString("utf8", at, newline);
+    at = newline + 1;
+    const size = Number(header.slice(header.lastIndexOf(" ") + 1));
+    if (!Number.isInteger(size) || size < 0) {
+      blobs.push(null);
+      continue;
+    }
+    blobs.push(out.toString("utf8", at, at + size));
+    at += size + 1;
+  }
+  while (blobs.length < specs.length) blobs.push(null);
+  return blobs;
+}
 function gitOrThrow(root, gitExecutable, args) {
   const out = git(root, gitExecutable, args);
   if (out === null) throw new Error(`git ${args.slice(0, 2).join(" ")} failed in ${root}`);
@@ -1551,29 +1641,43 @@ function historicalEvidence(root, gitExecutable, entry) {
     "--no-textconv",
     "--all",
     "--format=%H",
+    `--max-count=${MAX_HISTORY_REVISIONS + 1}`,
     "--",
     entry.localPath
   ]) ?? "").split(/\r?\n/).filter(Boolean);
   if (all.length === 0) return null;
   const revs = all.slice(0, MAX_HISTORY_REVISIONS);
+  const bodies = batchBlobs(
+    root,
+    gitExecutable,
+    revs.map((rev) => `${rev}:${entry.repoPath}`)
+  );
   let best = "none";
   let unreadable = 0;
-  for (const rev of revs) {
-    const body = git(root, gitExecutable, [
-      "show",
-      "--no-ext-diff",
-      "--no-textconv",
-      `${rev}:${entry.repoPath}`
-    ]);
+  const hintHashes = /* @__PURE__ */ new Set();
+  for (const body of bodies) {
     if (body === null) {
       unreadable++;
       continue;
     }
     const evidence = evidenceIn(body.split(/\r?\n/));
-    if (evidence === "proof") return { evidence: "proof", unread: 0, unreadable };
-    if (evidence === "hint") best = "hint";
+    if (evidence === "proof") return {
+      evidence: "proof",
+      unread: 0,
+      unreadable,
+      sourceFingerprint: createHash("sha256").update(body.trim(), "utf8").digest("hex")
+    };
+    if (evidence === "hint") {
+      best = "hint";
+      hintHashes.add(createHash("sha256").update(body.trim(), "utf8").digest("hex"));
+    }
   }
-  return { evidence: best, unread: all.length - revs.length, unreadable };
+  return {
+    evidence: best,
+    unread: all.length - revs.length,
+    unreadable,
+    sourceFingerprint: createHash("sha256").update([...hintHashes].sort().join("\n")).digest("hex")
+  };
 }
 function hasRemote(root, gitExecutable) {
   const out = git(root, gitExecutable, ["remote"]);
@@ -1615,9 +1719,7 @@ var gitleakRule = {
       findings.push({
         ruleId: "gitleak/env-tracked",
         severity: "P0",
-        // Only claim certainty when the file actually holds something that is
-        // recognisably a credential. Everything else is a committed env file
-        // that might hold one, which is worth saying quietly.
+        // 只有非示例中的明确凭据使用确定置信度。
         confidence: evidence === "proof" && !scaffolding ? "certain" : "likely",
         title: evidence === "proof" && !scaffolding ? `${path} is committed to git, with a credential in it` : `${path} is committed to git`,
         file: path,
@@ -1644,13 +1746,13 @@ var gitleakRule = {
       if (history && history.unread > 0) {
         ctx.reportIncomplete(
           "gitleak/env-in-history",
-          `only the ${MAX_HISTORY_REVISIONS} most recent versions of ${path} were read; ${history.unread} older ${history.unread === 1 ? "version was" : "versions were"} not checked`
+          `only the ${MAX_HISTORY_REVISIONS} most recent versions of ${path} were read; at least ${history.unread} older ${history.unread === 1 ? "version was" : "versions were"} not checked`
         );
       }
       if (history && history.unreadable > 0) {
         ctx.reportIncomplete(
           "gitleak/env-in-history",
-          `${history.unreadable} historical ${history.unreadable === 1 ? "version" : "versions"} of ${path} could not be read with git show; the repository may be incomplete or the file may exceed the Git output limit`
+          `${history.unreadable} historical ${history.unreadable === 1 ? "version" : "versions"} of ${path} could not be read from the repository; the repository may be incomplete or the file may exceed the Git output limit`
         );
       }
       const evidence = history?.evidence ?? "hint";
@@ -1658,9 +1760,9 @@ var gitleakRule = {
       const scaffolding = isScaffolding(path);
       findings.push({
         ruleId: "gitleak/env-in-history",
+        ...history?.sourceFingerprint === void 0 ? {} : { sourceFingerprint: history.sourceFingerprint },
         severity: "P0",
-        // Claiming certainty about a file nobody could read would be the same
-        // overreach the tracked branch just stopped making.
+        // 证据或上下文不足时降低置信度。
         confidence: evidence === "proof" && !scaffolding ? "certain" : "likely",
         title: stillTracked ? `${path} is committed to git, and an older version of it held a credential` : `${path} was removed, but it is still in your git history`,
         file: path,
@@ -1700,28 +1802,41 @@ var INTERNAL_SCHEMAS = /* @__PURE__ */ new Set([
   "pg_catalog"
 ]);
 var IS_DO_BLOCK = /\bdo\s+(?:language\s+\w+\s+)?$/i;
+var DASH = 45;
+var SLASH2 = 47;
+var STAR2 = 42;
+var SINGLE_QUOTE2 = 39;
+var DOUBLE_QUOTE2 = 34;
+var DOLLAR2 = 36;
+var NEWLINE2 = 10;
+var UNDERSCORE = 95;
+function isSpaceCode(code) {
+  if (code === 32 || code >= 9 && code <= 13) return true;
+  return code > 127 && /\s/.test(String.fromCharCode(code));
+}
 function maskSqlNoise(sql) {
-  const out = sql.split("");
+  const length = sql.length;
+  const out = codesOf(sql);
   const erase = (from, to) => blank(out, from, to);
   let i = 0;
-  while (i < sql.length) {
-    const ch = sql[i];
-    const two = sql.slice(i, i + 2);
-    if (two === "--") {
+  while (i < length) {
+    const ch = sql.charCodeAt(i);
+    if (ch === DASH && sql.charCodeAt(i + 1) === DASH) {
       const end = sql.indexOf("\n", i);
-      erase(i, end === -1 ? sql.length : end);
-      i = end === -1 ? sql.length : end;
+      erase(i, end === -1 ? length : end);
+      i = end === -1 ? length : end;
       continue;
     }
-    if (two === "/*") {
+    if (ch === SLASH2 && sql.charCodeAt(i + 1) === STAR2) {
       let depth = 0;
       let j = i;
-      while (j < sql.length) {
-        const pair = sql.slice(j, j + 2);
-        if (pair === "/*") {
+      while (j < length) {
+        const first = sql.charCodeAt(j);
+        const second = sql.charCodeAt(j + 1);
+        if (first === SLASH2 && second === STAR2) {
           depth++;
           j += 2;
-        } else if (pair === "*/") {
+        } else if (first === STAR2 && second === SLASH2) {
           depth--;
           j += 2;
           if (depth === 0) break;
@@ -1733,16 +1848,17 @@ function maskSqlNoise(sql) {
       i = j;
       continue;
     }
-    if (ch === "'") {
+    if (ch === SINGLE_QUOTE2) {
       const escaped = i > 0 && /[Ee]/.test(sql[i - 1] ?? "") && !/[A-Za-z0-9_]/.test(sql[i - 2] ?? "");
       let j = i + 1;
-      while (j < sql.length) {
-        if (escaped && sql[j] === "\\") {
+      while (j < length) {
+        const inner = sql.charCodeAt(j);
+        if (escaped && inner === 92) {
           j += 2;
           continue;
         }
-        if (sql[j] === "'") {
-          if (sql[j + 1] === "'") {
+        if (inner === SINGLE_QUOTE2) {
+          if (sql.charCodeAt(j + 1) === SINGLE_QUOTE2) {
             j += 2;
             continue;
           }
@@ -1755,20 +1871,21 @@ function maskSqlNoise(sql) {
       i = j;
       continue;
     }
-    if (ch === '"') {
+    if (ch === DOUBLE_QUOTE2) {
       let j = i + 1;
-      while (j < sql.length && sql[j] !== '"') {
-        if (/\s/.test(out[j] ?? "") && out[j] !== "\n") out[j] = "_";
+      while (j < length && sql.charCodeAt(j) !== DOUBLE_QUOTE2) {
+        const code = out[j];
+        if (code !== void 0 && code !== NEWLINE2 && isSpaceCode(code)) out[j] = UNDERSCORE;
         j++;
       }
       i = j + 1;
       continue;
     }
-    if (ch === "$") {
+    if (ch === DOLLAR2) {
       const tag = /^\$(?:[A-Za-z_]\w*)?\$/.exec(sql.slice(i))?.[0];
       if (tag) {
         const close = sql.indexOf(tag, i + tag.length);
-        const end = close === -1 ? sql.length : close + tag.length;
+        const end = close === -1 ? length : close + tag.length;
         if (!IS_DO_BLOCK.test(sql.slice(0, i))) erase(i, end);
         i = end;
         continue;
@@ -1776,7 +1893,7 @@ function maskSqlNoise(sql) {
     }
     i++;
   }
-  return out.join("");
+  return stringOf(out);
 }
 function unquote(ident) {
   const quoted = /^"(.*)"$/.exec(ident);
@@ -1865,10 +1982,7 @@ function projectScopeOf(path, scopes) {
   return best;
 }
 function isActiveSupabaseScope(ctx, files, scope) {
-  const rebased = files.map(
-    (file) => scope === "" ? file : { ...file, path: file.path.slice(scope.length + 1) }
-  );
-  return isSupabaseProject({ ...ctx, files: rebased });
+  return isSupabaseProject(ctx, files, scope);
 }
 function replayScopeOf(file, projectScope) {
   return `${file.isExampleContext ? "example" : "project"}:${projectScope}`;
@@ -2122,8 +2236,7 @@ var firebaseRulesRule = {
       findings.push({
         ruleId: "firebase/open-rules",
         severity: "P1",
-        // Open writes are unambiguous. An open read might be intentional
-        // (a public catalogue, announcements), so it stays lower-confidence.
+        // 开放写入为确定结果，公开读取需人工确认。
         confidence: canWrite ? "certain" : "likely",
         title: canWrite ? `Your ${product} rules let anyone ${ops} this data` : `Your ${product} rules make this data publicly readable`,
         file: file.path,
@@ -2161,8 +2274,7 @@ var firebaseRulesRule = {
       findings.push({
         ruleId: "firebase/test-mode-rules",
         severity: "P1",
-        // A hardcoded expiry date is never a deliberate authorisation design,
-        // so this stays certain whether or not writes are involved.
+        // 固定日期测试模式均作为确定配置问题。
         confidence: "certain",
         title: expired ? `Your ${product} rules are in test mode and expired on ${dateStr}` : `Your ${product} rules allow ${ops} to anyone until ${dateStr}`,
         file: file.path,
@@ -2191,7 +2303,10 @@ import { posix } from "path";
 var APP_ROUTER = /(?:^|\/)app\/api\/(?:.+\/)?route\.[mc]?[jt]sx?$/;
 var PAGES_ROUTER = /(?:^|\/)pages\/api\/.+\.[mc]?[jt]sx?$/;
 function isApiRoute(path) {
-  return APP_ROUTER.test(path) || PAGES_ROUTER.test(path);
+  return APP_ROUTER.test(routePathOf(path)) || PAGES_ROUTER.test(path);
+}
+function routePathOf(path) {
+  return path.replace(/(^|\/)\([^/]+\)(?=\/)/g, "$1").replace(/\/{2,}/g, "/");
 }
 var AUTH_ENDPOINT_NAMES = /^\/api\/auth\/(?:sign[-_]?in|sign[-_]?up|sign[-_]?out|log[-_]?in|log[-_]?out|register|session|verify|confirm|reset(?:[-_]password)?|forgot(?:[-_]password)?|magic[-_]?link|otp)$/;
 var AUTH_CALLBACK = /^\/api\/auth\/callback(?:\/[^/]+)?$/;
@@ -2199,7 +2314,7 @@ function isAuthEndpoint(url) {
   return AUTH_ENDPOINT_NAMES.test(url) || AUTH_CALLBACK.test(url);
 }
 function routeUrl(path) {
-  const m = /(?:^|\/)(?:app|pages)\/(api\/.*)$/.exec(path);
+  const m = /(?:^|\/)(?:app|pages)\/(api\/.*)$/.exec(routePathOf(path));
   if (!m) return `/${path}`;
   const url = m[1].replace(/\/route\.[mc]?[jt]sx?$/, "").replace(/\/index\.[mc]?[jt]sx?$/, "").replace(/\.[mc]?[jt]sx?$/, "");
   return `/${url}`;
@@ -2230,17 +2345,37 @@ function controlledStatement(source, afterCondition) {
   return source.slice(start, end);
 }
 function hasConditionalAuthGuard(code) {
-  const starts = code.matchAll(/\bif\s*\(/g);
-  for (const match of starts) {
+  const starts = /\bif\s*\(/g;
+  let match;
+  while ((match = starts.exec(code)) !== null) {
     const open = code.indexOf("(", match.index);
     const close = closingDelimiter(code, open, "(", ")");
     if (close === null) continue;
     const condition = code.slice(open + 1, close);
     const statement = controlledStatement(code, close + 1);
-    const stopsRequest = /\b(?:return|throw|redirect|notFound)\b/.test(statement);
+    const body = statement.startsWith("{") ? statement.slice(1, -1) : statement;
+    const pairs = delimiterPairs(body);
+    let stopsRequest = false;
+    for (let i = 0; i < body.length; i++) {
+      if (/^(?:return|throw|redirect|notFound)\b/.test(body.slice(i, i + 16)) && (i === 0 || !/[\w$]/.test(body[i - 1]))) {
+        stopsRequest = true;
+        break;
+      }
+      if (/^if\s*\(/.test(body.slice(i, i + 16))) break;
+      const end = pairs.get(i);
+      if (end !== void 0) i = end;
+    }
+    let statementStart = close + 1;
+    while (/\s/.test(code[statementStart] ?? "")) statementStart++;
+    starts.lastIndex = statementStart + statement.length;
     if (!stopsRequest) continue;
     const returnsDeniedStatus = /\b(?:return|throw)\b[\s\S]{0,300}\bstatus\s*[:(=]\s*(?:401|403)\b/i.test(statement);
-    if (AUTH_CONDITION.test(condition) || returnsDeniedStatus) return true;
+    const negative = !/&&|\?/.test(condition) && condition.split("||").some((part) => {
+      const term = part.trim();
+      const rejects = /^!\s*[\w$.]+(?:\s*\([^=]*\))?$/.test(term) || /^[\w$.]+\s*={2,3}\s*(?:null|undefined|false)$/.test(term) || /^[\w$.]+\s*!={1,2}\s*(?!(?:null|undefined|false)\b)[\w$.]+$/.test(term);
+      return rejects && (AUTH_CONDITION.test(term) || returnsDeniedStatus);
+    });
+    if (negative) return true;
   }
   return false;
 }
@@ -2248,6 +2383,132 @@ function hasAuthSignal(file) {
   const code = noiseMaskedOf(file);
   return AUTH_ENFORCING_CALL.test(code) || hasConditionalAuthGuard(code);
 }
+function delimiterPairs(code) {
+  const pairs = /* @__PURE__ */ new Map();
+  const stack = [];
+  for (let i = 0; i < code.length; i++) {
+    const ch = code[i];
+    if ("({[".includes(ch)) stack.push(i);
+    else if (")}]".includes(ch)) {
+      const open = stack.pop();
+      if (open !== void 0 && "({[".indexOf(code[open]) === ")}]".indexOf(ch)) {
+        pairs.set(open, i);
+      }
+    }
+  }
+  return pairs;
+}
+function functionBodies(code, pairs) {
+  const bodies = [];
+  for (const match of code.matchAll(/\bfunction\s*\*?\s*(?:\w+\s*)?\(|=>\s*\{/g)) {
+    let body;
+    if (match[0].startsWith("=>")) body = match.index + match[0].length - 1;
+    else {
+      const close = pairs.get(match.index + match[0].length - 1);
+      if (close === void 0) continue;
+      body = close + 1;
+      while (/\s/.test(code[body] ?? "")) body++;
+      if (code[body] === ":") {
+        const type = /^:[\w\s.<>,[\]|?]+(?=\{)/.exec(code.slice(body));
+        if (type) body += type[0].length;
+      }
+    }
+    const end = pairs.get(body);
+    if (code[body] === "{" && end !== void 0) bodies.push({ declaration: match.index, start: body, end });
+  }
+  return bodies;
+}
+function statementEnd(code, start, limit, pairs) {
+  if (code[start] === "{") return (pairs.get(start) ?? limit) + 1;
+  for (let i = start; i < limit; i++) {
+    if (code[i] === ";" || code[i] === "\n") return i + 1;
+    const close = pairs.get(i);
+    if (close !== void 0) i = close;
+  }
+  return limit;
+}
+function unguardedOperations(file, ops) {
+  if (ops.length === 0) return ops;
+  const code = noiseMaskedOf(file);
+  const pairs = delimiterPairs(code);
+  const bodies = functionBodies(code, pairs);
+  const declarations = new Map(bodies.map((body) => [body.declaration, body]));
+  const functionStarts = new Set(bodies.map((body) => body.start));
+  const guardEnds = /* @__PURE__ */ new Map();
+  const blocks = [...pairs].filter(([start]) => code[start] === "{").map(([start, end]) => ({ start, end })).sort((a, b) => a.start - b.start);
+  const active = [];
+  let blockIndex = 0;
+  const wrappers = [...code.matchAll(/\b(?:withAuth|NextAuth)\s*\(/g)].map((match) => {
+    const open = match.index + match[0].length - 1;
+    return { start: open, end: pairs.get(open) ?? open };
+  });
+  const guardEnd = (owner) => {
+    for (let i = owner.start + 1; i < owner.end; i++) {
+      const nested = declarations.get(i);
+      if (nested) {
+        i = nested.end;
+        continue;
+      }
+      if (code.startsWith("=>", i)) {
+        i = statementEnd(code, i + 2, owner.end, pairs) - 1;
+        continue;
+      }
+      if (i > 0 && /[\w$]/.test(code[i - 1])) continue;
+      const conditional = /^if\s*\(/.exec(code.slice(i, i + 32));
+      if (conditional) {
+        const open = i + conditional[0].length - 1;
+        const close2 = pairs.get(open);
+        if (close2 === void 0) return Infinity;
+        let start = close2 + 1;
+        while (/\s/.test(code[start] ?? "")) start++;
+        const end = statementEnd(code, start, owner.end, pairs);
+        if (end <= owner.end && hasConditionalAuthGuard(code.slice(i, end))) return end;
+        i = Math.min(end, owner.end) - 1;
+        continue;
+      }
+      const call = AUTH_ENFORCING_CALL.exec(code.slice(i, i + 100));
+      if (call?.index === 0 && !/^(?:withAuth|NextAuth)\b/i.test(call[0]) && !/\bfunction\s*$/.test(code.slice(Math.max(owner.start, i - 30), i))) {
+        const prefixStart = Math.max(
+          owner.start + 1,
+          code.lastIndexOf(";", i - 1) + 1,
+          code.lastIndexOf("\n", i - 1) + 1
+        );
+        const prefix = code.slice(prefixStart, i).trim();
+        if (/(?:&&|\|\||\?|:)\s*$/.test(code.slice(owner.start + 1, prefixStart))) continue;
+        const awaited = /^(?:await|(?:const|let|var)\s+[\w${},:\s]+?=\s*await)(?:\s+[\w$.]+\.)?$/.test(prefix);
+        const synchronous = /^(?:assertAuth(?:enticated)?|constructEvent)\b/i.test(call[0]) && /^(?:(?:const|let|var)\s+[\w$]+\s*=\s*)?(?:[\w$]+\.)*$/.test(prefix);
+        if (!awaited && !synchronous) continue;
+        const close2 = pairs.get(i + call[0].length - 1);
+        if (close2 !== void 0 && close2 < owner.end) return close2 + 1;
+      }
+      const close = pairs.get(i);
+      if (close !== void 0) i = close;
+    }
+    return Infinity;
+  };
+  return ops.filter((op) => {
+    while (blockIndex < blocks.length && blocks[blockIndex].start < op.index) {
+      const block = blocks[blockIndex++];
+      while (active.length && active[active.length - 1].end < block.start) active.pop();
+      active.push(block);
+    }
+    while (active.length && active[active.length - 1].end < op.index) active.pop();
+    if (wrappers.some((w) => w.start < op.index && w.end > op.index)) return false;
+    let ownerIndex = active.length - 1;
+    while (ownerIndex >= 0 && !functionStarts.has(active[ownerIndex].start)) ownerIndex--;
+    if (ownerIndex < 0) return true;
+    for (let index = ownerIndex; index < active.length; index++) {
+      const block = active[index];
+      let end = guardEnds.get(block.start);
+      if (end === void 0) {
+        end = guardEnd(block);
+        guardEnds.set(block.start, end);
+      }
+      if (end <= op.index) return false;
+    }
+    return true;
+  });
+}
 var CLIENT_CONSTRUCTOR = /\b(?:createClient|createServerClient)\s*(?:<[^()]{0,200}>)?\s*\(/;
 var SERVICE_ROLE_ENV = /\bSUPABASE_SERVICE_ROLE(?:_KEY)?\b|\bSERVICE_ROLE_KEY\b|\bSUPABASE_SECRET_KEY\b/;
 var SERVICE_ROLE_LITERAL = new RegExp(String.raw`['"\`](${JWT_SOURCE}|${SB_SECRET_SOURCE})['"\`]`, "g");
@@ -2314,7 +2575,7 @@ function usesSessionClient(route, sessionModules, allFiles) {
   return buildsSessionClient(route) || importsAnyOf(route, sessionModules, allFiles);
 }
 function moduleScopeOf(routePath) {
-  return /^(.*?)(?:src\/)?(?:app|pages)\/api\//.exec(routePath)?.[1] ?? "";
+  return /^(.*?)(?:src\/)?(?:app|pages)\/api\//.exec(routePathOf(routePath))?.[1] ?? "";
 }
 function importedModules(file, allFiles, aliasScope) {
   const found = [];
@@ -2641,8 +2902,7 @@ var apiAuthRule = {
     const sessionModules = ctx.files.filter(buildsSessionClient);
     const findings = [];
     for (const route of routes) {
-      if (hasAuthSignal(route)) continue;
-      const ops = findDataOps(route);
+      const ops = unguardedOperations(route, findDataOps(route));
       if (ops.length === 0) continue;
       const url = routeUrl(route.path);
       if (isAuthEndpoint(url)) continue;
@@ -2655,9 +2915,7 @@ var apiAuthRule = {
         findings.push({
           ruleId: "api/admin-db-access-without-auth",
           severity: "P0",
-          // Hard evidence: the route runs queries through a key that bypasses
-          // every RLS policy, and nothing in the file or in middleware checks
-          // who sent the request.
+          // 管理员客户端缺少鉴权时使用确定置信度。
           confidence: "certain",
           title: `Anyone can call ${url} and it queries your database as admin`,
           file: route.path,
@@ -2685,9 +2943,7 @@ var apiAuthRule = {
         findings.push({
           ruleId: "api/db-write-without-auth",
           severity: "P1",
-          // Lower confidence on purpose: the write may be legitimately open
-          // (a waitlist, a contact form), and protection can also live in a
-          // deployment-level proxy this scan cannot see.
+          // 公开写入可能是业务设计，保留疑似置信度。
           confidence: "likely",
           title: `${url} writes to your database with no sign-in check`,
           file: route.path,
@@ -2940,8 +3196,7 @@ var corsRule = {
         findings.push({
           ruleId: "cors/reflected-origin-with-credentials",
           severity: "P1",
-          // Both halves are read straight out of the file: the origin is handed
-          // back unchanged, and credentials are allowed. Nothing is inferred.
+          // 明确的来源回显和凭据配置使用确定置信度。
           confidence: "certain",
           title: "Any website can make signed-in requests to your API and read the answer",
           file: file.path,
@@ -2963,8 +3218,7 @@ var corsRule = {
         findings.push({
           ruleId: "cors/wildcard-with-credentials",
           severity: "P2",
-          // Not a judgement call: the specification forbids this pair, so every
-          // browser rejects it.
+          // 通配符与凭据组合违反浏览器跨域约束。
           confidence: "certain",
           title: "This CORS setup is rejected by every browser, so the requests it enables never work",
           file: file.path,
@@ -2990,8 +3244,38 @@ var corsRule = {
 // src/rules/index.ts
 var FILE_RULES = [secretsRule, exposureRule, firebaseRulesRule, corsRule];
 var PROJECT_RULES = [gitleakRule, supabaseRlsRule, apiAuthRule];
+var RULE_IDS = [
+  "api/admin-db-access-without-auth",
+  "api/db-write-without-auth",
+  "cors/reflected-origin-with-credentials",
+  "cors/wildcard-with-credentials",
+  "exposure/private-name-in-public-env",
+  "exposure/secret-in-public-env",
+  "exposure/supabase-service-role-in-client",
+  "firebase/open-rules",
+  "firebase/test-mode-rules",
+  "gitleak/env-in-history",
+  "gitleak/env-tracked",
+  "supabase/rls-not-enabled",
+  // 凭据规则 ID 从共享格式表生成。
+  ...SECRET_PATTERNS.map((p) => `secrets/hardcoded/${p.id}`)
+];
+function ruleMatches(selector, ruleId) {
+  return ruleId === selector || ruleId.startsWith(`${selector}/`);
+}
+function isKnownSelector(selector) {
+  return RULE_IDS.some((id) => ruleMatches(selector, id));
+}
+function shouldRunRule(id, only, skip) {
+  if (only.length === 0 && skip.length === 0) return true;
+  const namespace = id.split("/")[0];
+  return RULE_IDS.filter((candidate) => candidate.startsWith(`${namespace}/`)).some(
+    (candidate) => (only.length === 0 || only.some((selector) => ruleMatches(selector, candidate))) && !skip.some((selector) => ruleMatches(selector, candidate))
+  );
+}
 
 // src/engine.ts
+import { createHash as createHash2 } from "crypto";
 var SEVERITY_ORDER = { P0: 0, P1: 1, P2: 2 };
 var CONFIDENCE_ORDER = { certain: 0, likely: 1 };
 function dedupe(findings) {
@@ -3016,32 +3300,26 @@ function clean(text) {
 function cleanForOutput(text) {
   return clean(text);
 }
-function sanitize(findings) {
+function sanitize(findings, files) {
+  const byPath = new Map(files.map((file) => [file.path, file]));
+  const sourceIdentity = (f) => {
+    if (f.sourceFingerprint !== void 0) return { sourceFingerprint: f.sourceFingerprint };
+    const file = f.file === null ? void 0 : byPath.get(f.file);
+    const source = f.line === null ? file?.content : file?.lines[f.line - 1];
+    return source === void 0 ? {} : {
+      sourceFingerprint: createHash2("sha256").update(source.trim(), "utf8").digest("hex")
+    };
+  };
   return findings.map((f) => ({
     ...f,
+    // 仅输出摘要；原始行不进入报告，移动行号不改变身份。
+    ...sourceIdentity(f),
     title: clean(f.title),
-    // Per paragraph, so the breaks between them survive a cleaner that removes
-    // every newline inside them. See Finding.why.
+    // 按段落清理，保留段落之间的结构。
     why: f.why.map(clean),
-    // The path was left out of this list once, and a filename holding a
-    // credential put it straight back into the JSON, the terminal, the HTML
-    // and the prompt meant for pasting into an assistant.
+    // 文件路径也必须经过输出清理。
     file: f.file === null ? null : clean(f.file),
-    // Redacted first, cut second, and both of them here.
-    //
-    // A rule that trimmed its own excerpt to length before this ran could
-    // defeat the redaction entirely: cutting at 120 characters through the
-    // middle of a key leaves a fragment that matches no pattern, so `clean`
-    // waved it past and nineteen characters of a live OpenAI key reached the
-    // terminal, the JSON, the HTML report and the prompt meant for pasting
-    // into an assistant. The rule was not doing anything unreasonable — it
-    // truncated, which every other rule also does. The order was simply not
-    // its decision to make.
-    //
-    // So rules hand over the whole line and the boundary does both jobs, in
-    // the only order that is safe. Rules that redact per match still may:
-    // masking a known secret before this point is additive, and truncating an
-    // already-truncated string is a no-op.
+    // 先脱敏再截断，避免截断导致凭据特征失效。
     excerpt: f.excerpt === null ? null : truncate(clean(f.excerpt)),
     fix: f.fix.map(clean),
     ...f.humanOnly ? { humanOnly: f.humanOnly.map(clean) } : {}
@@ -3060,6 +3338,45 @@ function downgradeExampleContext(findings, files) {
     (f) => f.file !== null && examples.has(f.file) ? { ...f, confidence: "likely" } : f
   );
 }
+function suppressIgnoredLines(findings, files) {
+  const byPath = new Map(files.map((f) => [f.path, f]));
+  const markers = /* @__PURE__ */ new Map();
+  const kept = [];
+  const ignored = [];
+  for (const f of findings) {
+    if (f.file === null || f.line === null) {
+      kept.push(f);
+      continue;
+    }
+    let lines = markers.get(f.file);
+    if (lines === void 0) {
+      const file = byPath.get(f.file);
+      lines = file === void 0 ? /* @__PURE__ */ new Map() : ignoredLinesOf(file.lines);
+      markers.set(f.file, lines);
+    }
+    if (!lines.has(f.line)) {
+      kept.push(f);
+      continue;
+    }
+    const rules = lines.get(f.line);
+    if (rules !== null && rules !== void 0 && !rules.has(f.ruleId)) {
+      kept.push(f);
+      continue;
+    }
+    ignored.push({ file: f.file, line: f.line, ruleId: f.ruleId });
+  }
+  return { kept, ignored };
+}
+function applyRuleSelection(findings, options) {
+  const only = options.only ?? [];
+  const skip = options.skip ?? [];
+  if (only.length === 0 && skip.length === 0) return { kept: findings, selection: null };
+  const kept = findings.filter((f) => {
+    if (only.length > 0) return only.some((s) => ruleMatches(s, f.ruleId));
+    return !skip.some((s) => ruleMatches(s, f.ruleId));
+  });
+  return { kept, selection: { only, skip, removed: findings.length - kept.length } };
+}
 function sortFindings(findings) {
   return [...findings].sort((a, b) => {
     const bySeverity = SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity];
@@ -3069,26 +3386,22 @@ function sortFindings(findings) {
     return (a.file ?? "").localeCompare(b.file ?? "") || (a.line ?? 0) - (b.line ?? 0);
   });
 }
-async function scan(root) {
+async function scan(root, options = {}) {
   const started = Date.now();
   const gitExecutable = resolveGitExecutable(root);
   const git2 = detectGitRepo(root, gitExecutable);
   const { files, skipped, ignored, vendored } = collectFiles(root, git2 === "repo", gitExecutable);
   const findings = [];
   const errors = [];
+  const fileRules = FILE_RULES.filter((rule) => shouldRunRule(rule.id, options.only ?? [], options.skip ?? []));
+  const projectRules = PROJECT_RULES.filter((rule) => shouldRunRule(rule.id, options.only ?? [], options.skip ?? []));
   const incompleteSeen = /* @__PURE__ */ new Set();
   const ctx = {
     root,
     files,
     git: git2,
     gitExecutable,
-    // Deduplicated here rather than by each rule remembering to report once.
-    // A rule that reaches the same ceiling from two loops over the same file —
-    // firebase does, once for open rules and once for test-mode rules — said
-    // the identical sentence twice, in the terminal's incomplete section and in
-    // the JSON. Saying "part of this did not happen" twice does not make it
-    // twice as true, and a once-flag per rule is the kind of bookkeeping every
-    // new rule would have to remember.
+    // 统一记录不完整状态，避免重复提示。
     reportIncomplete: (ruleId, message) => {
       if (incompleteSeen.has(`${ruleId} ${message}`)) return;
       incompleteSeen.add(`${ruleId} ${message}`);
@@ -3096,24 +3409,40 @@ async function scan(root) {
     }
   };
   for (const file of files) {
-    for (const rule of FILE_RULES) {
-      if (!rule.appliesTo(file)) continue;
+    for (const rule of fileRules) {
       try {
+        if (!rule.appliesTo(file)) continue;
         findings.push(...rule.check(file, ctx));
       } catch (err) {
         errors.push({ ruleId: rule.id, file: file.path, message: messageOf(err), kind: "crashed" });
       }
     }
   }
-  for (const rule of PROJECT_RULES) {
+  for (const rule of projectRules) {
     try {
       findings.push(...await rule.check(ctx));
     } catch (err) {
       errors.push({ ruleId: rule.id, file: null, message: messageOf(err), kind: "crashed" });
     }
   }
+  const { kept, ignored: ignoredFindings } = suppressIgnoredLines(
+    dedupe(downgradeExampleContext(findings, files)),
+    files
+  );
+  const selected = applyRuleSelection(kept, options);
+  const counts = /* @__PURE__ */ new Map();
+  const bounded = sortFindings(selected.kept).filter((finding) => {
+    const count = (counts.get(finding.file) ?? 0) + 1;
+    counts.set(finding.file, count);
+    if (count <= MAX_FINDINGS_PER_FILE) return true;
+    if (count === MAX_FINDINGS_PER_FILE + 1) ctx.reportIncomplete(
+      "engine/findings-limit",
+      `${finding.file ?? "project"} has more than ${MAX_FINDINGS_PER_FILE} findings; remaining findings were not reported`
+    );
+    return false;
+  });
   return {
-    findings: sanitize(sortFindings(dedupe(downgradeExampleContext(findings, files)))),
+    findings: sanitize(bounded, files),
     filesScanned: files.length,
     durationMs: Date.now() - started,
     errors: errors.map((e) => ({
@@ -3123,18 +3452,16 @@ async function scan(root) {
     })),
     skipped: sanitizeSkippedForOutput(skipped),
     ignored: ignored.map(clean),
+    // 清理被忽略结果的路径。
+    ignoredFindings: ignoredFindings.map((f) => ({ ...f, file: clean(f.file) })),
+    // 选择器来自外部输入，输出前也需清理。
+    ruleSelection: selected.selection === null ? null : {
+      only: selected.selection.only.map(clean),
+      skip: selected.selection.skip.map(clean),
+      removed: selected.selection.removed
+    },
     vendored,
-    // A deliberate opt-out is not an incomplete scan: the user made that call
-    // knowingly. It is listed in the report, not treated as a failure.
-    //
-    // Examining no files at all, however, is the purest form of an incomplete
-    // scan, and it used to print a green tick and exit 0 — the exact outcome
-    // the README says must never share an exit code with "clean". It is also
-    // the most likely way to be wrong in practice: the headline command is
-    // `npx canship` with no argument, so running it from the wrong directory
-    // is the ordinary user error, and a directory holding nothing but a
-    // build/ folder (every entry of which the walker skips by design) reaches
-    // zero without looking empty to a human.
+    // 主动忽略不影响完整性；错误、跳过或零文件扫描均标记为未完成。
     partial: errors.length > 0 || skipped.length > 0 || files.length === 0
   };
 }
@@ -3195,6 +3522,26 @@ function skipPhrase(reason) {
 
 // src/report/terminal.ts
 var INDENT = "  ";
+function renderBaseline(opts) {
+  const suppressed = opts.baselineSuppressed ?? 0;
+  const stale = opts.baselineStale ?? 0;
+  if (suppressed === 0 && stale === 0) return [];
+  const out = [];
+  if (suppressed > 0) {
+    const where = opts.baselinePath ? ` (${opts.baselinePath})` : "";
+    out.push(
+      `${INDENT}${yellow(`${suppressed} ${plural(suppressed, "finding")} hidden by the baseline${where}`)}`
+    );
+    out.push(`${INDENT}${dim("These problems still exist. Re-run without --baseline to see them.")}`);
+  }
+  if (stale > 0) {
+    out.push(
+      // 不规则复数单独处理。
+      `${INDENT}${dim(`${stale} baseline ${stale === 1 ? "entry" : "entries"} no longer ${stale === 1 ? "matches" : "match"} anything \u2014 re-run --baseline-write to prune.`)}`
+    );
+  }
+  return out;
+}
 function renderReport(result, opts) {
   const out = [""];
   const { findings } = result;
@@ -3229,6 +3576,7 @@ function renderReport(result, opts) {
     out.push("");
   }
   out.push(...renderIgnored(result));
+  out.push(...renderBaseline(opts));
   if (!opts.showingLikely && opts.hiddenLikely > 0) {
     out.push(
       `${INDENT}${dim(`${opts.hiddenLikely} lower-confidence ${plural(opts.hiddenLikely, "finding")} hidden. Run with --all to see ${opts.hiddenLikely === 1 ? "it" : "them"}.`)}`
@@ -3306,10 +3654,17 @@ function renderClean(result, opts) {
     out.push(
       `${INDENT}${yellow(bold(`! No certain findings \u2014 ${opts.hiddenLikely} lower-confidence ${plural(opts.hiddenLikely, "finding")} hidden`))}`
     );
+  } else if ((opts.baselineSuppressed ?? 0) > 0) {
+    const suppressed = opts.baselineSuppressed ?? 0;
+    out.push(
+      `${INDENT}${yellow(bold(`! No new findings \u2014 ${suppressed} ${plural(suppressed, "finding")} accepted by the baseline`))}`
+    );
   } else {
     out.push(`${INDENT}${green(bold("\u2713 No exposed credentials found"))}`);
   }
   out.push("");
+  out.push(...renderBaseline(opts));
+  if ((opts.baselineSuppressed ?? 0) > 0 || (opts.baselineStale ?? 0) > 0) out.push("");
   out.push(`${INDENT}${dim("canship checked for:")}`);
   out.push(`${INDENT}${dim("  \xB7 API keys hardcoded in source code")}`);
   out.push(`${INDENT}${dim("  \xB7 Server-side secrets exposed to the browser via public env prefixes")}`);
@@ -3324,6 +3679,10 @@ function renderClean(result, opts) {
   out.push(`${INDENT}${dim("did find are the right ones.")}`);
   if (opts.hiddenLikely > 0) {
     out.push(`${INDENT}${dim("This is not a finding-free result. Review the hidden items with --all.")}`);
+  } else if (result.ignoredFindings.length > 0) {
+    out.push(
+      `${INDENT}${dim("This is not a finding-free result \u2014 some were silenced in the source. See below.")}`
+    );
   } else {
     out.push(`${INDENT}${dim("A clean result means these checks passed \u2014 not that your app is secure.")}`);
   }
@@ -3352,6 +3711,20 @@ function renderIgnored(result) {
       `${INDENT}${dim(`${result.ignored.length} ${plural(result.ignored.length, "file")} excluded by canship-ignore-file: ${shown}${more}`)}`
     );
   }
+  if (result.ruleSelection !== null) {
+    const { only, skip, removed } = result.ruleSelection;
+    const which = only.length > 0 ? `only ${only.join(", ")}` : `everything except ${skip.join(", ")}`;
+    const cost = removed > 0 ? `, hiding ${removed} ${plural(removed, "finding")}` : "";
+    out.push(`${INDENT}${dim(`Rule selection in force: ${which}${cost}`)}`);
+  }
+  if (result.ignoredFindings.length > 0) {
+    const n = result.ignoredFindings.length;
+    const shown = result.ignoredFindings.slice(0, 3).map((f) => `${f.file}:${f.line} (${f.ruleId})`).join(", ");
+    const more = n > 3 ? `, and ${n - 3} more` : "";
+    out.push(
+      `${INDENT}${dim(`${n} ${plural(n, "finding")} silenced by canship-ignore-next-line: ${shown}${more}`)}`
+    );
+  }
   if (result.vendored > 0) {
     out.push(
       `${INDENT}${dim(`${result.vendored} ${plural(result.vendored, "file")} skipped inside dependency directories (node_modules, vendor, Pods, .yarn, .pnpm-store)`)}`
@@ -3445,8 +3818,18 @@ function renderFixPrompt(findings, ctx) {
   const incompleteNote = !ctx?.partial ? null : ctx.filesScanned === 0 ? "Note: canship scanned zero files at this path, so none of its file-based checks ran. Do not treat this as a clean result. The path was probably wrong, or everything there is gitignored or build output \u2014 re-run canship pointed at the project source." : "Note: the scan did not finish \u2014 some rules failed or some files could not be read. Fixing what follows does not mean the project is clear; re-run canship once it can complete.";
   const hiddenLikely = ctx?.hiddenLikely ?? 0;
   const hiddenNote = hiddenLikely === 0 ? null : `Note: ${hiddenLikely} lower-confidence ${hiddenLikely === 1 ? "finding was" : "findings were"} hidden by the default view. Do not treat this as a finding-free result. Re-run with --all --fix-prompt to review them.`;
+  const baselineSuppressed = ctx?.baselineSuppressed ?? 0;
+  const silenced = ctx?.silenced ?? [];
+  const suppressedNotes = [
+    !ctx?.ignoredFiles?.length ? null : `Note: ${ctx.ignoredFiles.length} file(s) excluded by canship-ignore-file: ${defuseMarkers(ctx.ignoredFiles.join(", "))}. Their contents were not checked. Do not treat this as a clean result.`,
+    baselineSuppressed === 0 ? null : `Note: ${baselineSuppressed} ${baselineSuppressed === 1 ? "finding was" : "findings were"} hidden by a baseline. Those problems still exist and are not listed below. Re-run without --baseline to see them.`,
+    silenced.length === 0 ? null : `Note: ${silenced.length} ${silenced.length === 1 ? "finding was" : "findings were"} silenced by a canship-ignore-next-line marker in the source, at ${defuseMarkers(silenced.join(", "))}. Those problems still exist and are not listed below.`,
+    !ctx?.ruleSelection ? null : `Note: rules were selected before this list was produced \u2014 ${defuseMarkers(ctx.ruleSelection)}. Findings from the rules that did not run are not listed below.`
+  ].filter((note) => note !== null);
   if (findings.length === 0) {
-    const notes = [incompleteNote, hiddenNote].filter((note) => note !== null);
+    const notes = [incompleteNote, hiddenNote, ...suppressedNotes].filter(
+      (note) => note !== null
+    );
     return notes.length === 0 ? null : `${notes.join("\n\n")}
 `;
   }
@@ -3463,6 +3846,10 @@ function renderFixPrompt(findings, ctx) {
     out.push(hiddenNote);
     out.push("");
   }
+  for (const note of suppressedNotes) {
+    out.push(note);
+    out.push("");
+  }
   if (codeFixable.length > 0) {
     out.push("--- Paste everything below into your coding assistant ---");
     out.push("");
@@ -3539,18 +3926,21 @@ function renderFinding2(f, index) {
 function renderHtml(result, opts) {
   const { findings } = result;
   const hiddenLikely = opts.hiddenLikely ?? 0;
+  const baselineSuppressed = opts.baselineSuppressed ?? 0;
+  const baselineStale = opts.baselineStale ?? 0;
   const { blocking: certain, minor, unsure } = verdictOf(findings);
   const verdict = findings.length === 0 ? result.filesScanned === 0 ? (
-    // Examined nothing, so there is nothing to report either way.
+    // 未扫描文件时不显示通过结论。
     `<div class="verdict warn">No files were scanned &mdash; nothing was checked</div>`
   ) : result.partial ? (
-    // Never the green banner on a partial scan: it reads as a guarantee,
-    // and a scan that skipped files cannot make one.
+    // 扫描不完整时不得显示正常通过。
     hiddenLikely > 0 ? `<div class="verdict warn">No certain findings &mdash; ${hiddenLikely} lower-confidence ${plural(hiddenLikely, "finding")} hidden, and not everything was checked</div>` : `<div class="verdict warn">No findings &mdash; but not everything was checked</div>`
-  ) : hiddenLikely > 0 ? `<div class="verdict warn">No certain findings &mdash; ${hiddenLikely} lower-confidence ${plural(hiddenLikely, "finding")} hidden</div>` : `<div class="verdict clean">No exposed credentials found</div>` : certain > 0 ? `<div class="verdict bad">${certain} critical ${plural(certain, "issue")} &mdash; do not deploy</div>` : minor > 0 ? `<div class="verdict warn">${minor} ${plural(minor, "thing")} to fix &mdash; nothing exposed</div>` : `<div class="verdict warn">${unsure} possible ${plural(unsure, "issue")} to review</div>`;
+  ) : hiddenLikely > 0 ? `<div class="verdict warn">No certain findings &mdash; ${hiddenLikely} lower-confidence ${plural(hiddenLikely, "finding")} hidden</div>` : (
+    // 基线抑制结果时明确说明，避免误报为项目无问题。
+    baselineSuppressed > 0 ? `<div class="verdict warn">No new findings &mdash; ${baselineSuppressed} ${plural(baselineSuppressed, "finding")} accepted by the baseline</div>` : `<div class="verdict clean">No exposed credentials found</div>`
+  ) : certain > 0 ? `<div class="verdict bad">${certain} critical ${plural(certain, "issue")} &mdash; do not deploy</div>` : minor > 0 ? `<div class="verdict warn">${minor} ${plural(minor, "thing")} to fix &mdash; nothing exposed</div>` : `<div class="verdict warn">${unsure} possible ${plural(unsure, "issue")} to review</div>`;
   const body = findings.length === 0 ? result.filesScanned === 0 ? (
-    // The checklist below would be a false statement here: none of those
-    // checks had any input to run against.
+    // 零文件扫描不能显示已完成的检查清单。
     `<div class="clean-note">
            <p>canship found no files it could read at this path, so none of its checks ran.
            <strong>This is not a clean result &mdash; it is an empty one.</strong></p>
@@ -3562,6 +3952,10 @@ function renderHtml(result, opts) {
              <p><strong>This is not a finding-free result.</strong> The default report hides
              ${hiddenLikely} lower-confidence ${plural(hiddenLikely, "finding")}.</p>
              <p>Re-run with <code>--all --report</code> to include ${hiddenLikely === 1 ? "it" : "them"} in the report.</p>
+           </div>` : baselineSuppressed > 0 ? `<div class="clean-note">
+             <p><strong>This is not a finding-free result.</strong> A baseline is hiding
+             ${baselineSuppressed} ${plural(baselineSuppressed, "finding")}${opts.baselinePath ? ` (<code>${esc(opts.baselinePath)}</code>)` : ""}.</p>
+             <p>Those problems still exist. Re-run without <code>--baseline</code> to see ${baselineSuppressed === 1 ? "it" : "them"}.</p>
            </div>` : `<div class="clean-note">
            <p>canship checked for hardcoded API keys, server secrets exposed to the browser,
             Supabase tables without Row Level Security, open Firebase rules, API routes that reach
@@ -3572,14 +3966,16 @@ function renderHtml(result, opts) {
            checks it did find are the right ones.</p>
          </div>` : findings.map((f, i) => renderFinding2(f, i + 1)).join("\n");
   const optedOut = result.ignored.length > 0 ? `<p class="opted-out">${result.ignored.length} ${plural(result.ignored.length, "file")} excluded by <code>canship-ignore-file</code>: ${result.ignored.map((f) => `<code>${esc(f)}</code>`).join(", ")}</p>` : "";
+  const selection = result.ruleSelection;
+  const ruleSelection = selection === null ? "" : `<p class="opted-out">Rule selection in force: ${selection.only.length > 0 ? `only <code>${selection.only.map(esc).join("</code>, <code>")}</code>` : `everything except <code>${selection.skip.map(esc).join("</code>, <code>")}</code>`}${selection.removed > 0 ? `, hiding ${selection.removed} ${plural(selection.removed, "finding")}` : ""}.</p>`;
+  const silenced = result.ignoredFindings.length > 0 ? `<p class="opted-out">${result.ignoredFindings.length} ${plural(result.ignoredFindings.length, "finding")} silenced by <code>canship-ignore-next-line</code>: ${result.ignoredFindings.map((f) => `<code>${esc(f.file)}:${f.line}</code> (${esc(f.ruleId)})`).join(", ")}</p>` : "";
   const hiddenNotice = hiddenLikely > 0 && findings.length > 0 ? `<p class="opted-out">${hiddenLikely} lower-confidence ${plural(hiddenLikely, "finding")} hidden. Re-run with <code>--all --report</code> to include ${hiddenLikely === 1 ? "it" : "them"}.</p>` : "";
+  const baselineNotice = baselineSuppressed > 0 && findings.length > 0 ? `<p class="opted-out">${baselineSuppressed} ${plural(baselineSuppressed, "finding")} hidden by the baseline${opts.baselinePath ? ` (<code>${esc(opts.baselinePath)}</code>)` : ""}. Those problems still exist.</p>` : "";
+  const staleNotice = baselineStale > 0 ? `<p class="opted-out">${baselineStale} baseline ${baselineStale === 1 ? "entry" : "entries"} no longer ${baselineStale === 1 ? "matches" : "match"} anything &mdash; re-run <code>--baseline-write</code> to prune.</p>` : "";
   const incomplete = result.partial ? `<div class="incomplete">
          <h2>Not everything was checked</h2>
          <ul>
-           ${// Reachable with findings present: a repository whose working
-  // tree is entirely gitignored still has a git history, and the
-  // history rule reads it. The findings are real; the file-based
-  // checks simply never ran.
+           ${// 工作区零文件时仍可能产生 Git 历史结果。
   result.filesScanned === 0 ? `<li>no files could be read at this path, so every file-based check was skipped</li>` : ""}
            ${result.errors.map(
     (e) => `<li>the <code>${esc(e.ruleId)}</code> check ${e.kind === "incomplete" ? "did not finish" : "failed"}${e.file ? ` on <code>${esc(e.file)}</code>` : ""} &mdash; ${esc(e.message)}</li>`
@@ -3674,6 +4070,10 @@ function renderHtml(result, opts) {
   ${body}
   ${incomplete}
   ${hiddenNotice}
+  ${baselineNotice}
+  ${staleNotice}
+  ${silenced}
+  ${ruleSelection}
   ${optedOut}
   <footer>
     Generated by canship. Everything ran locally; nothing was uploaded.
@@ -3684,13 +4084,385 @@ function renderHtml(result, opts) {
 `;
 }
 
+// src/baseline.ts
+import { createHash as createHash3 } from "crypto";
+import { readFileSync as readFileSync3, statSync as statSync3, writeFileSync } from "fs";
+var BASELINE_VERSION = 2;
+var DEFAULT_BASELINE_PATH = "canship-baseline.json";
+function fingerprintOf(f) {
+  const identity = [f.ruleId, f.file ?? "", f.title, f.sourceFingerprint ?? f.excerpt ?? ""].join("\0");
+  return createHash3("sha256").update(identity, "utf8").digest("hex");
+}
+function buildBaseline(findings, now = /* @__PURE__ */ new Date()) {
+  const byFingerprint = /* @__PURE__ */ new Map();
+  for (const f of findings) {
+    const fingerprint = fingerprintOf(f);
+    const existing = byFingerprint.get(fingerprint);
+    if (existing) {
+      existing.count++;
+      continue;
+    }
+    byFingerprint.set(fingerprint, {
+      fingerprint,
+      ruleId: f.ruleId,
+      file: f.file,
+      title: f.title,
+      count: 1
+    });
+  }
+  const entries = [...byFingerprint.values()].sort(
+    (a, b) => (a.file ?? "").localeCompare(b.file ?? "") || a.ruleId.localeCompare(b.ruleId) || a.fingerprint.localeCompare(b.fingerprint)
+  );
+  return { version: BASELINE_VERSION, generatedAt: now.toISOString(), entries };
+}
+function serializeBaseline(baseline) {
+  return `${JSON.stringify(baseline, null, 2)}
+`;
+}
+function writeBaseline(path, baseline) {
+  writeFileSync(path, serializeBaseline(baseline), "utf8");
+}
+var BaselineError = class extends Error {
+};
+function isEntry(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const e = value;
+  return typeof e["fingerprint"] === "string" && e["fingerprint"].length > 0 && typeof e["ruleId"] === "string" && (e["file"] === null || typeof e["file"] === "string") && typeof e["title"] === "string" && typeof e["count"] === "number" && Number.isInteger(e["count"]) && e["count"] > 0;
+}
+var MAX_BASELINE_BYTES = 10 * 1024 * 1024;
+function readBaseline(path) {
+  let text;
+  try {
+    const size = statSync3(path).size;
+    if (size > MAX_BASELINE_BYTES) {
+      throw new BaselineError(
+        `baseline ${path} is ${size} bytes, over the ${MAX_BASELINE_BYTES}-byte limit`
+      );
+    }
+    text = readFileSync3(path, "utf8");
+  } catch (err) {
+    if (err instanceof BaselineError) throw err;
+    throw new BaselineError(
+      `could not read baseline ${path}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new BaselineError(`baseline ${path} is not valid JSON`);
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new BaselineError(`baseline ${path} is not a baseline file`);
+  }
+  const obj = parsed;
+  const version = obj["version"];
+  if (version !== BASELINE_VERSION) {
+    throw new BaselineError(
+      `baseline ${path} has version ${String(version)}; this canship reads version ${BASELINE_VERSION}. Review the findings and regenerate the baseline with --baseline-write.`
+    );
+  }
+  const rawEntries = obj["entries"];
+  if (!Array.isArray(rawEntries)) {
+    throw new BaselineError(`baseline ${path} has no entries array`);
+  }
+  const entries = [];
+  for (const [i, raw] of rawEntries.entries()) {
+    if (!isEntry(raw)) throw new BaselineError(`baseline ${path}: entry ${i} is malformed`);
+    entries.push({
+      fingerprint: raw.fingerprint,
+      ruleId: raw.ruleId,
+      file: raw.file,
+      title: raw.title,
+      count: raw.count
+    });
+  }
+  const generatedAt = typeof obj["generatedAt"] === "string" ? obj["generatedAt"] : "";
+  return { version: BASELINE_VERSION, generatedAt, entries };
+}
+function applyBaseline(findings, baseline) {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const entry of baseline.entries) {
+    remaining.set(entry.fingerprint, (remaining.get(entry.fingerprint) ?? 0) + entry.count);
+  }
+  const kept = [];
+  let suppressed = 0;
+  for (const f of findings) {
+    const budget = remaining.get(fingerprintOf(f)) ?? 0;
+    if (budget > 0) {
+      remaining.set(fingerprintOf(f), budget - 1);
+      suppressed++;
+      continue;
+    }
+    kept.push(f);
+  }
+  let stale = 0;
+  for (const left of remaining.values()) stale += left;
+  return { kept, suppressed, stale };
+}
+
+// src/report/sarif.ts
+var INFORMATION_URI = "https://github.com/Tasomei/canship";
+function suppressionNotes(result, opts) {
+  const notes = [];
+  const baseline = opts.baselineSuppressed ?? 0;
+  const hidden = opts.hiddenLikely ?? 0;
+  if (baseline > 0) {
+    notes.push({
+      level: "warning",
+      message: {
+        text: `${baseline} finding${baseline === 1 ? "" : "s"} hidden by a baseline. Those problems still exist.`
+      }
+    });
+  }
+  if (result.ignoredFindings.length > 0) {
+    const where = result.ignoredFindings.map((f) => `${f.file}:${f.line} (${f.ruleId})`).join(", ");
+    notes.push({
+      level: "warning",
+      message: {
+        text: `${result.ignoredFindings.length} finding${result.ignoredFindings.length === 1 ? "" : "s"} silenced by canship-ignore-next-line: ${where}`
+      }
+    });
+  }
+  if (result.ignored.length > 0) {
+    notes.push({
+      level: "warning",
+      message: {
+        text: `${result.ignored.length} file${result.ignored.length === 1 ? "" : "s"} excluded by canship-ignore-file: ${result.ignored.join(", ")}`
+      }
+    });
+  }
+  if (opts.ruleSelection) {
+    notes.push({ level: "warning", message: { text: `Rule selection in force: ${opts.ruleSelection}` } });
+  }
+  if (hidden > 0) {
+    notes.push({
+      level: "warning",
+      message: {
+        text: `${hidden} lower-confidence finding${hidden === 1 ? "" : "s"} not included; re-run with --all.`
+      }
+    });
+  }
+  return notes;
+}
+function levelOf(f) {
+  return f.confidence === "certain" && BLOCKING.has(f.severity) ? "error" : "warning";
+}
+function rulesOf(findings) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const f of findings) if (!seen.has(f.ruleId)) seen.set(f.ruleId, f);
+  return [...seen.entries()].map(([id, f]) => ({
+    id,
+    name: id,
+    shortDescription: { text: f.title },
+    fullDescription: { text: f.why.join(" ") },
+    help: {
+      text: [...f.why, ...f.fix.length > 0 ? ["How to fix:", ...f.fix] : []].join("\n")
+    },
+    properties: {
+      // 工具专属严重度和置信度保存在扩展属性中。
+      "canship-severity": f.severity,
+      "canship-confidence": f.confidence
+    },
+    defaultConfiguration: { level: levelOf(f) }
+  }));
+}
+function resultsOf(findings) {
+  return findings.map((f) => ({
+    ruleId: f.ruleId,
+    level: levelOf(f),
+    message: { text: f.title },
+    // 无可定位文件时不构造虚假位置。
+    locations: f.file === null ? [] : [
+      {
+        physicalLocation: {
+          // 按路径段进行 URI 编码，保留目录分隔符。
+          artifactLocation: { uri: f.file.split("/").map((part) => encodeURIComponent(part)).join("/") },
+          ...f.line === null ? {} : { region: { startLine: f.line } }
+        }
+      }
+    ],
+    partialFingerprints: { canshipFindingV2: fingerprintOf(f) }
+  }));
+}
+function renderSarif(result, opts) {
+  const { findings } = result;
+  const notifications = [
+    ...result.skipped.map((item) => ({
+      level: "warning",
+      message: { text: `${item.path}: ${item.reason}${item.detail ? ` \u2014 ${item.detail}` : ""}` }
+    })),
+    ...result.errors.map((e) => ({
+      level: e.kind === "crashed" ? "error" : "warning",
+      message: { text: `${e.ruleId}: ${e.message}` }
+    })),
+    ...suppressionNotes(result, opts)
+  ];
+  const log = {
+    $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "canship",
+            version: opts.version,
+            informationUri: INFORMATION_URI,
+            rules: rulesOf(findings)
+          }
+        },
+        results: resultsOf(findings),
+        invocations: [
+          {
+            // 该字段表示执行是否完整，与是否发现问题无关。
+            executionSuccessful: !result.partial,
+            ...notifications.length > 0 ? { toolExecutionNotifications: notifications } : {}
+          }
+        ]
+      }
+    ]
+  };
+  return `${JSON.stringify(log, null, 2)}
+`;
+}
+
+// src/config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
+import { join as join3 } from "path";
+var CONFIG_FILENAME = "canship.config.json";
+var REFUSED_KEYS = /* @__PURE__ */ new Map([
+  [
+    "bestEffort",
+    "accepting an incomplete scan is a decision for whoever runs canship, not for the project being scanned \u2014 pass --best-effort instead"
+  ]
+]);
+var ConfigError = class extends Error {
+};
+var KNOWN_KEYS = /* @__PURE__ */ new Set(["baseline", "only", "skip", "all"]);
+function selectors(value, field, path) {
+  if (!Array.isArray(value)) {
+    throw new ConfigError(`${path}: "${field}" must be an array of rule ids`);
+  }
+  const out = [];
+  for (const entry of value) {
+    if (typeof entry !== "string" || entry === "") {
+      throw new ConfigError(`${path}: "${field}" must contain only rule ids`);
+    }
+    if (!isKnownSelector(entry)) {
+      throw new ConfigError(`${path}: "${field}" names no known rule: ${entry}`);
+    }
+    out.push(entry);
+  }
+  return out;
+}
+function boolean(value, field, path) {
+  if (typeof value !== "boolean") throw new ConfigError(`${path}: "${field}" must be true or false`);
+  return value;
+}
+function parseConfig(text, path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new ConfigError(`${path} is not valid JSON`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new ConfigError(`${path} must contain a JSON object`);
+  }
+  const raw = parsed;
+  for (const key of Object.keys(raw)) {
+    const refused = REFUSED_KEYS.get(key);
+    if (refused !== void 0) {
+      throw new ConfigError(`${path}: "${key}" is not allowed here \u2014 ${refused}`);
+    }
+    if (!KNOWN_KEYS.has(key)) {
+      throw new ConfigError(`${path}: unknown setting "${key}"`);
+    }
+  }
+  const config = {};
+  if (raw["baseline"] !== void 0) {
+    if (typeof raw["baseline"] !== "string" || raw["baseline"] === "") {
+      throw new ConfigError(`${path}: "baseline" must be a file path`);
+    }
+    config.baseline = raw["baseline"];
+  }
+  if (raw["only"] !== void 0) config.only = selectors(raw["only"], "only", path);
+  if (raw["skip"] !== void 0) config.skip = selectors(raw["skip"], "skip", path);
+  if (raw["all"] !== void 0) config.all = boolean(raw["all"], "all", path);
+  if (config.only !== void 0 && config.skip !== void 0) {
+    throw new ConfigError(`${path}: "only" and "skip" cannot both be set`);
+  }
+  return config;
+}
+var MAX_CONFIG_BYTES = 1024 * 1024;
+function loadConfig(root) {
+  const path = join3(root, CONFIG_FILENAME);
+  if (!existsSync2(path)) return { config: {}, path: null };
+  let text;
+  try {
+    const size = statSync4(path).size;
+    if (size > MAX_CONFIG_BYTES) {
+      throw new ConfigError(
+        `${path} is ${size} bytes, over the ${MAX_CONFIG_BYTES}-byte limit`
+      );
+    }
+    text = readFileSync4(path, "utf8");
+  } catch (err) {
+    if (err instanceof ConfigError) throw err;
+    throw new ConfigError(
+      `could not read ${path}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return { config: parseConfig(text, path), path };
+}
+
 // src/cli.ts
-var VERSION = true ? "0.1.1" : "0.0.0-dev";
+var VERSION = true ? "0.2.1" : "0.0.0-dev";
 function argumentError(message) {
   process.stderr.write(`canship: ${cleanForOutput(message)}
 `);
   process.exit(3);
 }
+function optionalValue(arg, name, fallback) {
+  if (arg === name) return fallback;
+  if (!arg.startsWith(`${name}=`)) return null;
+  const value = arg.slice(name.length + 1);
+  if (!value) argumentError(`${name}= needs a file path`);
+  return value;
+}
+function insideProject(root, relative3) {
+  const target = resolve2(root, relative3);
+  const inside = relative_(realPathOf(root), realPathOf(target));
+  if (inside === "" || inside.startsWith("..") || isAbsolute2(inside)) {
+    argumentError(
+      `${CONFIG_FILENAME}: "baseline" must stay inside the project, and ${relative3} does not`
+    );
+  }
+  return target;
+}
+function realPathOf(path) {
+  let at = path;
+  const rest = [];
+  for (let depth = 0; depth < MAX_REAL_PATH_DEPTH; depth++) {
+    try {
+      const real = realpathSync2(at);
+      return rest.length === 0 ? real : resolve2(real, ...rest);
+    } catch {
+      const parent = resolve2(at, "..");
+      if (parent === at) return path;
+      rest.unshift(relative_(parent, at));
+      at = parent;
+    }
+  }
+  return path;
+}
+var MAX_REAL_PATH_DEPTH = 64;
+var UNREACHABLE_DEFAULT = "";
+function selectionPhrase(selection) {
+  if (selection === null) return null;
+  const which = selection.only.length > 0 ? `only ${selection.only.join(", ")}` : `everything except ${selection.skip.join(", ")}`;
+  return `${which}, hiding ${selection.removed}`;
+}
 function parseArgs(argv) {
   const args = {
     root: process.cwd(),
@@ -3699,21 +4471,61 @@ function parseArgs(argv) {
     fixPrompt: false,
     report: null,
     bestEffort: false,
+    baseline: null,
+    baselineDefault: false,
+    baselineWrite: null,
+    baselineWriteDefault: false,
+    only: [],
+    skip: [],
+    sarif: null,
+    noConfig: false,
     help: false,
     version: false
   };
   const positional = [];
   for (const arg of argv) {
-    if (arg === "--report") {
-      args.report = "canship-report.html";
+    const list = (name) => {
+      if (!arg.startsWith(`${name}=`)) return null;
+      const value = arg.slice(name.length + 1);
+      if (!value) argumentError(`${name}= needs at least one rule id`);
+      return value.split(",").map((s) => s.trim()).filter(Boolean);
+    };
+    const only = list("--only");
+    if (only !== null) {
+      args.only.push(...only);
       continue;
     }
-    if (arg.startsWith("--report=")) {
-      const value = arg.slice("--report=".length);
-      if (!value) {
-        argumentError("--report= needs a file path");
-      }
-      args.report = value;
+    const skip = list("--skip");
+    if (skip !== null) {
+      args.skip.push(...skip);
+      continue;
+    }
+    const report = optionalValue(arg, "--report", "canship-report.html");
+    if (report !== null) {
+      args.report = report;
+      continue;
+    }
+    if (arg === "--baseline") {
+      args.baselineDefault = true;
+      continue;
+    }
+    const baseline = optionalValue(arg, "--baseline", UNREACHABLE_DEFAULT);
+    if (baseline !== null) {
+      args.baseline = baseline;
+      continue;
+    }
+    if (arg === "--baseline-write") {
+      args.baselineWriteDefault = true;
+      continue;
+    }
+    const baselineWrite = optionalValue(arg, "--baseline-write", UNREACHABLE_DEFAULT);
+    if (baselineWrite !== null) {
+      args.baselineWrite = baselineWrite;
+      continue;
+    }
+    const sarif = optionalValue(arg, "--sarif", "canship.sarif");
+    if (sarif !== null) {
+      args.sarif = sarif;
       continue;
     }
     switch (arg) {
@@ -3730,6 +4542,9 @@ function parseArgs(argv) {
       case "--best-effort":
         args.bestEffort = true;
         break;
+      case "--no-config":
+        args.noConfig = true;
+        break;
       case "--help":
       case "-h":
         args.help = true;
@@ -3764,6 +4579,14 @@ var HELP = `
         --json        Output raw JSON (for CI or tooling)
         --best-effort Allow exit 0 for an incomplete scan with no findings;
                       findings still exit 1 or 2
+        --baseline[=F]       Hide findings already recorded in F, so only new
+                             ones are reported (default ${DEFAULT_BASELINE_PATH})
+        --baseline-write[=F] Record the current findings as a new baseline and exit
+        --only=IDS    Run matching rules (comma-separated, repeatable)
+        --skip=IDS    Exclude matching rules
+        --sarif[=F]   Write a SARIF 2.1.0 log for CI code scanning
+                      (default canship.sarif)
+        --no-config   Ignore canship.config.json in the scanned directory
     -h, --help        Show this help
     -v, --version     Show version
 
@@ -3775,6 +4598,10 @@ var HELP = `
 
   ${dim("--json and --fix-prompt are alternative stdout modes; --report may be combined with either.")}
 
+  ${dim("A baseline hides real findings. Every output says how many it hid.")}
+
+  ${dim(`Settings may also be committed to ${CONFIG_FILENAME}. A flag always wins over the file.`)}
+
   ${dim("Scanned files stay local: no project-code execution, network requests, or uploads.")}
 `;
 async function main() {
@@ -3792,20 +4619,116 @@ async function main() {
   if (args.json && args.fixPrompt) {
     argumentError("--json and --fix-prompt are mutually exclusive");
   }
-  if (!existsSync2(args.root) || !statSync3(args.root).isDirectory()) {
+  if ((args.baseline !== null || args.baselineDefault) && (args.baselineWrite !== null || args.baselineWriteDefault)) {
+    argumentError("--baseline and --baseline-write are mutually exclusive");
+  }
+  if (!existsSync3(args.root) || !statSync5(args.root).isDirectory()) {
     process.stderr.write(`${red("canship:")} not a directory: ${cleanForOutput(args.root)}
 `);
     return process.exit(3);
   }
-  const result = await scan(args.root);
+  let config;
+  try {
+    config = args.noConfig ? {} : loadConfig(args.root).config;
+  } catch (err) {
+    if (err instanceof ConfigError) {
+      process.stderr.write(`${red("canship:")} ${cleanForOutput(err.message)}
+`);
+      return process.exit(3);
+    }
+    throw err;
+  }
+  for (const [field, values] of [
+    ["--only", args.only],
+    ["--skip", args.skip]
+  ]) {
+    for (const selector of values) {
+      if (!isKnownSelector(selector)) {
+        argumentError(`${field} names no known rule: ${selector}`);
+      }
+    }
+  }
+  const cliSelection = args.only.length > 0 || args.skip.length > 0;
+  const only = cliSelection ? args.only : config.only ?? [];
+  const skip = cliSelection ? args.skip : config.skip ?? [];
+  if (only.length > 0 && skip.length > 0) {
+    argumentError("rule selection cannot use both only and skip");
+  }
+  const showAll = args.showAll || config.all === true;
+  const bestEffort = args.bestEffort;
+  const baselinePath = args.baseline !== null ? resolve2(args.baseline) : args.baselineDefault ? resolve2(args.root, DEFAULT_BASELINE_PATH) : config.baseline !== void 0 ? insideProject(args.root, config.baseline) : null;
+  const scanned = await scan(args.root, { only, skip });
+  if (args.baselineWrite !== null || args.baselineWriteDefault) {
+    const target = args.baselineWrite !== null ? resolve2(args.baselineWrite) : resolve2(args.root, DEFAULT_BASELINE_PATH);
+    const baseline = buildBaseline(scanned.findings);
+    try {
+      writeBaseline(target, baseline);
+    } catch (err) {
+      process.stderr.write(
+        `${red("canship:")} could not write baseline to ${cleanForOutput(target)}
+${cleanForOutput(String(err))}
+`
+      );
+      return process.exit(3);
+    }
+    const accepted = scanned.findings.length;
+    process.stdout.write(
+      `
+  ${bold("Baseline written to")} ${cyan(cleanForOutput(target))}
+  ${dim(`${accepted} ${accepted === 1 ? "finding is" : "findings are"} now accepted and will not be reported.`)}
+  ${yellow("These problems still exist.")}
+  ${dim("The file names the path, rule and title of each one \u2014 including findings")}
+  ${dim("in files git does not track, such as .env.local. It holds no credential")}
+  ${dim("values. Commit it so the decision is reviewable; on a public repository,")}
+  ${dim("weigh what that publishes first.")}
+
+`
+    );
+    if (scanned.partial) {
+      process.stderr.write(
+        `${yellow("canship:")} the scan was incomplete, so this baseline may be missing findings.
+`
+      );
+    }
+    if (scanned.ruleSelection !== null) {
+      process.stderr.write(
+        `${yellow("canship:")} rule selection was in force, so this baseline covers only the rules that ran.
+`
+      );
+    }
+    return process.exit(0);
+  }
+  let baselineSuppressed = 0;
+  let baselineStale = 0;
+  let result = scanned;
+  if (baselinePath !== null) {
+    const source = baselinePath;
+    try {
+      const applied = applyBaseline(scanned.findings, readBaseline(source));
+      result = { ...scanned, findings: applied.kept };
+      baselineSuppressed = applied.suppressed;
+      baselineStale = applied.stale;
+    } catch (err) {
+      if (err instanceof BaselineError) {
+        process.stderr.write(`${red("canship:")} ${cleanForOutput(err.message)}
+`);
+        return process.exit(3);
+      }
+      throw err;
+    }
+  }
   const displayRoot = cleanForOutput(args.root);
-  const shown = args.showAll ? result.findings : result.findings.filter((f) => f.confidence === "certain");
-  const hiddenLikely = args.showAll ? 0 : result.findings.filter((f) => f.confidence === "likely").length;
+  const shown = showAll ? result.findings : result.findings.filter((f) => f.confidence === "certain");
+  const hiddenLikely = showAll ? 0 : result.findings.filter((f) => f.confidence === "likely").length;
   if (args.fixPrompt) {
     const prompt = renderFixPrompt(shown, {
       partial: result.partial,
       filesScanned: result.filesScanned,
-      hiddenLikely
+      hiddenLikely,
+      baselineSuppressed,
+      silenced: result.ignoredFindings.map((f) => `${f.file}:${f.line} (${f.ruleId})`),
+      ignoredFiles: result.ignored,
+      ruleSelection: selectionPhrase(result.ruleSelection)
     });
     process.stdout.write(
       prompt === null ? "Nothing to fix \u2014 no findings.\n" : `${prompt}
@@ -3819,16 +4742,19 @@ async function main() {
           root: displayRoot,
           filesScanned: result.filesScanned,
           durationMs: result.durationMs,
-          // Machine consumers need the same distinction humans get: an empty
-          // findings array from a partial scan is not a pass.
+          // 空结果不能掩盖扫描未完成。
           partial: result.partial,
           errors: result.errors,
           skipped: result.skipped,
           ignored: result.ignored,
+          ignoredFindings: result.ignoredFindings,
+          ruleSelection: result.ruleSelection,
           vendored: result.vendored,
-          // The default view hides the detail, never the fact. A machine reading this
-          // must not see "no findings" while lower-confidence ones exist.
+          // 隐藏详情时仍披露疑似结果数量。
           hiddenLikely,
+          // 明确披露基线抑制和过期条目数量。
+          baselineSuppressed,
+          baselineStale,
           findings: shown
         },
         null,
@@ -3840,19 +4766,63 @@ async function main() {
     process.stdout.write(
       `${renderReport(
         { ...result, findings: shown },
-        { root: displayRoot, showingLikely: args.showAll, hiddenLikely }
+        {
+          root: displayRoot,
+          showingLikely: showAll,
+          hiddenLikely,
+          baselineSuppressed,
+          baselineStale,
+          baselinePath: baselinePath === null ? null : cleanForOutput(baselinePath)
+        }
       )}
 `
     );
   }
+  if (args.sarif) {
+    const target = resolve2(args.sarif);
+    try {
+      writeFileSync2(
+        target,
+        renderSarif(
+          { ...result, findings: shown },
+          {
+            version: VERSION,
+            baselineSuppressed,
+            hiddenLikely,
+            ruleSelection: selectionPhrase(result.ruleSelection)
+          }
+        ),
+        "utf8"
+      );
+      if (!args.json && !args.fixPrompt) {
+        process.stdout.write(`  ${dim("SARIF written to")} ${cyan(cleanForOutput(target))}
+
+`);
+      }
+    } catch (err) {
+      process.stderr.write(
+        `${red("canship:")} could not write SARIF to ${cleanForOutput(target)}
+${cleanForOutput(String(err))}
+`
+      );
+      return process.exit(3);
+    }
+  }
   if (args.report) {
     const target = resolve2(args.report);
     try {
-      writeFileSync(
+      writeFileSync2(
         target,
         renderHtml(
           { ...result, findings: shown },
-          { root: displayRoot, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), hiddenLikely }
+          {
+            root: displayRoot,
+            generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            hiddenLikely,
+            baselineSuppressed,
+            baselineStale,
+            baselinePath: baselinePath === null ? null : cleanForOutput(baselinePath)
+          }
         ),
         "utf8"
       );
@@ -3872,7 +4842,7 @@ ${cleanForOutput(String(err))}
   }
   if (verdictOf(result.findings).blocking > 0) return process.exit(1);
   if (result.findings.length > 0) return process.exit(2);
-  if (result.partial && !args.bestEffort) return process.exit(3);
+  if (result.partial && !bestEffort) return process.exit(3);
   return process.exit(0);
 }
 main().catch((err) => {