residoo 0.13.0 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "residoo",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Find secrets leaking through your AI coding agent's session history. Zero network calls in the scan path, zero dependencies.",
   "license": "MIT",
   "author": "CloudRoam (https://cloudroam.io)",

package/src/cli.js

@@ -150,6 +150,14 @@ Scan options:
                           similar characters (0/O, Y/*) can be misread,
                           which breaks an exact-format match, so this is
                           best-effort additional coverage, not a guarantee.
+  --include-pii           also scan for PII: US Social Security Numbers
+                          (dashed format only), credit card numbers
+                          (Luhn-validated), and IBANs (checksum-validated).
+                          A different RISK CATEGORY, not a lower confidence
+                          bar -- residoo is deliberately credentials-only
+                          by default. Deliberately excludes bare email/
+                          phone (too common in ordinary text to meet this
+                          project's own high-confidence bar even opt-in).
 
 Watch:
   residoo watch            continuous scanning instead of one snapshot:
@@ -167,7 +175,8 @@ Watch:
   --verify                same opt-in vendor check as scan --verify,
                           applied to each newly found credential once,
                           never to one already seen
-  --include-noisy, --include-suppressed, --no-color   same meaning as scan
+  --include-noisy, --include-suppressed, --include-pii, --no-color
+                          same meaning as scan
   Ctrl+C stops cleanly and prints a session summary (skipped with --json,
   where the same information is one final NDJSON event).
 
@@ -655,6 +664,7 @@ async function runWatch(args) {
   const includeSuppressed = args.includes("--include-suppressed");
   const verify = args.includes("--verify");
   const noColor = args.includes("--no-color");
+  const includePii = args.includes("--include-pii");
 
   let intervalSeconds = 5;
   const intervalArg = argValue(args, "--interval");
@@ -680,7 +690,7 @@ async function runWatch(args) {
 
   const { promise, stop } = startWatch({
     sources,
-    options: { includeNoisy, includeSuppressed, verify, noColor, json: wantsJson, pollMs: intervalSeconds * 1000 },
+    options: { includeNoisy, includeSuppressed, verify, noColor, includePii, json: wantsJson, pollMs: intervalSeconds * 1000 },
   });
 
   const printFinalSummary = (stats) => {
@@ -918,6 +928,12 @@ async function main(argv) {
   // exact confirmed image shape this looks for and its honest accuracy
   // limitations.
   const wantsOcr = args.includes("--ocr");
+  // --include-pii: a different RISK CATEGORY, not a lower confidence bar
+  // (see pii.js) -- residoo is deliberately credentials-only by default;
+  // this opts into three checksum-validated categories (SSN, Luhn-valid
+  // card numbers, IBAN) rather than the shape-only, much noisier
+  // categories (bare email, phone) some competitors also ship.
+  const wantsPii = args.includes("--include-pii");
 
   // --project [dir]: the dir is optional (CI passes ".", a bare --project
   // means the current directory). null means machine mode.
@@ -1029,7 +1045,7 @@ async function main(argv) {
 
   const progress = makeProgressReporter(noColor);
   const result = await scan({
-    sources, includeNoisy, includeSuppressed, verify, noColor, ocr: wantsOcr,
+    sources, includeNoisy, includeSuppressed, verify, noColor, ocr: wantsOcr, includePii: wantsPii,
     onProgress: progress.onProgress,
     // Clears the spinner's last frame before --verify's own stderr lines
     // print; without this the last spinner line sits uncleared on screen

package/src/mcpTools.js

@@ -50,11 +50,20 @@ function rejectUnknownKeys(args, allowed) {
   return errs;
 }
 
-/** Shared arg shape for residoo_scan/residoo_check: includeNoisy, includeSuppressed, maxEntries. */
+/**
+ * Shared arg shape for residoo_scan/residoo_check: includeNoisy,
+ * includeSuppressed, includePii, maxEntries. includePii is exposed here
+ * (unlike ocr or verify, see this file's own header comment on verify's
+ * exclusion) because it is architecturally identical to includeNoisy --
+ * local-only, no network call, no external process, just a different
+ * detection category (see pii.js) -- not the network/live-secret trust
+ * boundary verify's own exclusion is specifically about.
+ */
 function validateSweepArgs(args, allowedKeys) {
   const errs = rejectUnknownKeys(args, allowedKeys);
   if (args.includeNoisy !== undefined && typeof args.includeNoisy !== "boolean") errs.push("includeNoisy must be a boolean");
   if (args.includeSuppressed !== undefined && typeof args.includeSuppressed !== "boolean") errs.push("includeSuppressed must be a boolean");
+  if (args.includePii !== undefined && typeof args.includePii !== "boolean") errs.push("includePii must be a boolean");
   let maxEntries = 25;
   if (args.maxEntries !== undefined) {
     if (typeof args.maxEntries !== "number" || !Number.isInteger(args.maxEntries) || args.maxEntries < 1 || args.maxEntries > 200) {
@@ -63,7 +72,10 @@ function validateSweepArgs(args, allowedKeys) {
       maxEntries = args.maxEntries;
     }
   }
-  return { errs, includeNoisy: args.includeNoisy === true, includeSuppressed: args.includeSuppressed === true, maxEntries };
+  return {
+    errs, includeNoisy: args.includeNoisy === true, includeSuppressed: args.includeSuppressed === true,
+    includePii: args.includePii === true, maxEntries,
+  };
 }
 
 /** Drop the full step-by-step runbook (redundant once per shared rule id across many entries -- call residoo_explain for that) and any null-valued optional field. */
@@ -122,8 +134,8 @@ function buildTools({ sources }) {
   let checkStarted = false;
 
   async function handleScan(args) {
-    const SCAN_KEYS = new Set(["projectDir", "includeNoisy", "includeSuppressed", "maxEntries"]);
-    const { errs, includeNoisy, includeSuppressed, maxEntries } = validateSweepArgs(args, SCAN_KEYS);
+    const SCAN_KEYS = new Set(["projectDir", "includeNoisy", "includeSuppressed", "includePii", "maxEntries"]);
+    const { errs, includeNoisy, includeSuppressed, includePii, maxEntries } = validateSweepArgs(args, SCAN_KEYS);
     if (args.projectDir !== undefined && typeof args.projectDir !== "string") errs.push("projectDir must be a string");
     if (errs.length) return errorResult(`Invalid arguments: ${errs.join("; ")}`);
 
@@ -140,7 +152,7 @@ function buildTools({ sources }) {
       scanSources = sources;
     }
 
-    const result = await scan({ sources: scanSources, includeNoisy, includeSuppressed, verify: false, noColor: true });
+    const result = await scan({ sources: scanSources, includeNoisy, includeSuppressed, includePii, verify: false, noColor: true });
     const acks = loadAcks();
     const dismissed = loadDismissed();
     const rotation = renderRotation(result.findings, acks, dismissed);
@@ -167,8 +179,8 @@ function buildTools({ sources }) {
   }
 
   async function handleCheck(args) {
-    const CHECK_KEYS = new Set(["includeNoisy", "includeSuppressed", "maxEntries"]);
-    const { errs, includeNoisy, includeSuppressed, maxEntries } = validateSweepArgs(args, CHECK_KEYS);
+    const CHECK_KEYS = new Set(["includeNoisy", "includeSuppressed", "includePii", "maxEntries"]);
+    const { errs, includeNoisy, includeSuppressed, includePii, maxEntries } = validateSweepArgs(args, CHECK_KEYS);
     if (errs.length) return errorResult(`Invalid arguments: ${errs.join("; ")}`);
 
     const firstCheckThisSession = !checkStarted;
@@ -179,7 +191,7 @@ function buildTools({ sources }) {
     const emit = (e) => events.push(e);
     const stats = await sweepOnce({
       sources, tracked: checkTracked, seen: checkSeen, ledger,
-      options: { includeNoisy, includeSuppressed, verify: false, noColor: true }, emit,
+      options: { includeNoisy, includeSuppressed, includePii, verify: false, noColor: true }, emit,
     });
 
     const allNew = events.filter((e) => e.type === "finding");
@@ -353,6 +365,7 @@ function buildTools({ sources }) {
         projectDir: { type: "string", description: "Absolute path to a project/repo directory to scan instead of the machine-wide transcript stores (same as `residoo scan --project <dir>`). Omit for the default machine-wide scan." },
         includeNoisy: { type: "boolean", default: false, description: "Also run residoo's two low-confidence heuristic rules (generic password/secret assignments) -- catches more, false-positives more. Off by default." },
         includeSuppressed: { type: "boolean", default: false, description: "Include matches normally hidden because they look like vendor-documented example values or placeholder text. Off by default." },
+        includePii: { type: "boolean", default: false, description: "Also scan for PII (US Social Security Numbers, Luhn-validated credit card numbers, checksum-validated IBANs) -- a different risk category from a credential, not a lower confidence bar. Off by default; residoo is deliberately credentials-only otherwise." },
         maxEntries: { type: "integer", minimum: 1, maximum: 200, default: 25, description: "Cap on distinct findings returned in full detail, pending-first. Counts in the response are always exact even when the entry list is truncated." },
       },
       required: [],
@@ -368,6 +381,7 @@ function buildTools({ sources }) {
       properties: {
         includeNoisy: { type: "boolean", default: false, description: "Same meaning as residoo_scan." },
         includeSuppressed: { type: "boolean", default: false, description: "Same meaning as residoo_scan." },
+        includePii: { type: "boolean", default: false, description: "Same meaning as residoo_scan." },
         maxEntries: { type: "integer", minimum: 1, maximum: 200, default: 25, description: "Cap on new findings / re-exposures returned in full detail. Counts are always exact even when truncated." },
       },
       required: [],

package/src/pii.js

@@ -0,0 +1,96 @@
+"use strict";
+
+/**
+ * Opt-in PII detection (--include-pii). Named directly by this session's
+ * own competitive research into funded AI-DLP vendors (Strac, Cyberhaven,
+ * Nightfall) as one of the few concrete, buildable things residoo could
+ * adopt without becoming a hosted service -- and independently
+ * corroborated by two direct competitors' own shipped detector lists
+ * (DidILeak, Medusa), both of which cover PII alongside credentials.
+ *
+ * Kept entirely separate from PATTERNS/NOISY_PATTERNS in patterns.js on
+ * purpose: residoo's stated identity elsewhere in this project is
+ * "deliberately credentials-only" (see docs/comparison.md's DidILeak
+ * section), and this module doesn't change that default -- it's a
+ * separate, explicitly opt-in category a user has to ask for, the same
+ * relationship NOISY_PATTERNS already has to the default rule set, just
+ * for a different reason (a different RISK CATEGORY, not a lower
+ * confidence bar).
+ *
+ * Only three detectors, deliberately: DidILeak's own shipped list also
+ * includes bare email addresses and phone numbers, but both are far too
+ * common in ordinary, non-sensitive text (a support email in a comment, a
+ * phone number in an error message) to meet this project's own
+ * "high-confidence only, a security tool that cries wolf gets
+ * uninstalled" bar, opt-in or not -- DidILeak itself rates them "low"/
+ * "info" severity for the same reason. The three included here all have a
+ * REAL mathematical validator, not just a shape match, which is what
+ * keeps false-positive risk low enough to ship even as an additive
+ * category: Luhn for card numbers, ISO 7064 MOD 97-10 for IBAN, and the
+ * Social Security Administration's own published invalid-range rules for
+ * SSNs (no checksum exists for SSNs, hence "medium" confidence there, not
+ * "high" -- disclosed, not smoothed over).
+ */
+
+/** Luhn checksum (ISO/IEC 7812-1): the standard validator for payment card numbers. `digits` must already be digits-only. */
+function luhnValid(digits) {
+  let sum = 0;
+  let alt = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let d = digits.charCodeAt(i) - 48;
+    if (alt) { d *= 2; if (d > 9) d -= 9; }
+    sum += d;
+    alt = !alt;
+  }
+  return sum % 10 === 0;
+}
+
+/**
+ * ISO 7064 MOD 97-10 (the IBAN checksum): move the first 4 characters to
+ * the end, map letters to numbers (A=10..Z=35), and the whole numeral must
+ * be congruent to 1 mod 97. Computed digit-by-digit since the numeral is
+ * far larger than any JS integer.
+ *
+ * Scope, disclosed rather than assumed complete: this checks the generic
+ * ISO 13616 structural rule and the checksum, not each of the ~70
+ * IBAN-issuing countries' own exact fixed length (a German IBAN is always
+ * 22 characters, a French one always 27) -- a real per-country length
+ * table would need to be built and kept current; the checksum alone
+ * already rejects the overwhelming majority of non-IBAN digit/letter runs.
+ */
+function ibanValid(iban) {
+  if (iban.length < 15 || iban.length > 34) return false;
+  const rearranged = iban.slice(4) + iban.slice(0, 4);
+  let mod = 0;
+  for (const ch of rearranged) {
+    const code = ch.charCodeAt(0);
+    const value = code >= 65 && code <= 90 ? code - 55 : code - 48; // A-Z -> 10-35, else digit
+    if (value < 0 || value > 35) return false;
+    const digits = value >= 10 ? String(value) : ch;
+    for (const d of digits) mod = (mod * 10 + (d.charCodeAt(0) - 48)) % 97;
+  }
+  return mod === 1;
+}
+
+const PII_PATTERNS = [
+  // Dashed format only -- a bare 9-digit run is indistinguishable from
+  // countless other numbers in a coding-agent transcript (ports, PIDs,
+  // timestamps) and would make this rule pure noise. Invalid-range
+  // exclusions are the Social Security Administration's own published
+  // rules: area 000, 666, and 900-999 were never issued; group 00 and
+  // serial 0000 are never valid within an otherwise-real-shaped number.
+  { id: "us_ssn", label: "US Social Security Number", confidence: "medium",
+    re: /\b(?!000|666|9\d{2})\d{3}-(?!00)\d{2}-(?!0000)\d{4}\b/g },
+  // Candidate digit runs (13-19 digits, ISO/IEC 7812's own real-world
+  // range, optionally space- or dash-separated the way a human actually
+  // types a card number) are Luhn-validated below before ever being
+  // reported -- the regex alone is not the detector.
+  { id: "credit_card_number", label: "Credit card number (Luhn-validated)", confidence: "high",
+    re: /\b\d(?:[ -]?\d){12,18}\b/g,
+    validate: (m) => { const d = m.replace(/[ -]/g, ""); return d.length >= 13 && d.length <= 19 && luhnValid(d); } },
+  { id: "iban", label: "IBAN (checksum-validated)", confidence: "high",
+    re: /\b[A-Z]{2}\d{2}[A-Z0-9]{11,30}\b/g,
+    validate: (m) => ibanValid(m) },
+];
+
+module.exports = { PII_PATTERNS, luhnValid, ibanValid };

package/src/report.js

@@ -534,15 +534,18 @@ function renderJson(result, integrity = null, rotation = null) {
         rule: f.ruleId, label: f.label, confidence: f.confidence,
         source: f.source, file: f.relFile, line: f.line, preview: f.preview,
         fileMTimeMs: f.fileMTimeMs,
-        // Markers for the decode/reconstruct/OCR passes (absent on ordinary
-        // findings). `encoding` names how the value was wrapped ("base64" /
-        // "base64url"); `spanLines` names the adjacent line pair a split value
-        // was reconstructed across; `ocr` means the value was never plain
-        // text at all -- it was read out of a pasted or tool-returned image
-        // (see ocr.js).
+        // Markers for the decode/reconstruct/OCR/PII passes (absent on
+        // ordinary findings). `encoding` names how the value was wrapped
+        // ("base64" / "base64url"); `spanLines` names the adjacent line
+        // pair a split value was reconstructed across; `ocr` means the
+        // value was never plain text at all -- it was read out of a
+        // pasted or tool-returned image (see ocr.js); `pii` means this is
+        // a --include-pii finding, a different risk category from a
+        // credential, not a rule from the default set (see pii.js).
         ...(f.encoding ? { encoding: f.encoding } : {}),
         ...(f.spanLines ? { spanLines: f.spanLines } : {}),
         ...(f.ocr ? { ocr: true } : {}),
+        ...(f.pii ? { pii: true } : {}),
         fingerprint: fingerprintFinding(f),
         // Only present on an --include-suppressed run: says WHY this finding
         // is low-confidence, so a JSON consumer doesn't have to guess.

package/src/rotation.js

@@ -1146,6 +1146,42 @@ const ROTATION_GUIDANCE = {
     revokeNote: "Revocation is immediate; anything still using the old token starts failing authentication at once.",
   },
 
+  // ── PII (only reachable via --include-pii) ─────────────────────────────
+  // Framed deliberately differently from every entry above: PII has no
+  // issuer to revoke a credential with, no console to rotate it in. The
+  // real action is "should this data exist in this file at all" and, if it
+  // was genuinely exposed to someone who shouldn't have it, who to tell.
+  us_ssn: {
+    label: "US Social Security Number",
+    consolePath: "There is no vendor console for this -- an SSN can't be rotated the way a credential can.",
+    steps: [
+      "Confirm this is a real SSN and not a placeholder/test value (no checksum exists for SSNs, so this rule has no mathematical validator behind it, unlike the two below)",
+      "Remove it from the transcript file if it doesn't need to be there (residoo scan --seal quarantines the whole file without deleting anything, if you want a reversible first step)",
+      "If it was genuinely exposed to someone who shouldn't have it, that's an identity-theft exposure, not an account compromise -- the affected person (you, a customer, an employee) may want to consider a credit freeze or fraud alert with the credit bureaus, not \"rotate a key\"",
+    ],
+    revokeNote: "Unlike every credential rule in this file, there is no revoke/rotate action available at all -- the number itself doesn't change.",
+  },
+  credit_card_number: {
+    label: "Credit card number (Luhn-validated)",
+    consolePath: "The card issuer's own fraud/support line, or your payment processor's dashboard if this is a customer's card, not your own.",
+    steps: [
+      "If it's your own card, most issuers let you freeze or reissue it from their app without waiting for a physical replacement",
+      "If it's a customer's or someone else's card, tell them directly -- they need to contact their own issuer, you can't act on their behalf",
+      "Remove it from the transcript file if it doesn't need to be there",
+    ],
+    revokeNote: "This passed a real Luhn checksum, so it is very unlikely to be a random-looking placeholder -- treat it as a real card number until shown otherwise.",
+  },
+  iban: {
+    label: "IBAN (checksum-validated)",
+    consolePath: "The account holder's own bank.",
+    steps: [
+      "An IBAN alone (without the account holder's separate authentication, e.g. a SEPA mandate) can't usually initiate a transfer by itself, but it's still a real bank account identifier -- treat exposure as a privacy issue even where it isn't immediately a fraud one",
+      "If it's your own account and you're concerned, your bank can advise on IBAN-specific fraud monitoring",
+      "Remove it from the transcript file if it doesn't need to be there",
+    ],
+    revokeNote: "This passed the real ISO 7064 MOD 97-10 checksum every valid IBAN must satisfy, so it is very unlikely to be a random-looking placeholder.",
+  },
+
   // ── NOISY_PATTERNS (only reachable via --include-noisy) ───────────────
   generic_password_assignment: {
     label: "Password assignment (noisy rule)",

package/src/scan.js

@@ -4,6 +4,7 @@ const path = require("path");
 const { PATTERNS, NOISY_PATTERNS, redact } = require("./patterns");
 const { findDecodedMatches, findBoundaryMatches, contentProjection } = require("./decode");
 const { isTesseractAvailable, extractImageBlocks, ocrImageBase64 } = require("./ocr");
+const { PII_PATTERNS } = require("./pii");
 const { findPairedSecret, findNearbyCandidate } = require("./pairing");
 const { looksRandom } = require("./rarity");
 const { decodeJwtExpiryMs } = require("./jwtExpiry");
@@ -272,7 +273,7 @@ function localTimestamp(d) {
  * absolute path can itself carry a username or a project name the rest of
  * this report is careful never to print.
  */
-async function scan({ sources, includeNoisy = false, includeSuppressed = false, onProgress = null, verify = false, verifyOnlyFingerprint = null, onBeforeVerify = null, noColor = false, ocr = false } = {}) {
+async function scan({ sources, includeNoisy = false, includeSuppressed = false, onProgress = null, verify = false, verifyOnlyFingerprint = null, onBeforeVerify = null, noColor = false, ocr = false, includePii = false } = {}) {
   const rules = includeNoisy ? PATTERNS.concat(NOISY_PATTERNS) : PATTERNS;
   // --ocr: checked once, not per line/image -- isTesseractAvailable shells
   // out, and this scan can touch thousands of lines. ocrRequestedButMissing
@@ -600,6 +601,34 @@ async function scan({ sources, includeNoisy = false, includeSuppressed = false,
     }
   };
 
+  // --include-pii: a completely separate pass from every rule above, on
+  // purpose -- PII (see pii.js) is a different RISK CATEGORY from a
+  // credential, not just a lower-confidence version of one, so it gets its
+  // own opt-in flag and its own pass rather than being folded into `rules`.
+  // None of matchLine's AWS-pairing/verification machinery applies to PII
+  // at all, so this mirrors decodeLine/ocrLine's simpler shape, not
+  // matchLine's. `validate` (Luhn, IBAN's MOD 97-10) runs before a
+  // candidate is even considered for suppression -- an invalid checksum
+  // is not a "placeholder," it's simply not a match.
+  const piiLine = (line, file, relFile, lineNo, mtimeMs) => {
+    if (!includePii) return;
+    for (const rule of PII_PATTERNS) {
+      rule.re.lastIndex = 0;
+      let m;
+      while ((m = rule.re.exec(line)) !== null) {
+        if (rule.validate && !rule.validate(m[0])) continue;
+        const before = line.slice(Math.max(0, m.index - CONTEXT_WINDOW), m.index);
+        const suppressedReason = suppressionReason(m[0], before, rule.id);
+        if (suppressedReason && !includeSuppressed) {
+          suppressedCount++;
+          continue;
+        }
+        record(rule, m[0], relFile, file, lineNo, mtimeMs,
+          suppressedReason ? "low" : rule.confidence, suppressedReason, { pii: true });
+      }
+    }
+  };
+
   // Feature 2: split-line boundary join. A finding here means one credential
   // was split across this line and the next and is contiguous on neither. It
   // is recorded against BOTH contributing lines (each holds a fragment of the
@@ -717,6 +746,13 @@ async function scan({ sources, includeNoisy = false, includeSuppressed = false,
               flagFailed();
             }
           }
+          if (includePii) {
+            try {
+              piiLine(line, file, relFile, i + 1, mtimeMs);
+            } catch (err) {
+              flagFailed();
+            }
+          }
           try {
             const content = contentProjection(line);
             // Boundary join with the previous line (2-way splits only; see

package/src/watch.js

@@ -266,14 +266,14 @@ function makeSyntheticSource(realId, batchesByFile) {
  * `verify` is always forced off here: seeding a dedup cache must never be
  * the reason a live vendor API gets hit.
  */
-async function baselineSeed(source, sourceId, file, sizeBytes, mtimeMs, seen, includeNoisy, includeSuppressed, noColor) {
+async function baselineSeed(source, sourceId, file, sizeBytes, mtimeMs, seen, includeNoisy, includeSuppressed, noColor, includePii) {
   const batch = await readWholeFile(source, file, sizeBytes, mtimeMs);
   if (!batch) return;
   let result;
   try {
     result = await scan({
       sources: [makeSyntheticSource(sourceId, new Map([[file, batch]]))],
-      includeNoisy, includeSuppressed, verify: false, noColor,
+      includeNoisy, includeSuppressed, verify: false, noColor, includePii,
     });
   } catch {
     return; // best-effort: a failure here just leaves this file's dedup
@@ -299,7 +299,7 @@ async function baselineSeed(source, sourceId, file, sizeBytes, mtimeMs, seen, in
  * `dismiss` takes effect without a restart.
  */
 async function sweepOnce({ sources, tracked, seen, ledger, options, emit }) {
-  const { includeNoisy, includeSuppressed, verify, noColor } = options || {};
+  const { includeNoisy, includeSuppressed, verify, noColor, includePii } = options || {};
   let loud = 0;
   let quiet = 0;
   let suppressedByLedger = 0;
@@ -363,7 +363,7 @@ async function sweepOnce({ sources, tracked, seen, ledger, options, emit }) {
           contentHash: tailable ? null : wholeFileHash(file),
         });
         if (!tailable) {
-          await baselineSeed(source, sourceId, file, sizeBytes, mtimeMs, seen, includeNoisy, includeSuppressed, noColor);
+          await baselineSeed(source, sourceId, file, sizeBytes, mtimeMs, seen, includeNoisy, includeSuppressed, noColor, includePii);
         }
         continue;
       }
@@ -432,7 +432,7 @@ async function sweepOnce({ sources, tracked, seen, ledger, options, emit }) {
     try {
       result = await scan({
         sources: [makeSyntheticSource(sourceId, batchesByFile)],
-        includeNoisy, includeSuppressed, verify, noColor,
+        includeNoisy, includeSuppressed, verify, noColor, includePii,
       });
     } catch (err) {
       emit({ type: "watch-error", at: new Date(), source: sourceId, detail: "scan failed: " + (err && err.message) });