@stroq/cli 0.14.1 → 0.15.0

package/dist/index.js

@@ -549,10 +549,10 @@ function decodeLayer(text, depth, maxDepth) {
   return found;
 }
 function expandVariants(text, maxDepth = 2) {
-  const normalized = normalizeText(text);
+  const normalized2 = normalizeText(text);
   const base = [{ kind: "raw", depth: 0, text }];
-  if (normalized !== text) base.push({ kind: "normalized", depth: 0, text: normalized });
-  return [...base, ...decodeLayer(normalized, 1, maxDepth)];
+  if (normalized2 !== text) base.push({ kind: "normalized", depth: 0, text: normalized2 });
+  return [...base, ...decodeLayer(normalized2, 1, maxDepth)];
 }
 
 // ../core/src/rules/atr-types.ts
@@ -1255,7 +1255,14 @@ var SEVERITY_WEIGHT = {
 };
 var DEFAULT_THRESHOLD = 0.6;
 var DEFAULT_MAX_CHARS = 2e5;
-var DEFAULT_BUDGET_MS = 500;
+var DEFAULT_BUDGET_MS = 4e3;
+var SCAN_BUDGET_ENV = "STROQ_SCAN_BUDGET_MS";
+function budgetFromEnv() {
+  const raw = process.env[SCAN_BUDGET_ENV];
+  if (raw === void 0) return void 0;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
 var ENCODED_FLOOR = 0.7;
 var BUDGET_MATCH = {
   ruleId: "STROQ-SCAN-BUDGET",
@@ -1275,7 +1282,7 @@ function timedOutResult(matches) {
 function scanContent(rules, text, opts = {}, context = {}) {
   const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
   const maxChars = opts.maxChars ?? DEFAULT_MAX_CHARS;
-  const budgetMs = opts.budgetMs ?? DEFAULT_BUDGET_MS;
+  const budgetMs = opts.budgetMs ?? budgetFromEnv() ?? DEFAULT_BUDGET_MS;
   const startedAt = performance.now();
   const input = text.length > maxChars ? text.slice(0, maxChars) : text;
   const seen = /* @__PURE__ */ new Set();
@@ -1311,13 +1318,13 @@ function isDangerousRmTarget(target, cwd) {
   if (t.startsWith("~") || t.startsWith("$") || t.startsWith("..")) return true;
   if (UNC_PATH.test(t)) return true;
   if (WINDOWS_DRIVE_PATH.test(t)) {
-    const normalized2 = foldPath(t).toLowerCase();
+    const normalized3 = foldPath(t).toLowerCase();
     const root = foldPath(cwd).toLowerCase();
-    return normalized2 === "" || !normalized2.startsWith(`${root}/`);
+    return normalized3 === "" || !normalized3.startsWith(`${root}/`);
   }
   if (!t.startsWith("/")) return false;
-  const normalized = t.replace(/\/+$/, "");
-  return !normalized.startsWith(`${cwd}/`);
+  const normalized2 = t.replace(/\/+$/, "");
+  return !normalized2.startsWith(`${cwd}/`);
 }
 
 // ../core/src/actions/classify-powershell.ts
@@ -1450,14 +1457,14 @@ function matchingParenEnd(text, start) {
 }
 function extractSubstitutions(command) {
   const results = [];
-  for (const open of OPEN_SUBSTITUTIONS) {
-    let idx = command.indexOf(open);
+  for (const open3 of OPEN_SUBSTITUTIONS) {
+    let idx = command.indexOf(open3);
     while (idx !== -1) {
-      const start = idx + open.length;
+      const start = idx + open3.length;
       const end = matchingParenEnd(command, start);
       if (end === -1) break;
       results.push(command.slice(start, end));
-      idx = command.indexOf(open, end);
+      idx = command.indexOf(open3, end);
     }
   }
   const backtickPairs = command.match(/`[^`]*`/g) ?? [];
@@ -1467,6 +1474,22 @@ function extractSubstitutions(command) {
 function splitTop(command) {
   return command.split(SEGMENT_SPLIT).map((s) => s.trim()).filter((s) => s.length > 0);
 }
+var SEQUENCE_SPLIT = /\|\||&&|;|\n/;
+function pipelinesOf(command) {
+  return command.split(SEQUENCE_SPLIT).map(
+    (run) => run.split("|").map((stage) => stage.trim()).filter((stage) => stage.length > 0)
+  ).filter((stages) => stages.length > 0);
+}
+function splitPipelines(command) {
+  return [
+    ...pipelinesOf(command),
+    ...extractSubstitutions(command).flatMap(pipelinesOf),
+    ...extractShCStrings(command).flatMap(pipelinesOf),
+    ...extractFindExecCommands(command).flatMap(pipelinesOf),
+    ...extractEvalArguments(command).flatMap(pipelinesOf),
+    ...extractGitForeachOrBisectRunCommands(command).flatMap(pipelinesOf)
+  ];
+}
 var SH_C_QUOTE = /\b(?:sh|bash|zsh|dash|ksh)\s+-c\s+(["'])/g;
 var IEX_QUOTE = /\b(?:iex|Invoke-Expression)\s+(["'])/gi;
 function extractQuotedBodies(command, pattern) {
@@ -1963,19 +1986,28 @@ function isNetwork(seg) {
   if (/\/dev\/tcp\//.test(seg)) return true;
   return isUnknownWrapperNetworkCall(seg, word);
 }
-function encodedExecSignals(segments) {
-  return segments.flatMap((seg, i) => {
-    const later = segments.slice(i + 1);
-    const signals = [];
-    if (DECODE.test(seg) && later.some(isShell)) signals.push("decode-pipe-shell");
-    if (isNetwork(seg) && later.some(isShell)) signals.push("remote-pipe-shell");
-    if (EVAL_DYNAMIC.test(seg)) signals.push("eval-dynamic");
-    if (INLINE_INTERP.test(seg) && INLINE_PAYLOAD.test(seg))
-      signals.push("inline-interpreter-payload");
-    if (SHELL_C_REMOTE.test(seg)) signals.push("shell-c-remote");
-    if (SHELL_PROC_SUB_REMOTE.test(seg)) signals.push("shell-proc-sub-remote");
-    return signals;
-  });
+function encodedExecSignals(segments, pipelines) {
+  const piped = pipelines.flatMap(
+    (stages) => stages.flatMap((stage, i) => {
+      const downstream = stages.slice(i + 1);
+      const signals = [];
+      if (DECODE.test(stage) && downstream.some(isShell)) signals.push("decode-pipe-shell");
+      if (isNetwork(stage) && downstream.some(isShell)) signals.push("remote-pipe-shell");
+      return signals;
+    })
+  );
+  return [
+    ...piped,
+    ...segments.flatMap((seg) => {
+      const signals = [];
+      if (EVAL_DYNAMIC.test(seg)) signals.push("eval-dynamic");
+      if (INLINE_INTERP.test(seg) && INLINE_PAYLOAD.test(seg))
+        signals.push("inline-interpreter-payload");
+      if (SHELL_C_REMOTE.test(seg)) signals.push("shell-c-remote");
+      if (SHELL_PROC_SUB_REMOTE.test(seg)) signals.push("shell-proc-sub-remote");
+      return signals;
+    })
+  ];
 }
 function destructiveSignals(segments, cwd) {
   return segments.flatMap((seg) => {
@@ -2008,7 +2040,10 @@ function classifyCommand(command, cwd) {
   const selfConfig = selfTamperSignals(segments);
   const ps = powershellSignals(segments, cwd);
   const groups = [
-    ["shell.exec_encoded", [...encodedExecSignals(segments), ...ps.encoded]],
+    [
+      "shell.exec_encoded",
+      [...encodedExecSignals(segments, splitPipelines(command)), ...ps.encoded]
+    ],
     ["shell.network", [...segments.filter(isNetwork).map(() => "network-command"), ...ps.network]],
     ["shell.destructive", [...destructiveSignals(segments, cwd), ...ps.destructive]],
     ["fs.secrets", [...secretSignals(segments), ...ps.secrets]],
@@ -3807,6 +3842,25 @@ function collectStrings(value, depth = 0) {
   }
   return [];
 }
+function collectKeyedStrings(value, key2 = null, into = /* @__PURE__ */ new Map(), depth = 0) {
+  if (depth > MAX_JSON_DEPTH) return into;
+  if (typeof value === "string") {
+    const keys = into.get(value) ?? /* @__PURE__ */ new Set();
+    if (key2 !== null) keys.add(key2);
+    into.set(value, keys);
+    return into;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectKeyedStrings(item, key2, into, depth + 1);
+    return into;
+  }
+  if (value !== null && typeof value === "object") {
+    for (const [childKey, item] of Object.entries(value)) {
+      collectKeyedStrings(item, childKey, into, depth + 1);
+    }
+  }
+  return into;
+}
 function mapStrings(value, fn, depth = 0) {
   if (depth > MAX_JSON_DEPTH) return value;
   if (typeof value === "string") return fn(value);
@@ -3822,19 +3876,182 @@ function mapStrings(value, fn, depth = 0) {
   return value;
 }
 
+// ../core/src/cloak/keyed.ts
+var normalizeKey = (key2) => key2.toLowerCase().replace(/[^a-z0-9]/g, "");
+var PERSON_KEYS = /* @__PURE__ */ new Set([
+  "firstname",
+  "lastname",
+  "fullname",
+  "middlename",
+  "givenname",
+  "familyname",
+  "surname",
+  "displayname",
+  "legalname",
+  "personname",
+  "contactname",
+  "customername",
+  "clientname",
+  "employeename",
+  "patientname",
+  "authorname",
+  "ownername",
+  "recipientname",
+  "sendername",
+  "attendee",
+  "attendees",
+  "attendeename"
+]);
+var PLACE_KEYS = /* @__PURE__ */ new Set([
+  "streetaddress",
+  "street",
+  "addressline1",
+  "addressline2",
+  "address1",
+  "address2",
+  "homeaddress",
+  "billingaddress",
+  "shippingaddress",
+  "mailingaddress",
+  "postaladdress",
+  "deliveryaddress"
+]);
+var MAX_NAME_CHARS = 200;
+var MAX_ADDRESS_CHARS = 500;
+function detectKeyedFields(text, keys) {
+  if (text.trim() === "") return [];
+  let kind = null;
+  for (const key2 of keys) {
+    const normalized2 = normalizeKey(key2);
+    if (PERSON_KEYS.has(normalized2)) {
+      kind = "name";
+      break;
+    }
+    if (PLACE_KEYS.has(normalized2)) kind = "address";
+  }
+  if (kind === null) return [];
+  if (text.length > (kind === "name" ? MAX_NAME_CHARS : MAX_ADDRESS_CHARS)) return [];
+  return [{ kind, start: 0, end: text.length, value: text, restorable: true }];
+}
+
+// ../core/src/cloak/prose-names.ts
+var MIN_PART_CHARS = 3;
+var MAX_NEEDLES = 64;
+var ALSO_ORDINARY = /* @__PURE__ */ new Set([
+  "Amber",
+  "Art",
+  "Autumn",
+  "Bill",
+  "Bob",
+  "Buck",
+  "Carol",
+  "Chase",
+  "Chuck",
+  "Daisy",
+  "Dawn",
+  "Don",
+  "Drew",
+  "Earl",
+  "Faith",
+  "Frank",
+  "Grace",
+  "Guy",
+  "Hope",
+  "Hunter",
+  "Jack",
+  "Joy",
+  "June",
+  "Major",
+  "Mark",
+  "Max",
+  "May",
+  "Mercy",
+  "Nick",
+  "Olive",
+  "Page",
+  "Pat",
+  "Pearl",
+  "Rose",
+  "Ruby",
+  "Sky",
+  "Stone",
+  "Sue",
+  "Summer",
+  "Wade",
+  "Ward",
+  "Will"
+]);
+var NOT_WORD = "[^\\p{L}\\p{N}_]";
+var SENTENCE_END = /* @__PURE__ */ new Set([".", "!", "?", "\n", "\r", ";", ":", "\u2022", "-", "*"]);
+var escapeLiteral = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function nameNeedles(names) {
+  const out = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const trimmed = name.trim();
+    if (trimmed === "") continue;
+    out.add(trimmed);
+    for (const part of trimmed.split(/[^\p{L}\p{N}]+/u)) {
+      if (part.length >= MIN_PART_CHARS) out.add(part);
+    }
+  }
+  return [...out].sort((a, b) => b.length - a.length || (a < b ? -1 : 1)).slice(0, MAX_NEEDLES);
+}
+function startsSentence(text, index) {
+  for (let i = index - 1; i >= 0; i -= 1) {
+    const char = text[i] ?? "";
+    if (char === " " || char === "	") continue;
+    return SENTENCE_END.has(char);
+  }
+  return true;
+}
+function compileNameMatcher(needles) {
+  if (needles.length === 0) return null;
+  const source = `(?<=^|${NOT_WORD})(?:${needles.map(escapeLiteral).join("|")})(?=$|${NOT_WORD})`;
+  return (text) => {
+    if (text === "") return [];
+    const spans = [];
+    for (const match of text.matchAll(new RegExp(source, "gu"))) {
+      const value = match[0];
+      const start = match.index;
+      if (ALSO_ORDINARY.has(value) && startsSentence(text, start)) continue;
+      spans.push({ kind: "name", start, end: start + value.length, value, restorable: true });
+    }
+    return spans;
+  };
+}
+
 // ../core/src/cloak/detector.ts
 var MAX_CLOAK_CHARS = MAX_SCAN_CHARS;
 function createCloakDetector(options) {
   return {
-    async detect(text) {
+    async detect(text, keys) {
       if (text === "" || text.length > MAX_CLOAK_CHARS) return [];
-      const patterns = detectPatterns(text);
-      if (!options.secrets) return patterns;
+      const shapes = [...detectPatterns(text), ...detectKeyedFields(text, keys ?? /* @__PURE__ */ new Set())];
+      if (!options.secrets) return mergeSpans(shapes);
       const matches = await options.secrets.lookup(candidatesFromText(text), options.cwd);
-      return mergeSpans([...secretSpans(text, matches), ...patterns]);
+      return mergeSpans([...secretSpans(text, matches), ...shapes]);
     }
   };
 }
+async function detectAcrossLeaves(leaves, detector) {
+  const found = /* @__PURE__ */ new Map();
+  const names = /* @__PURE__ */ new Set();
+  for (const [text, keys] of leaves) {
+    const spans = mergeSpans(await detector.detect(text, keys));
+    if (spans.length > 0) found.set(text, spans);
+    for (const span of spans) if (span.kind === "name") names.add(span.value);
+  }
+  if (names.size === 0) return found;
+  const matcher = compileNameMatcher(nameNeedles(names));
+  if (matcher === null) return found;
+  for (const text of leaves.keys()) {
+    const prose = matcher(text);
+    if (prose.length === 0) continue;
+    const merged = mergeSpans([...found.get(text) ?? [], ...prose]);
+    found.set(text, merged);
+  }
+  return found;
+}
 
 // ../core/src/cloak/store.ts
 import { mkdir as mkdir6, readFile as readFile5, rename as rename4, writeFile as writeFile4 } from "fs/promises";
@@ -4556,7 +4773,7 @@ import { parseArgs as parseArgs2 } from "util";
 
 // src/bench/run.ts
 import { closeSync, existsSync as existsSync2, openSync, readSync, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
-import { join as join8 } from "path";
+import { basename as basename2, join as join8 } from "path";
 import { fileURLToPath } from "url";
 var TEXT = /\.(?:md|rst|txt|adoc)$/i;
 var BENCH_BUDGET_MS = 6e4;
@@ -4600,15 +4817,23 @@ function runBench(dir) {
   const flaggedFiles = [];
   let bytes = 0;
   let timedOut = 0;
+  let slowestMs = 0;
+  let slowestFile = "";
   for (const file of files) {
     const size = statSync4(file).size;
     bytes += size;
+    const startedAt = performance.now();
     const result = scanContent(
       rules,
       readPrefix(file, MAX_READ_BYTES),
       { budgetMs: BENCH_BUDGET_MS },
       { target: "repo_content" }
     );
+    const elapsed = performance.now() - startedAt;
+    if (elapsed > slowestMs) {
+      slowestMs = elapsed;
+      slowestFile = file;
+    }
     if (result.timedOut) timedOut += 1;
     if (result.verdict !== "suspect") continue;
     flaggedFiles.push(file);
@@ -4632,6 +4857,8 @@ function runBench(dir) {
     flagged: flaggedFiles.length,
     rate: files.length === 0 ? 0 : flaggedFiles.length / files.length,
     timedOut,
+    slowestMs,
+    slowestFile,
     byRule: [...perRule.values()].sort((a, b) => b.files - a.files),
     flaggedFiles
   };
@@ -4648,6 +4875,14 @@ function formatBench(report, opts = {}) {
       `timedOut:  ${report.timedOut} ${noun} hit the bench's scan budget and were forced suspect by that alone, not by a rule match \u2014 see docs/BENCH.md's Method section.`
     );
   }
+  if (opts.timings === true) {
+    const headroom = DEFAULT_BUDGET_MS / Math.max(report.slowestMs, 1e-3);
+    const verdict = headroom < 2 ? "  ** raise DEFAULT_BUDGET_MS **" : "";
+    const which = opts.verbose === true ? ` (${basename2(report.slowestFile)})` : "";
+    lines.push(
+      `slowest:   ${report.slowestMs.toFixed(0)} ms${which} against production's ${DEFAULT_BUDGET_MS} ms budget \u2014 ${headroom.toFixed(1)}x headroom${verdict}`
+    );
+  }
   if (report.byRule.length === 0) {
     lines.push("", "Nothing in this corpus trips a rule.");
   } else {
@@ -4686,7 +4921,7 @@ async function runBenchCommand(args) {
   const report = runBench(dir);
   process.stdout.write(
     values.json ? `${JSON.stringify(report, null, 2)}
-` : formatBench(report, { verbose: values.verbose })
+` : formatBench(report, { verbose: values.verbose, timings: true })
   );
   return 0;
 }
@@ -6032,7 +6267,7 @@ function runOpenClawInstall(bin, dir, run = spawnCommand) {
 
 // src/commands/init-mcp.ts
 import { existsSync as existsSync8, statSync as statSync6 } from "fs";
-import { basename as basename2, resolve as resolve3 } from "path";
+import { basename as basename3, resolve as resolve3 } from "path";
 
 // src/commands/mcp-config.ts
 import { existsSync as existsSync7 } from "fs";
@@ -6198,7 +6433,7 @@ var MCP_NOTE = 'Restart the MCP client before this takes effect: it launches its
 function mcpTarget(client, configPath, scope) {
   if (client === void 0) {
     const file = resolve3(configPath ?? "");
-    return { file, label: basename2(file) };
+    return { file, label: basename3(file) };
   }
   if (!isMcpClient(client)) return null;
   return { file: mcpConfigPath(client, scope), label: client };
@@ -7319,8 +7554,8 @@ var MAX_CONFIG_BYTES = 256 * 1024;
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".venv", "venv", "vendor", "target", "dist", "build"]);
 var readTextOr = (file, fallback = "") => {
   try {
-    const stat3 = statSync8(file);
-    if (!stat3.isFile() || stat3.size > MAX_CONFIG_BYTES) return fallback;
+    const stat4 = statSync8(file);
+    if (!stat4.isFile() || stat4.size > MAX_CONFIG_BYTES) return fallback;
     return readFileSync15(file, "utf8");
   } catch {
     return fallback;
@@ -7377,9 +7612,9 @@ function gitAttributesHits(root) {
 }
 function runsAsGitHook(file, plat) {
   try {
-    const stat3 = statSync8(file);
-    if (!stat3.isFile()) return false;
-    return plat === "win32" || (stat3.mode & 73) !== 0;
+    const stat4 = statSync8(file);
+    if (!stat4.isFile()) return false;
+    return plat === "win32" || (stat4.mode & 73) !== 0;
   } catch {
     return false;
   }
@@ -8761,11 +8996,7 @@ var McpCloak = class {
         kind: "refused",
         reason: `the result serialises to ${serialised.length} characters, more than the ${MAX_CLOAK_CHARS} Stroq can scan whole`
       };
-    const spansByText = /* @__PURE__ */ new Map();
-    for (const text of new Set(collectStrings(result))) {
-      const spans = mergeSpans(await this.opts.detector.detect(text));
-      if (spans.length > 0) spansByText.set(text, spans);
-    }
+    const spansByText = await detectAcrossLeaves(collectKeyedStrings(result), this.opts.detector);
     if (spansByText.size === 0) return { kind: "unchanged" };
     const requests = [];
     for (const spans of spansByText.values()) {
@@ -9753,7 +9984,9 @@ import { join as join23 } from "path";
 import { parseArgs as parseArgs8 } from "util";
 
 // src/replay/transcript.ts
-import { readdir, readFile as readFile6, stat as stat2 } from "fs/promises";
+import { createReadStream } from "fs";
+import { readdir, stat as stat2 } from "fs/promises";
+import { createInterface } from "readline";
 import { homedir as homedir19 } from "os";
 import { join as join22 } from "path";
 var isRecord2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -9772,24 +10005,24 @@ function blocksOf(record) {
   const content = message["content"];
   return Array.isArray(content) ? content.filter(isRecord2) : [];
 }
-function parseTranscript(text) {
+function createTranscriptParser() {
   const events = [];
   const pending = /* @__PURE__ */ new Map();
   let sessionId = "transcript";
   let cwd = null;
   let skipped = 0;
-  for (const line3 of text.split("\n")) {
-    if (line3.trim().length === 0) continue;
+  function push(line3) {
+    if (line3.trim().length === 0) return;
     let record;
     try {
       record = JSON.parse(line3);
     } catch {
       skipped += 1;
-      continue;
+      return;
     }
     if (!isRecord2(record)) {
       skipped += 1;
-      continue;
+      return;
     }
     if (typeof record["sessionId"] === "string") sessionId = record["sessionId"];
     if (cwd === null && typeof record["cwd"] === "string") cwd = record["cwd"];
@@ -9816,7 +10049,19 @@ function parseTranscript(text) {
       }
     }
   }
-  return { sessionId, cwd, events, skipped };
+  return { push, finish: () => ({ sessionId, cwd, events, skipped }) };
+}
+async function feedLines(path, parser) {
+  const lines = createInterface({
+    input: createReadStream(path, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  try {
+    for await (const line3 of lines) parser.push(line3);
+  } finally {
+    lines.close();
+  }
+  return parser.finish();
 }
 function projectSlug(cwd) {
   return cwd.replace(/[/.]/g, "-");
@@ -9856,7 +10101,7 @@ async function listJsonl(dir) {
   return files;
 }
 async function readTranscript(path) {
-  return parseTranscript(await readFile6(path, "utf8"));
+  return feedLines(path, createTranscriptParser());
 }
 
 // src/commands/replay.ts
@@ -10523,7 +10768,7 @@ stroq run \u2014 ${invocation.command}${agent === null ? "" : ` (${agent})`}`);
 }
 
 // src/commands/sent.ts
-import { homedir as homedir21 } from "os";
+import { homedir as homedir24 } from "os";
 import { parseArgs as parseArgs9 } from "util";
 
 // src/sent/format.ts
@@ -10646,19 +10891,664 @@ function formatSent(report) {
 }
 
 // src/sent/readers.ts
+import { open as open2 } from "fs/promises";
+import { homedir as homedir23 } from "os";
+
+// src/sent/codex.ts
+import { open, readdir as readdir2, stat as stat3 } from "fs/promises";
+import { homedir as homedir21 } from "os";
+import { join as join26 } from "path";
+
+// src/sent/codex-literal.ts
+var MAX_DEPTH = 64;
+var Unreadable = class extends Error {
+};
+function fail() {
+  throw new Unreadable();
+}
+function readObjectLiteral(src, start) {
+  let i = start;
+  let depth = 0;
+  const skip = () => {
+    while (i < src.length && (src[i] === "," || /\s/.test(src[i]))) i += 1;
+  };
+  const skipSpace = () => {
+    while (i < src.length && /\s/.test(src[i])) i += 1;
+  };
+  const ESCAPES = {
+    n: "\n",
+    t: "	",
+    r: "\r",
+    b: "\b",
+    f: "\f",
+    v: "\v",
+    "0": "\0"
+  };
+  function readString(quote) {
+    i += 1;
+    let out = "";
+    while (i < src.length) {
+      const c = src[i];
+      if (c === "\\") {
+        const next = src[i + 1];
+        if (next === void 0) fail();
+        if (next === "\n") {
+          i += 2;
+          continue;
+        }
+        if (next === "u") {
+          if (src[i + 2] === "{") {
+            const close = src.indexOf("}", i + 3);
+            if (close < 0) fail();
+            const code2 = Number.parseInt(src.slice(i + 3, close), 16);
+            if (Number.isNaN(code2)) fail();
+            out += String.fromCodePoint(code2);
+            i = close + 1;
+            continue;
+          }
+          const code = Number.parseInt(src.slice(i + 2, i + 6), 16);
+          if (Number.isNaN(code)) fail();
+          out += String.fromCharCode(code);
+          i += 6;
+          continue;
+        }
+        if (next === "x") {
+          const code = Number.parseInt(src.slice(i + 2, i + 4), 16);
+          if (Number.isNaN(code)) fail();
+          out += String.fromCharCode(code);
+          i += 4;
+          continue;
+        }
+        out += ESCAPES[next] ?? next;
+        i += 2;
+        continue;
+      }
+      if (c === quote) {
+        i += 1;
+        return out;
+      }
+      if (quote === "`" && c === "$" && src[i + 1] === "{") {
+        let braces = 0;
+        const from = i;
+        while (i < src.length) {
+          const t = src[i];
+          if (t === "{") braces += 1;
+          else if (t === "}") {
+            braces -= 1;
+            if (braces === 0) {
+              i += 1;
+              break;
+            }
+          }
+          i += 1;
+        }
+        if (braces !== 0) fail();
+        out += src.slice(from, i);
+        continue;
+      }
+      out += c;
+      i += 1;
+    }
+    return fail();
+  }
+  function readKey() {
+    skip();
+    const c = src[i];
+    if (c === '"' || c === "'" || c === "`") return readString(c);
+    const name = /^[A-Za-z_$][\w$]*/.exec(src.slice(i));
+    if (!name) fail();
+    i += name[0].length;
+    return name[0];
+  }
+  function readValue() {
+    skip();
+    if (i >= src.length) fail();
+    const c = src[i];
+    if (c === "{") return readObject();
+    if (c === "[") return readArray();
+    if (c === '"' || c === "'" || c === "`") return readString(c);
+    const rest = src.slice(i);
+    for (const [word, value] of [
+      ["true", true],
+      ["false", false],
+      ["null", null],
+      ["undefined", null]
+    ]) {
+      if (rest.startsWith(word) && !/[\w$]/.test(rest[word.length] ?? "")) {
+        i += word.length;
+        return value;
+      }
+    }
+    const num = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(rest);
+    if (num) {
+      i += num[0].length;
+      return Number(num[0]);
+    }
+    return fail();
+  }
+  function readObject() {
+    depth += 1;
+    if (depth > MAX_DEPTH) fail();
+    i += 1;
+    const out = {};
+    for (; ; ) {
+      skip();
+      if (i >= src.length) fail();
+      if (src[i] === "}") {
+        i += 1;
+        depth -= 1;
+        return out;
+      }
+      if (src.startsWith("...", i)) {
+        i += 3;
+        const name = /^[A-Za-z_$][\w$.]*/.exec(src.slice(i));
+        if (!name) fail();
+        i += name[0].length;
+        continue;
+      }
+      const key2 = readKey();
+      skipSpace();
+      if (src[i] === ":") {
+        i += 1;
+        out[key2] = readValue();
+        continue;
+      }
+      if (src[i] === "}" || src[i] === ",") {
+        out[key2] = null;
+        continue;
+      }
+      fail();
+    }
+  }
+  function readArray() {
+    depth += 1;
+    if (depth > MAX_DEPTH) fail();
+    i += 1;
+    const out = [];
+    for (; ; ) {
+      skip();
+      if (i >= src.length) fail();
+      if (src[i] === "]") {
+        i += 1;
+        depth -= 1;
+        return out;
+      }
+      out.push(readValue());
+    }
+  }
+  const opening = src[start];
+  if (opening !== "{" && opening !== "[") return null;
+  try {
+    const value = readValue();
+    return { value, end: i };
+  } catch (err) {
+    if (err instanceof Unreadable) return null;
+    if (err instanceof RangeError) return null;
+    throw err;
+  }
+}
+
+// src/sent/codex.ts
+var isRecord3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function outputText(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return "";
+  return value.map((block) => {
+    if (typeof block === "string") return block;
+    if (isRecord3(block) && typeof block["text"] === "string") return block["text"];
+    return "";
+  }).filter((t) => t.length > 0).join("");
+}
+var TOOL_CALL = /\btools\.([A-Za-z_$][\w$]*)\s*\(/g;
+function invocationsIn(script) {
+  const found = [];
+  TOOL_CALL.lastIndex = 0;
+  for (let m = TOOL_CALL.exec(script); m !== null; m = TOOL_CALL.exec(script)) {
+    const afterParen = m.index + m[0].length;
+    const brace = script.indexOf("{", afterParen - 1);
+    const literal = brace >= 0 && brace <= afterParen + 2 ? readObjectLiteral(script, brace) : null;
+    const args = isRecord3(literal?.value) ? { ...literal.value } : { raw: script };
+    found.push({ tool: m[1], input: args });
+  }
+  return found;
+}
+function normalized(mapped, input) {
+  if (mapped !== "Bash" || typeof input["command"] === "string") return input;
+  const command = commandOf(input);
+  return command === "" ? input : { ...input, command };
+}
+function eventsFor(callId, rawTool, rawInput, at) {
+  const invocations = isPatchTool(rawTool) ? [{ tool: rawTool, input: { input: rawInput } }] : invocationsIn(rawInput);
+  const list = invocations.length > 0 ? invocations : [{ tool: rawTool, input: { raw: rawInput } }];
+  return list.map((inv, n) => {
+    const tool = codexToolName(inv.tool);
+    return {
+      kind: "pre",
+      /* One script, several calls: the ids stay distinct so the output can attach to
+         exactly one of them, and the first keeps the recorded `call_id` so the
+         common single-call case reads as the rollout wrote it. */
+      id: n === 0 ? callId : `${callId}#${n}`,
+      tool,
+      input: normalized(tool, inv.input),
+      at
+    };
+  });
+}
+function createCodexParser() {
+  const events = [];
+  const pending = /* @__PURE__ */ new Map();
+  let sessionId = "transcript";
+  let cwd = null;
+  let skipped = 0;
+  function push(line3) {
+    if (line3.trim().length === 0) return;
+    let envelope2;
+    try {
+      envelope2 = JSON.parse(line3);
+    } catch {
+      skipped += 1;
+      return;
+    }
+    if (!isRecord3(envelope2)) {
+      skipped += 1;
+      return;
+    }
+    const at = typeof envelope2["timestamp"] === "string" ? envelope2["timestamp"] : "";
+    const payload = isRecord3(envelope2["payload"]) ? envelope2["payload"] : envelope2;
+    if (envelope2["type"] === "session_meta") {
+      if (typeof payload["session_id"] === "string") sessionId = payload["session_id"];
+      if (typeof payload["cwd"] === "string") cwd = payload["cwd"];
+      return;
+    }
+    if (cwd === null && typeof payload["cwd"] === "string") cwd = payload["cwd"];
+    const kind = payload["type"];
+    const callId = payload["call_id"];
+    if (typeof callId !== "string") return;
+    if (kind === "custom_tool_call" || kind === "function_call") {
+      const rawTool = typeof payload["name"] === "string" ? payload["name"] : "unknown";
+      if (kind === "function_call") {
+        let parsed = null;
+        if (typeof payload["arguments"] === "string") {
+          try {
+            parsed = JSON.parse(payload["arguments"]);
+          } catch {
+            parsed = { raw: payload["arguments"] };
+          }
+        }
+        const tool = codexToolName(rawTool);
+        const input = isRecord3(parsed) ? parsed : {};
+        const event = {
+          kind: "pre",
+          id: callId,
+          tool,
+          input: normalized(tool, input),
+          at
+        };
+        events.push(event);
+        pending.set(callId, { id: event.id, tool: event.tool, input: event.input });
+        return;
+      }
+      const script = typeof payload["input"] === "string" ? payload["input"] : "";
+      const produced = eventsFor(callId, rawTool, script, at);
+      events.push(...produced);
+      const last = produced[produced.length - 1];
+      if (last) pending.set(callId, { id: last.id, tool: last.tool, input: last.input });
+      return;
+    }
+    if (kind === "custom_tool_call_output" || kind === "function_call_output") {
+      const call = pending.get(callId);
+      if (!call) return;
+      events.push({
+        kind: "post",
+        id: call.id,
+        tool: call.tool,
+        input: call.input,
+        resultText: outputText(payload["output"]),
+        at
+      });
+    }
+  }
+  return { push, finish: () => ({ sessionId, cwd, events, skipped }) };
+}
+var codexRoot = (home = homedir21()) => join26(home, ".codex", "sessions");
+var META_BYTES = 64 * 1024;
+async function rolloutCwd(path) {
+  let head;
+  try {
+    const handle = await open(path, "r");
+    try {
+      const buffer = Buffer.alloc(META_BYTES);
+      const { bytesRead } = await handle.read(buffer, 0, META_BYTES, 0);
+      head = buffer.subarray(0, bytesRead).toString("utf8");
+    } finally {
+      await handle.close();
+    }
+  } catch {
+    return null;
+  }
+  const first = head.split("\n")[0];
+  if (first === void 0 || first.trim() === "") return null;
+  try {
+    const envelope2 = JSON.parse(first);
+    if (!isRecord3(envelope2)) return null;
+    const payload = isRecord3(envelope2["payload"]) ? envelope2["payload"] : envelope2;
+    return typeof payload["cwd"] === "string" ? payload["cwd"] : null;
+  } catch {
+    return null;
+  }
+}
+async function everyRollout(root) {
+  const entries = await readdir2(root, { recursive: true, withFileTypes: true }).catch(() => []);
+  const files = [];
+  for (const entry2 of entries) {
+    if (!entry2.isFile()) continue;
+    if (!entry2.name.startsWith("rollout-") || !entry2.name.endsWith(".jsonl")) continue;
+    const path = join26(entry2.parentPath, entry2.name);
+    try {
+      files.push({ path, mtimeMs: (await stat3(path)).mtimeMs });
+    } catch {
+    }
+  }
+  return files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+async function findCodexRollouts(cwd, home) {
+  const all = await everyRollout(codexRoot(home));
+  const here = [];
+  for (const file of all) {
+    if (await rolloutCwd(file.path) === cwd) here.push(file);
+  }
+  return here.length > 0 ? here : all;
+}
+async function readCodexRollout(path) {
+  return feedLines(path, createCodexParser());
+}
+
+// src/sent/cursor.ts
+import { homedir as homedir22 } from "os";
+import { join as join27 } from "path";
+var TOOL_NAMES = {
+  run_terminal_command_v2: "Bash",
+  run_terminal_command: "Bash",
+  read_file_v2: "Read",
+  read_file: "Read",
+  edit_file_v2: "Write",
+  edit_file: "Write",
+  search_replace: "Write",
+  create_file: "Write",
+  delete_file: "Write"
+};
+var PATH_FIELDS2 = ["targetFile", "effectiveUri", "path", "targetDirectory", "absolutePath"];
+var RESULT_FIELDS = ["output", "contents", "result"];
+function parseJson(value) {
+  if (typeof value !== "string" || value === "") return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function mcpPair(params) {
+  if (!isRecord(params)) return null;
+  const tools = params["tools"];
+  if (!Array.isArray(tools)) return null;
+  const first = tools[0];
+  if (!isRecord(first)) return null;
+  const tool = first["name"];
+  const server = first["serverName"];
+  if (typeof tool !== "string" || typeof server !== "string") return null;
+  return { server, tool, args: first["parameters"] };
+}
+function callOf(name, params) {
+  const mcp = mcpPair(params);
+  if (mcp !== null) {
+    return {
+      tool: mcpToolName(mcp.server, mcp.tool),
+      input: toolInputRecord(mcp.args),
+      paths: []
+    };
+  }
+  const record = isRecord(params) ? params : {};
+  const paths = PATH_FIELDS2.map((field) => record[field]).filter(
+    (value) => typeof value === "string" && value.startsWith("/")
+  );
+  const mapped = TOOL_NAMES[name] ?? name;
+  if (mapped === "Bash") {
+    const command = record["command"];
+    return { tool: mapped, input: { command: typeof command === "string" ? command : "" }, paths };
+  }
+  if (mapped === "Read" || mapped === "Write") {
+    const file = record["targetFile"] ?? record["relativeWorkspacePath"] ?? record["path"] ?? record["uri"];
+    return {
+      tool: mapped,
+      input: { file_path: typeof file === "string" ? file : "" },
+      paths
+    };
+  }
+  return { tool: mapped, input: record, paths };
+}
+function resultTextOf(raw) {
+  if (typeof raw !== "string" || raw === "") return null;
+  const parsed = parseJson(raw);
+  if (isRecord(parsed)) {
+    for (const field of RESULT_FIELDS) {
+      const value = parsed[field];
+      if (typeof value === "string") return value;
+    }
+  }
+  return raw;
+}
+function parseCursorStore(rows) {
+  const bySession = /* @__PURE__ */ new Map();
+  for (const row2 of rows) {
+    const parts = row2.key.split(":");
+    if (parts.length < 3 || parts[0] !== "bubbleId") continue;
+    const id = parts[1] ?? "";
+    if (id === "") continue;
+    let session = bySession.get(id);
+    if (session === void 0) {
+      session = { events: [], roots: [], latest: 0, skipped: 0 };
+      bySession.set(id, session);
+    }
+    const bubble = parseJson(row2.value);
+    if (!isRecord(bubble)) {
+      session.skipped += 1;
+      continue;
+    }
+    const at = typeof bubble["createdAt"] === "string" ? bubble["createdAt"] : "";
+    const moment = Date.parse(at);
+    if (Number.isFinite(moment)) session.latest = Math.max(session.latest, moment);
+    const former = bubble["toolFormerData"];
+    if (!isRecord(former)) continue;
+    const name = typeof former["name"] === "string" ? former["name"] : "";
+    if (name === "") continue;
+    const call = callOf(name, parseJson(former["params"]));
+    for (const path of call.paths) if (!session.roots.includes(path)) session.roots.push(path);
+    const callId = typeof former["toolCallId"] === "string" && former["toolCallId"] !== "" ? former["toolCallId"] : parts.slice(2).join(":") ?? "";
+    session.events.push({ kind: "pre", id: callId, tool: call.tool, input: call.input, at });
+    const text = resultTextOf(former["result"]);
+    if (text === null) continue;
+    session.events.push({
+      kind: "post",
+      id: callId,
+      tool: call.tool,
+      input: call.input,
+      resultText: text,
+      at
+    });
+  }
+  return [...bySession.entries()].map(([id, s]) => ({
+    id,
+    mtimeMs: s.latest,
+    roots: s.roots,
+    transcript: {
+      sessionId: id,
+      cwd: s.roots[0] ?? null,
+      events: s.events,
+      skipped: s.skipped
+    }
+  })).sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+function cursorStateDb(plat = process.platform, env = process.env, home = homedir22()) {
+  const base = plat === "darwin" ? join27(home, "Library", "Application Support", "Cursor") : plat === "win32" ? join27(env["APPDATA"] ?? join27(home, "AppData", "Roaming"), "Cursor") : join27(home, ".config", "Cursor");
+  return join27(base, "User", "globalStorage", "state.vscdb");
+}
+var cursorSessionPath = (db, session) => `${db}#${session}`;
+function splitCursorSessionPath(path) {
+  const hash = path.lastIndexOf("#");
+  if (hash <= 0) return { db: path, session: null };
+  return { db: path.slice(0, hash), session: path.slice(hash + 1) };
+}
+var sqlitePromise = null;
+async function sqlite() {
+  sqlitePromise ??= (async () => {
+    const emit2 = process.emitWarning;
+    process.emitWarning = ((warning, ...rest) => {
+      const name = typeof warning === "string" ? String(rest[0] ?? "") : warning.name;
+      const text = typeof warning === "string" ? warning : warning.message;
+      if (name === "ExperimentalWarning" && text.includes("SQLite")) return;
+      emit2.call(process, warning, ...rest);
+    });
+    try {
+      return await import("sqlite");
+    } catch {
+      return null;
+    } finally {
+      process.emitWarning = emit2;
+    }
+  })();
+  return sqlitePromise;
+}
+async function cursorUnavailable() {
+  if (await sqlite() !== null) return null;
+  return `Cursor sessions need node:sqlite, which ${process.version} does not have \u2014 Node 22.23 or newer reads them`;
+}
+async function storeRows(db, session) {
+  const mod = await sqlite();
+  if (mod === null) return [];
+  let handle;
+  try {
+    handle = new mod.DatabaseSync(db, { readOnly: true });
+  } catch {
+    return [];
+  }
+  try {
+    const like = session === null ? "bubbleId:%" : `bubbleId:${session}:%`;
+    const rows = handle.prepare("select key, value from cursorDiskKV where key like ?").all(like);
+    return rows.flatMap((row2) => {
+      const { key: key2, value } = row2;
+      return typeof key2 === "string" && typeof value === "string" ? [{ key: key2, value }] : [];
+    });
+  } catch {
+    return [];
+  } finally {
+    handle.close();
+  }
+}
+function isUnder(path, dir) {
+  if (dir === "") return false;
+  const base = dir.endsWith("/") ? dir.slice(0, -1) : dir;
+  return path === base || path.startsWith(`${base}/`);
+}
+async function findCursorSessions(cwd, db) {
+  const store = db ?? cursorStateDb();
+  const sessions = parseCursorStore(await storeRows(store, null));
+  const files = (list) => list.map((s) => ({ path: cursorSessionPath(store, s.id), mtimeMs: s.mtimeMs }));
+  const here = sessions.filter((s) => s.roots.some((root) => isUnder(root, cwd)));
+  return here.length > 0 ? files(here) : files(sessions);
+}
+async function readCursorSession(path) {
+  const { db, session } = splitCursorSessionPath(path);
+  const sessions = parseCursorStore(await storeRows(db, session));
+  const found = session === null ? sessions[0] : sessions.find((s) => s.id === session);
+  return found?.transcript ?? { sessionId: session ?? "", cwd: null, events: [], skipped: 0 };
+}
+
+// src/sent/readers.ts
+var HEAD_BYTES = 64 * 1024;
 var claudeCodeReader = {
   agent: "claude-code",
   find: findTranscripts,
-  read: readTranscript
+  read: readTranscript,
+  root: "~/.claude/projects",
+  /* A Claude record is the message itself: `{type:'user'|'assistant', message:{…}}`,
+     with `sessionId` on nearly every line. A Codex record is an envelope around a
+     payload and has neither. */
+  claims: (head) => {
+    const record = tryParse(head);
+    if (!isRecord4(record)) return false;
+    return "message" in record || "sessionId" in record;
+  }
+};
+var codexReader = {
+  agent: "codex",
+  find: (cwd) => findCodexRollouts(cwd),
+  read: readCodexRollout,
+  root: "~/.codex/sessions",
+  /* Codex wraps every record: `{timestamp, ordinal, type, payload}`. The envelope
+     is the format, so its presence is the test. */
+  claims: (head) => {
+    const record = tryParse(head);
+    return isRecord4(record) && isRecord4(record["payload"]) && typeof record["type"] === "string";
+  }
+};
+var cursorReader = {
+  agent: "cursor",
+  find: (cwd) => findCursorSessions(cwd),
+  read: readCursorSession,
+  root: tilde(cursorStateDb()),
+  unavailable: cursorUnavailable,
+  /* A SQLite file announces itself in its first 16 bytes, and that is all the
+     dispatch needs: no other agent here writes one. */
+  claims: (head) => head.startsWith("SQLite format 3")
 };
-var READERS = [claudeCodeReader];
+var READERS = [claudeCodeReader, codexReader, cursorReader];
+async function readerNotices() {
+  const notices = [];
+  for (const reader of READERS) {
+    const why = await reader.unavailable?.();
+    if (why !== void 0 && why !== null) notices.push(why);
+  }
+  return notices;
+}
+function tilde(path) {
+  const home = homedir23();
+  return home !== "" && path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+var isRecord4 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function tryParse(line3) {
+  try {
+    return JSON.parse(line3);
+  } catch {
+    return null;
+  }
+}
+var READER_ROOTS = () => READERS.map((r) => r.root).join(" or ");
+async function readerForFile(path) {
+  let head = "";
+  try {
+    const handle = await open2(splitCursorSessionPath(path).db, "r");
+    try {
+      const buffer = Buffer.alloc(HEAD_BYTES);
+      const { bytesRead } = await handle.read(buffer, 0, HEAD_BYTES, 0);
+      head = buffer.subarray(0, bytesRead).toString("utf8").split("\n")[0] ?? "";
+    } finally {
+      await handle.close();
+    }
+  } catch {
+    return claudeCodeReader;
+  }
+  return READERS.find((reader) => reader.claims(head)) ?? claudeCodeReader;
+}
 async function newestTranscript(cwd) {
+  let best = null;
   for (const reader of READERS) {
-    const found = await reader.find(cwd);
-    const newest = found[0];
-    if (newest) return { reader, path: newest.path };
+    const newest = (await reader.find(cwd))[0];
+    if (!newest) continue;
+    if (best === null || newest.mtimeMs > best.mtimeMs) {
+      best = { reader, path: newest.path, mtimeMs: newest.mtimeMs };
+    }
   }
-  return null;
+  return best === null ? null : { reader: best.reader, path: best.path };
 }
 
 // src/sent/scan.ts
@@ -10882,7 +11772,7 @@ function emit(report, out) {
 var USAGE = `stroq sent \u2014 which of your credentials already reached a model provider
 
   stroq sent --last                 read the newest session in this directory
-  stroq sent --transcript <path>    read a specific transcript file
+  stroq sent --transcript <path>    read a specific transcript or rollout
   stroq sent [<session-id>]         read a session Stroq itself recorded
 
 Flags:
@@ -10890,9 +11780,10 @@ Flags:
   --fail-on-finding    exit 1 when a credential is found (for a scheduled job)
   -h, --help           show this
 
-It reads this machine's credential files to know what to look for, and prints
-names and sources only, never a value. A finding exits 0 by default: a session
-that already happened cannot be un-sent by today's commit.
+Reads Claude Code transcripts and Codex CLI rollouts; --transcript works out
+which from the file itself. It reads this machine's credential files to know what
+to look for, and prints names and sources only, never a value. A finding exits 0
+by default: a session that already happened cannot be un-sent by today's commit.
 `;
 async function runSent(args) {
   let parsed;
@@ -10924,7 +11815,7 @@ ${USAGE}`);
     failOnFinding: values["fail-on-finding"] === true
   };
   const cwd = process.cwd();
-  const home = homedir21();
+  const home = homedir24();
   const index = new FileSecretIndex(secretsFile(), home);
   const stats = await index.refresh(cwd);
   const scope = {
@@ -10935,14 +11826,18 @@ ${USAGE}`);
   };
   if (values.transcript !== void 0 || values.last === true) {
     const found = values.transcript === void 0 ? await newestTranscript(cwd) : (
-      // One reader is registered, so a transcript named on the command line is
-      // parsed by it. A second agent's format would need a way to tell them
-      // apart; writing that dispatch now would be guessing at a format nobody
-      // here can test against.
-      { reader: claudeCodeReader, path: values.transcript }
+      // Chosen by what is in the file, not by where it is: a Codex rollout
+      // parsed as a Claude transcript yields no events at all, which prints
+      // as a clean session rather than as the mistake it is.
+      { reader: await readerForFile(values.transcript), path: values.transcript }
     );
     if (found === null) {
-      process.stdout.write("no agent transcript found \u2014 looked under ~/.claude/projects\n");
+      const notices = await readerNotices();
+      process.stdout.write(
+        `no agent transcript found \u2014 looked under ${READER_ROOTS()}
+` + notices.map((why) => `  note: ${why}
+`).join("")
+      );
       return 1;
     }
     const transcript = await found.reader.read(found.path);
@@ -11064,13 +11959,13 @@ function runTrust(argv, now = () => /* @__PURE__ */ new Date()) {
 // src/commands/untaint.ts
 import { existsSync as existsSync14, readdirSync as readdirSync7 } from "fs";
 import { rm as rm6 } from "fs/promises";
-import { join as join26 } from "path";
+import { join as join28 } from "path";
 import { parseArgs as parseArgs11 } from "util";
 var USAGE2 = "usage: stroq untaint --session <id> | --all\n";
 async function clearAll() {
   const dir = sessionsDir();
   if (!existsSync14(dir)) return;
-  await Promise.all(readdirSync7(dir).map((f) => rm6(join26(dir, f), { force: true })));
+  await Promise.all(readdirSync7(dir).map((f) => rm6(join28(dir, f), { force: true })));
 }
 async function runUntaint(args) {
   const { values } = parseArgs11({

package/openclaw-plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "stroq",
   "name": "Stroq",
   "description": "Local action firewall for OpenClaw: scans what the agent reads, taints the session, blocks or asks before dangerous tool calls.",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stroq-openclaw-plugin",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "private": true,
   "description": "Stroq's OpenClaw plugin entry: forwards before_tool_call and after_tool_call to the Stroq CLI.",
   "type": "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stroq/cli",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "description": "Local action firewall for AI agents: scans what the agent reads, taints the session, blocks dangerous follow-up actions",
   "license": "Apache-2.0",
   "type": "module",