codiedev 0.9.79 → 0.9.81

package/dist/localScrub.js

@@ -0,0 +1,820 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUN_INTERVAL_MS = exports.MIN_AGE_MS = void 0;
+exports.sessionStores = sessionStores;
+exports.cursorIdeDb = cursorIdeDb;
+exports.cleanJson = cleanJson;
+exports.cleanJsonl = cleanJsonl;
+exports.cleanText = cleanText;
+exports.cleanYaml = cleanYaml;
+exports.cleanFor = cleanFor;
+exports.cleanFile = cleanFile;
+exports.filesOf = filesOf;
+exports.cleanOpenCodeDb = cleanOpenCodeDb;
+exports.countCursorDb = countCursorDb;
+exports.runLocalScrub = runLocalScrub;
+exports.runAndReport = runAndReport;
+exports.scrubPolicy = scrubPolicy;
+exports.scrubAllowed = scrubAllowed;
+exports.formatRules = formatRules;
+exports.runScheduledScrub = runScheduledScrub;
+exports.maybeSpawnLocalScrub = maybeSpawnLocalScrub;
+// Local session scrub: removes keys from the session files every harness keeps
+// on this machine. The server already scrubs what we upload; this cleans the
+// copies left on the laptop (Claude Code, Codex, Cursor, Copilot, OpenCode /
+// Codie harness, pi / Codie pi).
+//
+// Runs in a detached child at most once an hour, started from a session-start
+// hook (Codex: first prompt), and only when the person turned it on in
+// Security → Settings or their company requires it (scrubAllowed). Off by
+// default. `codiedev scrub` runs it by hand regardless. Never touches a session that may be open:
+//   - files changed in the last hour are skipped;
+//   - a cleaned copy is written next to the file and swapped in only if the
+//     file is byte-for-byte unchanged since it was read;
+//   - the original mtime is restored so resume lists keep their order;
+//   - every line of a JSONL file must still parse after cleaning, else that
+//     line is cleaned value by value instead.
+// Uses the same rules as the server (scrub/rules.ts mirrors
+// convex/lib/scrubSecrets.ts), so the laptop and the server agree on what a
+// key is. Never records a key: the state and log hold paths and counts only.
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const extraRules_1 = require("./scrub/extraRules");
+const knownSecrets_1 = require("./knownSecrets");
+const harnessDirs_1 = require("./harnessDirs");
+const copilotHooks_1 = require("./copilotHooks");
+const configDir_1 = require("./configDir");
+const localScrubReport_1 = require("./localScrubReport");
+exports.MIN_AGE_MS = 60 * 60_000;
+exports.RUN_INTERVAL_MS = 60 * 60_000;
+const MAX_FILE_BYTES = 100 * 1024 * 1024;
+const DEFAULT_BUDGET_MS = 2 * 60_000;
+const STATE_VERSION = 1;
+const isJsonl = (f) => f.endsWith(".jsonl");
+/** Every place a harness keeps conversation text on this machine. Snapshots
+ * of the user's own files (Copilot rewind, Claude file-history) are left
+ * alone: cleaning them would change code the user restores later. */
+function sessionStores(env = process.env, home = os.homedir(), stateDir = (0, configDir_1.codiedevStateDir)()) {
+    const claude = (0, harnessDirs_1.claudeConfigDir)(env, home);
+    const codex = (0, harnessDirs_1.codexHome)(env, home);
+    const dataHome = env.XDG_DATA_HOME?.trim() ? path.resolve(env.XDG_DATA_HOME.trim()) : path.join(home, ".local", "share");
+    const openCodeData = path.join(dataHome, "opencode");
+    return [
+        { harness: "claude-code", kind: "jsonl", root: path.join(claude, "projects"), match: isJsonl },
+        { harness: "claude-code", kind: "jsonl", root: path.join(claude, "history.jsonl") },
+        { harness: "codex", kind: "jsonl", root: path.join(codex, "sessions"), match: isJsonl },
+        { harness: "codex", kind: "jsonl", root: path.join(codex, "archived_sessions"), match: isJsonl },
+        { harness: "codex", kind: "jsonl", root: path.join(codex, "history.jsonl") },
+        {
+            harness: "cursor",
+            kind: "jsonl",
+            root: path.join(home, ".cursor", "projects"),
+            match: (f) => isJsonl(f) && f.split(path.sep).includes("agent-transcripts"),
+        },
+        {
+            harness: "copilot",
+            kind: "jsonl",
+            root: path.join((0, copilotHooks_1.copilotHome)(env, home), "session-state"),
+            match: (f) => path.basename(f) === "events.jsonl",
+        },
+        // Copilot puts the session's title/summary (often the first prompt) here.
+        {
+            harness: "copilot",
+            kind: "yaml",
+            root: path.join((0, copilotHooks_1.copilotHome)(env, home), "session-state"),
+            match: (f) => path.basename(f) === "workspace.yaml",
+        },
+        { harness: "pi", kind: "jsonl", root: path.join((0, harnessDirs_1.piAgentDir)(env, home), "sessions"), match: isJsonl },
+        { harness: "pi", kind: "jsonl", root: path.join(stateDir, "managed", "pi", "agent", "sessions"), match: isJsonl },
+        { harness: "opencode", kind: "json", root: path.join(stateDir, "opencode-captures"), match: (f) => f.endsWith(".json") },
+        { harness: "opencode", kind: "text", root: path.join(openCodeData, "tool-output") },
+        { harness: "opencode", kind: "opencode-db", root: path.join(openCodeData, "opencode.db") },
+        // Counted only. cursor-agent resumes chats from these stores.
+        {
+            harness: "cursor",
+            kind: "cursor-agent-db",
+            root: path.join(home, ".cursor", "chats"),
+            match: (f) => path.basename(f) === "store.db",
+        },
+        { harness: "cursor", kind: "cursor-ide-db", root: cursorIdeDb(env, home) },
+    ];
+}
+/** The Cursor IDE's chat database (VS Code layout, per platform). */
+function cursorIdeDb(env = process.env, home = os.homedir(), platform = process.platform) {
+    const base = platform === "darwin"
+        ? path.join(home, "Library", "Application Support")
+        : platform === "win32"
+            ? env.APPDATA || path.join(home, "AppData", "Roaming")
+            : env.XDG_CONFIG_HOME?.trim() || path.join(home, ".config");
+    return path.join(base, "Cursor", "User", "globalStorage", "state.vscdb");
+}
+/** Clean every string inside a parsed JSON value. */
+function cleanValue(value, count) {
+    if (typeof value === "string") {
+        const r = (0, extraRules_1.scrub)(value);
+        count.n += r.redactions.length;
+        return r.text;
+    }
+    if (Array.isArray(value))
+        return value.map((v) => cleanValue(v, count));
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = cleanValue(v, count);
+        return out;
+    }
+    return value;
+}
+function parses(text) {
+    try {
+        JSON.parse(text);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** One JSON document. Cleans the raw text (keeps formatting byte-for-byte
+ * outside the keys); if that would break the JSON, cleans value by value. */
+function cleanJson(text) {
+    const raw = (0, extraRules_1.scrub)(text);
+    if (raw.redactions.length === 0)
+        return { text, redactions: 0 };
+    if (parses(raw.text) || !parses(text))
+        return { text: raw.text, redactions: raw.redactions.length };
+    const count = { n: 0 };
+    const cleaned = cleanValue(JSON.parse(text), count);
+    return { text: JSON.stringify(cleaned), redactions: count.n };
+}
+/** JSONL: each line is its own JSON document. Line endings are kept. */
+function cleanJsonl(text) {
+    const lines = text.split("\n");
+    let redactions = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.trim())
+            continue;
+        const cr = line.endsWith("\r");
+        const body = cr ? line.slice(0, -1) : line;
+        const r = cleanJson(body);
+        if (r.redactions === 0)
+            continue;
+        redactions += r.redactions;
+        lines[i] = cr ? `${r.text}\r` : r.text;
+    }
+    return redactions === 0 ? { text, redactions: 0 } : { text: lines.join("\n"), redactions };
+}
+function cleanText(text) {
+    const r = (0, extraRules_1.scrub)(text);
+    return { text: r.text, redactions: r.redactions.length };
+}
+/** Flat `key: value` YAML. A redaction at the start of an unquoted value
+ * would read as a YAML list (`[REDACTED:…]`), so such values get quoted. */
+function cleanYaml(text) {
+    let redactions = 0;
+    const lines = text.split("\n").map((line) => {
+        const r = (0, extraRules_1.scrub)(line);
+        if (r.redactions.length === 0)
+            return line;
+        redactions += r.redactions.length;
+        const m = r.text.match(/^(\s*[^\s:#][^:]*:\s+)(\[REDACTED:.*?)(\r?)$/);
+        if (!m)
+            return r.text;
+        return `${m[1]}'${m[2].replace(/'/g, "''")}'${m[3]}`;
+    });
+    return redactions === 0 ? { text, redactions: 0 } : { text: lines.join("\n"), redactions };
+}
+function cleanFor(kind, text) {
+    return kind === "jsonl" ? cleanJsonl(text) : kind === "json" ? cleanJson(text) : kind === "yaml" ? cleanYaml(text) : cleanText(text);
+}
+/** Clean one file in place, safely. Returns the outcome, how many keys, and
+ * (when keys were found) which ones plus the session's title and folder. */
+function cleanFile(file, kind, deps) {
+    let before;
+    try {
+        before = fs.statSync(file);
+    }
+    catch {
+        return { outcome: "error", redactions: 0 };
+    }
+    if (deps.now - before.mtimeMs < deps.minAgeMs)
+        return { outcome: "too-recent", redactions: 0 };
+    if (before.size > MAX_FILE_BYTES)
+        return { outcome: "too-large", redactions: 0 };
+    let original;
+    try {
+        original = fs.readFileSync(file);
+    }
+    catch {
+        return { outcome: "error", redactions: 0 };
+    }
+    const originalText = original.toString("utf8");
+    const result = cleanFor(kind, originalText);
+    if (result.redactions === 0)
+        return { outcome: "clean", redactions: 0 };
+    const detail = { keys: (0, localScrubReport_1.keysIn)(originalText), ...(0, localScrubReport_1.describeText)(kind, result.text) };
+    if (deps.dryRun)
+        return { outcome: "would-clean", redactions: result.redactions, detail };
+    const tmp = `${file}.codiedev-scrub-${process.pid}.tmp`;
+    try {
+        fs.writeFileSync(tmp, result.text, { mode: before.mode & 0o777 });
+        deps.beforeSwap?.(file);
+        // Swap only if nobody wrote to the file since we read it.
+        const now = fs.statSync(file);
+        if (now.size !== before.size || now.mtimeMs !== before.mtimeMs || !fs.readFileSync(file).equals(original)) {
+            fs.rmSync(tmp, { force: true });
+            return { outcome: "changed-while-cleaning", redactions: 0 };
+        }
+        fs.renameSync(tmp, file);
+        // Keep the original times so "resume" pickers keep their order.
+        fs.utimesSync(file, before.atime, before.mtime);
+        return { outcome: "cleaned", redactions: result.redactions, detail };
+    }
+    catch {
+        try {
+            fs.rmSync(tmp, { force: true });
+        }
+        catch { /* ignore */ }
+        return { outcome: "error", redactions: 0 };
+    }
+}
+function* walk(root) {
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        const p = path.join(root, e.name);
+        if (e.isDirectory())
+            yield* walk(p);
+        else if (e.isFile() && !e.name.includes(".codiedev-scrub-"))
+            yield p;
+    }
+}
+function filesOf(store) {
+    let st;
+    try {
+        st = fs.statSync(store.root);
+    }
+    catch {
+        return [];
+    }
+    if (st.isFile())
+        return [store.root];
+    const out = [];
+    for (const f of walk(store.root))
+        if (!store.match || store.match(f))
+            out.push(f);
+    return out;
+}
+function openSqlite(file, readOnly = false) {
+    try {
+        // node:sqlite ships with Node 22.5+; older Nodes skip the database.
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { DatabaseSync } = require("node:sqlite");
+        const db = readOnly ? new DatabaseSync(file, { readOnly: true }) : new DatabaseSync(file);
+        db.exec("PRAGMA busy_timeout = 2000");
+        return db;
+    }
+    catch {
+        return null;
+    }
+}
+/** Tables holding conversation JSON in OpenCode 1.x (`opencode.db`). Missing
+ * tables are skipped, so older and newer schemas both work. */
+const OPENCODE_TABLES = [
+    { table: "message", session: "session_id", time: "time_updated" },
+    { table: "part", session: "session_id", time: "time_updated" },
+    { table: "session_message", session: "session_id", time: "time_updated" },
+    { table: "event", session: "aggregate_id" },
+];
+function cleanOpenCodeDb(file, deps) {
+    if (!fs.existsSync(file))
+        return { outcome: "clean", redactions: 0, rows: 0 };
+    const db = openSqlite(file);
+    if (!db)
+        return { outcome: "no-sqlite", redactions: 0, rows: 0 };
+    const sessions = new Map();
+    let redactions = 0;
+    let rows = 0;
+    try {
+        const cutoff = deps.now - deps.minAgeMs;
+        const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((t) => t.name));
+        // A session touched in the last hour may be open: leave all of it alone.
+        const recent = new Set();
+        for (const t of OPENCODE_TABLES) {
+            if (!tables.has(t.table) || !t.time)
+                continue;
+            for (const r of db.prepare(`SELECT DISTINCT ${t.session} AS s FROM ${t.table} WHERE ${t.time} >= ?`).all(cutoff)) {
+                recent.add(r.s);
+            }
+        }
+        const updates = [];
+        for (const t of OPENCODE_TABLES) {
+            if (!tables.has(t.table))
+                continue;
+            const all = db.prepare(`SELECT id, ${t.session} AS s, data FROM ${t.table}`).all();
+            for (const row of all) {
+                if (recent.has(row.s) || typeof row.data !== "string")
+                    continue;
+                if (deps.onlySessions && !deps.onlySessions.has(row.s))
+                    continue;
+                const r = cleanJson(row.data);
+                if (r.redactions === 0)
+                    continue;
+                redactions += r.redactions;
+                updates.push({ table: t.table, id: row.id, data: r.text, before: row.data });
+                const cur = sessions.get(row.s) ?? { keys: [] };
+                // The event log repeats message/part data; count keys once per session.
+                if (t.table !== "event")
+                    cur.keys = (0, localScrubReport_1.mergeKeys)(cur.keys, (0, localScrubReport_1.keysIn)(row.data));
+                sessions.set(row.s, cur);
+            }
+        }
+        rows = updates.length;
+        if (rows === 0)
+            return { outcome: "clean", redactions: 0, rows: 0 };
+        if (tables.has("session")) {
+            const get = db.prepare("SELECT title, directory FROM session WHERE id = ?");
+            for (const [id, d] of sessions) {
+                const row = get.all(id)[0];
+                if (typeof row?.title === "string")
+                    d.title = (0, extraRules_1.scrub)(row.title).text.slice(0, 80);
+                if (typeof row?.directory === "string")
+                    d.cwd = row.directory;
+            }
+        }
+        if (deps.dryRun)
+            return { outcome: "would-clean", redactions, rows, sessions };
+        db.exec("BEGIN IMMEDIATE");
+        try {
+            // Only touch rows still exactly as we read them.
+            for (const u of updates) {
+                db.prepare(`UPDATE ${u.table} SET data = ? WHERE id = ? AND data = ?`).run(u.data, u.id, u.before);
+            }
+            db.exec("COMMIT");
+        }
+        catch (e) {
+            try {
+                db.exec("ROLLBACK");
+            }
+            catch { /* ignore */ }
+            throw e;
+        }
+        return { outcome: "cleaned", redactions, rows, sessions };
+    }
+    catch {
+        return { outcome: "error", redactions: 0, rows: 0 };
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch { /* ignore */ }
+    }
+}
+function decodeMetaName(hexOrJson) {
+    try {
+        const text = /^[0-9a-f]+$/i.test(hexOrJson) ? Buffer.from(hexOrJson, "hex").toString("utf8") : hexOrJson;
+        const name = JSON.parse(text).name;
+        return typeof name === "string" ? name : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function countCursorDb(file, kind) {
+    const db = openSqlite(file, true);
+    if (!db)
+        return null;
+    try {
+        const rows = (kind === "cursor-agent-db"
+            ? db.prepare("SELECT data AS v FROM blobs").all()
+            : db.prepare("SELECT key AS k, value AS v FROM cursorDiskKV WHERE key LIKE 'bubbleId:%' OR key LIKE 'composerData:%'").all());
+        const chats = new Map();
+        const titles = new Map();
+        // One store.db is one chat, named by its folder (the agent id).
+        const agentChat = path.basename(path.dirname(file));
+        for (const row of rows) {
+            const text = typeof row.v === "string" ? row.v : row.v instanceof Uint8Array ? Buffer.from(row.v).toString("latin1") : "";
+            if (!text)
+                continue;
+            // IDE rows are keyed bubbleId:<composerId>:<bubbleId> / composerData:<composerId>.
+            const chat = kind === "cursor-agent-db" ? agentChat : (row.k ?? "").split(":")[1] ?? "";
+            if (kind === "cursor-ide-db" && row.k?.startsWith("composerData:")) {
+                const name = decodeMetaName(text);
+                if (name)
+                    titles.set(chat, name);
+            }
+            const keys = (0, localScrubReport_1.keysIn)(text);
+            if (keys.length === 0)
+                continue;
+            chats.set(chat, (0, localScrubReport_1.mergeKeys)(chats.get(chat) ?? [], keys));
+        }
+        if (kind === "cursor-agent-db" && chats.size > 0) {
+            try {
+                const meta = db.prepare("SELECT value AS v FROM meta").all();
+                for (const m of meta) {
+                    const name = decodeMetaName(String(m.v));
+                    if (name)
+                        titles.set(agentChat, name);
+                }
+            }
+            catch { /* no meta */ }
+        }
+        const details = [...chats].map(([chat, keys]) => ({
+            harness: "cursor",
+            sessionKey: chat,
+            ...(titles.get(chat) ? { title: (0, extraRules_1.scrub)(titles.get(chat)).text.slice(0, 80) } : {}),
+            keys,
+            status: "not_removed",
+            reason: "cursor_chat_store",
+        }));
+        return { keys: details.reduce((n, d) => n + d.keys.reduce((m, k) => m + k.count, 0), 0), chats: details.length, details };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch { /* ignore */ }
+    }
+}
+const scrubDir = (stateDir) => path.join(stateDir, "local-scrub");
+/** Changes whenever the rule set changes, so new rules re-check old files. */
+function rulesFingerprint() {
+    try {
+        const src = fs.readFileSync(path.join(__dirname, "scrub", "rules.js"), "utf8");
+        let h = 0;
+        for (let i = 0; i < src.length; i++)
+            h = (h * 31 + src.charCodeAt(i)) | 0;
+        return String(h);
+    }
+    catch {
+        return "unknown";
+    }
+}
+function readState(dir, rules) {
+    try {
+        const s = JSON.parse(fs.readFileSync(path.join(dir, "state.json"), "utf8"));
+        if (s.version === STATE_VERSION && s.rules === rules && s.files)
+            return s;
+    }
+    catch { /* fresh */ }
+    return { version: STATE_VERSION, rules, files: {} };
+}
+function writeAtomic(file, text) {
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, text, { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+function runLocalScrub(opts = {}) {
+    const now = opts.now ?? Date.now();
+    const deps = {
+        now,
+        minAgeMs: opts.minAgeMs ?? exports.MIN_AGE_MS,
+        dryRun: Boolean(opts.dryRun),
+        ...(opts.onlySessions ? { onlySessions: new Set(opts.onlySessions) } : {}),
+    };
+    const started = Date.now();
+    const budget = opts.budgetMs ?? DEFAULT_BUDGET_MS;
+    const stateDir = opts.stateDir ?? (0, configDir_1.codiedevStateDir)();
+    const dir = scrubDir(stateDir);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const rules = rulesFingerprint();
+    const state = readState(dir, rules);
+    const only = opts.only ? new Set(opts.only.map((p) => path.resolve(p))) : null;
+    const summary = {
+        dryRun: deps.dryRun, scanned: 0, cleaned: 0, redactions: 0, skippedRecent: 0, skippedLarge: 0,
+        changedWhileCleaning: 0, errors: 0, unfinished: false, byHarness: {}, leftInCursor: { keys: 0, chats: 0 }, sessions: [],
+    };
+    const found = new Map();
+    const detect = (harness, sessionKey, d) => {
+        const id = `${harness}\u0000${sessionKey}`;
+        const cur = found.get(id);
+        if (cur) {
+            cur.keys = (0, localScrubReport_1.mergeKeys)(cur.keys, d.keys);
+            cur.title ??= d.title;
+            cur.cwd ??= d.cwd;
+        }
+        else {
+            found.set(id, { harness, sessionKey, ...(d.title ? { title: d.title } : {}), ...(d.cwd ? { cwd: d.cwd } : {}), keys: d.keys, status: "removed" });
+        }
+    };
+    const counted = (state.counted ??= {});
+    const tally = (h, n) => {
+        const t = (summary.byHarness[h] ??= { files: 0, redactions: 0 });
+        t.files += 1;
+        t.redactions += n;
+    };
+    outer: for (const store of opts.stores ?? sessionStores(process.env, os.homedir(), stateDir)) {
+        if (store.kind === "cursor-agent-db" || store.kind === "cursor-ide-db") {
+            if (only || opts.onlySessions)
+                continue;
+            for (const file of filesOf(store)) {
+                let sig;
+                try {
+                    const st = fs.statSync(file);
+                    // A WAL holds the newest rows; include it so new chats are re-counted.
+                    let wal = "";
+                    try {
+                        const w = fs.statSync(`${file}-wal`);
+                        wal = `:${w.size}:${w.mtimeMs}`;
+                    }
+                    catch { /* no wal */ }
+                    sig = `${st.size}:${st.mtimeMs}${wal}`;
+                }
+                catch {
+                    continue;
+                }
+                if (counted[file]?.sig !== sig) {
+                    const c = countCursorDb(file, store.kind);
+                    if (!c)
+                        continue;
+                    counted[file] = { sig, ...c };
+                }
+            }
+            continue;
+        }
+        if (store.kind === "opencode-db") {
+            if (only && !only.has(path.resolve(store.root)))
+                continue;
+            const r = cleanOpenCodeDb(store.root, deps);
+            if (r.outcome === "no-sqlite")
+                continue;
+            summary.scanned += 1;
+            if (r.outcome === "error")
+                summary.errors += 1;
+            if (r.redactions > 0) {
+                summary.redactions += r.redactions;
+                if (r.outcome === "cleaned")
+                    summary.cleaned += 1;
+                tally(store.harness, r.redactions);
+                for (const [id, d] of r.sessions ?? [])
+                    detect(store.harness, id, d);
+            }
+            continue;
+        }
+        for (const file of filesOf(store)) {
+            // --session targets the OpenCode database only; files need --path.
+            if ((only || opts.onlySessions) && !only?.has(path.resolve(file)))
+                continue;
+            if (Date.now() - started > budget) {
+                summary.unfinished = true;
+                break outer;
+            }
+            let st;
+            try {
+                st = fs.statSync(file);
+            }
+            catch {
+                continue;
+            }
+            const sig = `${st.size}:${st.mtimeMs}`;
+            if (!only && state.files[file] === sig)
+                continue; // unchanged since last check
+            summary.scanned += 1;
+            const r = cleanFile(file, store.kind, deps);
+            switch (r.outcome) {
+                case "too-recent":
+                    summary.skippedRecent += 1;
+                    break;
+                case "too-large":
+                    summary.skippedLarge += 1;
+                    state.files[file] = sig;
+                    break;
+                case "changed-while-cleaning":
+                    summary.changedWhileCleaning += 1;
+                    break;
+                case "error":
+                    summary.errors += 1;
+                    break;
+                case "clean":
+                    state.files[file] = sig;
+                    break;
+                case "would-clean":
+                    summary.redactions += r.redactions;
+                    tally(store.harness, r.redactions);
+                    if (r.detail)
+                        detect(store.harness, (0, localScrubReport_1.sessionKeyOf)(store.harness, file), r.detail);
+                    break;
+                case "cleaned": {
+                    summary.cleaned += 1;
+                    summary.redactions += r.redactions;
+                    tally(store.harness, r.redactions);
+                    if (r.detail)
+                        detect(store.harness, (0, localScrubReport_1.sessionKeyOf)(store.harness, file), r.detail);
+                    try {
+                        const after = fs.statSync(file);
+                        state.files[file] = `${after.size}:${after.mtimeMs}`;
+                    }
+                    catch { /* next run re-checks */ }
+                    break;
+                }
+            }
+        }
+    }
+    for (const [f, c] of Object.entries(counted)) {
+        if (!fs.existsSync(f)) {
+            delete counted[f];
+            continue;
+        }
+        if (only || opts.onlySessions)
+            continue;
+        summary.leftInCursor.keys += c.keys;
+        summary.leftInCursor.chats += c.chats;
+        summary.sessions.push(...(c.details ?? []));
+    }
+    summary.sessions.unshift(...found.values());
+    if (!deps.dryRun) {
+        // Forget files that no longer exist so the state doesn't grow forever.
+        for (const f of Object.keys(state.files))
+            if (!fs.existsSync(f))
+                delete state.files[f];
+        try {
+            writeAtomic(path.join(dir, "state.json"), JSON.stringify(state));
+        }
+        catch { /* ignore */ }
+        try {
+            fs.appendFileSync(path.join(dir, "log.jsonl"), JSON.stringify({ at: new Date(now).toISOString(), ...summary }) + "\n", { mode: 0o600 });
+        }
+        catch { /* ignore */ }
+    }
+    return summary;
+}
+// ---------------------------------------------------------------------------
+// Run and report (the background child and `codiedev scrub`)
+// ---------------------------------------------------------------------------
+/** Run the scrub and send the audit to Codiedev when connected. Dry runs and
+ * runs limited by --path/--session are never sent. */
+async function runAndReport(opts = {}) {
+    const at = opts.now ?? Date.now();
+    const summary = runLocalScrub(opts);
+    let reported = false;
+    if (!summary.dryRun && !opts.only && !opts.onlySessions) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { readConfig } = require("./utils");
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { CLI_VERSION } = require("./version");
+            const { buildReport, machineId, sendReport } = await Promise.resolve().then(() => __importStar(require("./localScrubReport")));
+            const config = readConfig();
+            if (config?.token && config.backendUrl) {
+                const payload = buildReport({
+                    machineId: machineId(scrubDir(opts.stateDir ?? (0, configDir_1.codiedevStateDir)())),
+                    at,
+                    complete: !summary.unfinished,
+                    summary,
+                    sessions: summary.sessions,
+                    ignoredPaths: config.captureIgnoredPaths,
+                });
+                reported = await sendReport(config.backendUrl, config.token, payload, CLI_VERSION);
+            }
+        }
+        catch { /* best-effort */ }
+    }
+    return { ...summary, reported };
+}
+const defaultConfig = () => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { readConfig } = require("./utils");
+    return readConfig();
+};
+const OFF = { enabled: false, formats: [], ownSecrets: "off" };
+async function scrubPolicy(fetchImpl = fetch, getConfig = defaultConfig) {
+    try {
+        const config = getConfig();
+        if (!config?.token || !config.backendUrl)
+            return OFF;
+        const res = await fetchImpl(`${config.backendUrl}/api/cli/localScrubPolicy`, {
+            headers: { Authorization: `Bearer ${config.token}` },
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok)
+            return OFF;
+        const body = (await res.json());
+        const formats = Array.isArray(body.formats)
+            ? body.formats.filter((f) => f && typeof f.name === "string" && typeof f.source === "string" && f.source.length <= 300).slice(0, 50)
+            : [];
+        // An older server says nothing: match on the laptop, send nothing.
+        const ownSecrets = body.ownSecrets === "off" || body.ownSecrets === "server" ? body.ownSecrets : "laptop";
+        const key = typeof body.fingerprintKey === "string" && /^[0-9a-f]{64}$/.test(body.fingerprintKey) ? body.fingerprintKey : undefined;
+        return { enabled: body.enabled === true, formats, ownSecrets, ...(key ? { fingerprintKey: key } : {}) };
+    }
+    catch {
+        return OFF;
+    }
+}
+/** Should this person's machine run the background scrub? */
+async function scrubAllowed(fetchImpl = fetch, getConfig = defaultConfig) {
+    return (await scrubPolicy(fetchImpl, getConfig)).enabled;
+}
+/** Turn the company's token formats into scrub rules; a bad one is skipped. */
+function formatRules(formats) {
+    const out = [];
+    for (const f of formats) {
+        try {
+            out.push({ name: `custom:${f.name}`, re: new RegExp(`(?<![A-Za-z0-9])${f.source}(?![A-Za-z0-9_-])`, "g"), ...(f.keyword ? { keywords: [f.keyword] } : {}) });
+        }
+        catch { /* skip */ }
+    }
+    return out;
+}
+/** The scheduled run: policy check, then this person's own secrets (as the
+ *  admin set it: not read / matched here / also keyed fingerprints to the
+ *  server) and the company's formats, then the scrub and its report. */
+async function runScheduledScrub(opts = {}) {
+    const getConfig = opts.getConfig ?? defaultConfig;
+    const policy = await scrubPolicy(opts.fetchImpl ?? fetch, getConfig);
+    if (!policy.enabled)
+        return false;
+    const stateDir = opts.stateDir ?? (0, configDir_1.codiedevStateDir)();
+    const known = policy.ownSecrets === "off" ? [] : (0, knownSecrets_1.collectKnownSecrets)(opts.home ?? os.homedir(), (0, knownSecrets_1.recentCwds)(scrubDir(stateDir)));
+    if (policy.ownSecrets === "server" && policy.fingerprintKey)
+        await (0, knownSecrets_1.uploadKnownSecrets)(getConfig(), policy.fingerprintKey, known, opts.fetchImpl ?? fetch);
+    const knownRule = (0, knownSecrets_1.knownSecretRule)(known);
+    (0, extraRules_1.setExtraRules)([...formatRules(policy.formats), ...(knownRule ? [knownRule] : [])]);
+    try {
+        await runAndReport({ stateDir });
+    }
+    finally {
+        (0, extraRules_1.setExtraRules)([]);
+    }
+    return true;
+}
+/** Start a background scrub if the last one was over an hour ago. Stamps
+ * first so sessions opening at the same time don't each start one. */
+function maybeSpawnLocalScrub(opts = {}) {
+    try {
+        const env = opts.env ?? process.env;
+        if (opts.connected === false || env.CODIEDEV_LOCAL_SCRUB === "off" || env.CODIEDEV_LOCAL_SCRUB_CHILD)
+            return "disabled";
+        const now = opts.now ?? Date.now();
+        const dir = scrubDir(opts.stateDir ?? (0, configDir_1.codiedevStateDir)());
+        // Which repos are this person's, for their .env files (read only when the
+        // scrub is on; this just remembers the path).
+        (0, knownSecrets_1.rememberCwd)(dir, opts.cwd);
+        const stamp = path.join(dir, "last-run");
+        try {
+            const last = fs.statSync(stamp).mtimeMs;
+            if (now - last < exports.RUN_INTERVAL_MS && last <= now)
+                return "recent";
+        }
+        catch { /* never ran */ }
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(stamp, String(now));
+        const t = new Date(now);
+        fs.utimesSync(stamp, t, t);
+        const child = (opts.spawn ?? child_process_1.spawn)(process.execPath, [opts.hookEntry ?? path.join(__dirname, "hook.js"), "local-scrub"], {
+            detached: true,
+            stdio: "ignore",
+            env: { ...env, CODIEDEV_LOCAL_SCRUB_CHILD: "1" },
+        });
+        child.on?.("error", () => { });
+        child.unref?.();
+        return "spawned";
+    }
+    catch {
+        return "error";
+    }
+}