@stroq/cli 0.12.1 → 0.13.0

package/dist/index.js

@@ -1526,6 +1526,7 @@ function firstArgAfter(segment2) {
 // ../core/src/actions/self-config.ts
 var SELF_CONFIG_FILE = /(\.claude\/settings(\.local)?\.json|\.cursor\/hooks\.json|\.codex\/(hooks\.json|config\.toml)|\.github\/(hooks(?![\w.-])|copilot\/settings(\.local)?\.json)|\.copilot\/(hooks(?![\w.-])|settings\.json|config\.json)|\.openclaw\/(openclaw\.json|plugins(?![\w.-])|extensions(?![\w.-]))|(\.windsurf|\.codeium(\/windsurf)?)\/hooks\.json|(?<![\w.-])\/etc\/windsurf\/hooks\.json|Application(?:\\ | )Support\/Windsurf\/hooks\.json|(?<![\w.-])claude_desktop_config\.json|(?<![\w.-])mcp_config\.json|\.stroq(\/|\b))/;
 var PROTECTED_DIRS = /\.(claude|cursor|codex|copilot|openclaw|stroq|windsurf|codeium|github\/(hooks|copilot))(\/|$|\s)/;
+var PROTECTED_DIR_BARE = /(^|[\s"'=(])(?:[\w.~/-]*\/)?(?:\.(claude|cursor|codex|copilot|openclaw|stroq|windsurf|codeium)|\.github\/(hooks|copilot))(?:\/\*?|\*)?(?=$|[\s"';|&)])/i;
 var SELF_CONFIG_READ_COMMANDS = /* @__PURE__ */ new Set([
   "cat",
   "less",
@@ -1608,7 +1609,8 @@ function isFindWriteIntent(segment2) {
 }
 function touchesSelfConfig(segment2, word) {
   if (SELF_CONFIG_FILE.test(segment2)) return true;
-  return word === "find" && PROTECTED_DIRS.test(segment2);
+  if (word === "find" && PROTECTED_DIRS.test(segment2)) return true;
+  return SELF_CONFIG_WRITE_COMMANDS.has(word) && PROTECTED_DIR_BARE.test(segment2);
 }
 function isSelfConfigWriteIntent(segment2, word) {
   if (SELF_CONFIG_WRITE_COMMANDS.has(word)) return true;
@@ -1924,7 +1926,7 @@ function classifyCommand(command, cwd) {
 }
 
 // ../core/src/actions/classify-tool.ts
-var SECRET_PATH = /(\/\.ssh\/|\bid_(rsa|ed25519|ecdsa|dsa)\b|\/\.aws\/|(^|\/)\.env(\.[\w-]+)?$|\.(pem|p12|pfx|key)$|\/\.(npmrc|netrc|pgpass|git-credentials)$|\/\.kube\/config$|\/\.config\/gcloud\/|\/etc\/(shadow|passwd)$)/;
+var SECRET_PATH = /(\/\.ssh(\/|$)|\bid_(rsa|ed25519|ecdsa|dsa)\b|\/\.aws(\/|$)|(^|\/)\.env(\.[\w-]+)?$|\.(pem|p12|pfx|key)$|\/\.(npmrc|netrc|pgpass|git-credentials)$|\/\.kube(\/config$|$)|\/\.config\/gcloud(\/|$)|\/etc\/(shadow|passwd)$)/;
 var SIDE_EFFECT_TOOL = /(send|post|publish|upload|email|mail|message|notify|pay|transfer|purchase|delete|remove|drop|deploy|execute|exec|run|shell|write|update|create|comment|merge|push)/i;
 var WRITE_SHAPED_TOOL = /(write|edit|delete|remove|move|rename|append|put|save|update|create_file|mkdir)/i;
 var PATH_LIKE_KEY = /^(path|filepath|file_path|file|target|dest|destination|uri|url)s?$/i;
@@ -1941,7 +1943,20 @@ function pathOf(toolInput) {
   const candidate = toolInput["file_path"] ?? toolInput["notebook_path"] ?? toolInput["path"] ?? "";
   return typeof candidate === "string" ? candidate : "";
 }
-function classifyPath(path, write2) {
+function normalizePathForMatch(path) {
+  const collapsed = path.replace(/(^|\/)\.(?=\/)/g, "$1").replace(/\/{2,}/g, "/");
+  const segments = [];
+  for (const segment2 of collapsed.split("/")) {
+    if (segment2 === ".." && segments.length > 0 && segments[segments.length - 1] !== "..") {
+      segments.pop();
+    } else {
+      segments.push(segment2);
+    }
+  }
+  return segments.join("/").toLowerCase();
+}
+function classifyPath(rawPath, write2) {
+  const path = normalizePathForMatch(rawPath);
   const classes = [];
   const signals = [];
   if (write2 && SELF_CONFIG_FILE.test(path)) {
@@ -2593,8 +2608,14 @@ function pipeShellAtoms(text) {
     atom: { kind: "pipe_shell", value: collapse(m[0]) }
   }));
 }
+var PATH_SEGMENT_MAX = 16;
+function looksLikePath(body) {
+  const parts = body.split("/");
+  return parts.length >= 3 && parts.every((part) => part.length <= PATH_SEGMENT_MAX);
+}
 function looksBase64(token) {
   const body = token.replace(/=+$/, "");
+  if (looksLikePath(body)) return false;
   return !HEX.test(body) && /[a-z]/.test(body) && /[A-Z]/.test(body) && /[0-9+/]/.test(body);
 }
 function encodedAtoms(text) {
@@ -6602,8 +6623,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 stat2 = statSync8(file);
-    if (!stat2.isFile() || stat2.size > MAX_CONFIG_BYTES) return fallback;
+    const stat3 = statSync8(file);
+    if (!stat3.isFile() || stat3.size > MAX_CONFIG_BYTES) return fallback;
     return readFileSync15(file, "utf8");
   } catch {
     return fallback;
@@ -6664,8 +6685,8 @@ function gitHookHits(root) {
   try {
     return readdirSync6(dir).filter((name) => !name.endsWith(".sample")).filter((name) => {
       try {
-        const stat2 = statSync8(join19(dir, name));
-        return stat2.isFile() && (stat2.mode & 73) !== 0;
+        const stat3 = statSync8(join19(dir, name));
+        return stat3.isFile() && (stat3.mode & 73) !== 0;
       } catch {
         return false;
       }
@@ -8426,10 +8447,397 @@ ${MCP_USAGE}`);
   });
 }
 
+// src/commands/replay.ts
+import { mkdtemp as mkdtemp2, rm as rm5 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join21 } from "path";
+import { parseArgs as parseArgs8 } from "util";
+
+// src/replay/transcript.ts
+import { readdir, readFile as readFile5, stat as stat2 } from "fs/promises";
+import { homedir as homedir17 } from "os";
+import { join as join20 } from "path";
+var isRecord2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function resultText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((b) => {
+    if (typeof b === "string") return b;
+    if (isRecord2(b) && typeof b["text"] === "string") return b["text"];
+    return "";
+  }).filter((t) => t.length > 0).join("\n");
+}
+function blocksOf(record) {
+  const message = record["message"];
+  if (!isRecord2(message)) return [];
+  const content = message["content"];
+  return Array.isArray(content) ? content.filter(isRecord2) : [];
+}
+function parseTranscript(text) {
+  const events = [];
+  const pending = /* @__PURE__ */ new Map();
+  let sessionId = "transcript";
+  let cwd = null;
+  let skipped = 0;
+  for (const line2 of text.split("\n")) {
+    if (line2.trim().length === 0) continue;
+    let record;
+    try {
+      record = JSON.parse(line2);
+    } catch {
+      skipped += 1;
+      continue;
+    }
+    if (!isRecord2(record)) {
+      skipped += 1;
+      continue;
+    }
+    if (typeof record["sessionId"] === "string") sessionId = record["sessionId"];
+    if (cwd === null && typeof record["cwd"] === "string") cwd = record["cwd"];
+    const at = typeof record["timestamp"] === "string" ? record["timestamp"] : "";
+    for (const block of blocksOf(record)) {
+      if (block.type === "tool_use" && typeof block.id === "string") {
+        const tool = typeof block.name === "string" ? block.name : "unknown";
+        const input = isRecord2(block.input) ? block.input : {};
+        pending.set(block.id, { tool, input });
+        events.push({ kind: "pre", id: block.id, tool, input, at });
+        continue;
+      }
+      if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+        const call = pending.get(block.tool_use_id);
+        if (!call) continue;
+        events.push({
+          kind: "post",
+          id: block.tool_use_id,
+          tool: call.tool,
+          input: call.input,
+          resultText: resultText(block.content),
+          at
+        });
+      }
+    }
+  }
+  return { sessionId, cwd, events, skipped };
+}
+function projectSlug(cwd) {
+  return cwd.replace(/[/.]/g, "-");
+}
+var transcriptRoot = () => join20(homedir17(), ".claude", "projects");
+async function findTranscripts(cwd) {
+  const root = transcriptRoot();
+  const scoped = join20(root, projectSlug(cwd));
+  const found = await listJsonl(scoped) ?? [];
+  if (found.length > 0) return found.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  let dirs;
+  try {
+    dirs = (await readdir(root, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => join20(root, d.name));
+  } catch {
+    return [];
+  }
+  const all = [];
+  for (const dir of dirs) all.push(...await listJsonl(dir) ?? []);
+  return all.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+async function listJsonl(dir) {
+  let names;
+  try {
+    names = await readdir(dir);
+  } catch {
+    return null;
+  }
+  const files = [];
+  for (const name of names) {
+    if (!name.endsWith(".jsonl")) continue;
+    const path = join20(dir, name);
+    try {
+      files.push({ path, mtimeMs: (await stat2(path)).mtimeMs });
+    } catch {
+    }
+  }
+  return files;
+}
+async function readTranscript(path) {
+  return parseTranscript(await readFile5(path, "utf8"));
+}
+
+// src/commands/replay.ts
+var CLIP = /…+$/;
+var sourceKey = (tool, source) => JSON.stringify([tool, source]);
+var ATOM_RANK = {
+  pipe_shell: 4,
+  encoded: 3,
+  pkg: 2,
+  url: 1,
+  host: 0
+};
+var atomRank = (ev) => ATOM_RANK[ev.kind] ?? 0;
+function sameSource(summary, source) {
+  const a = summary.replace(CLIP, "");
+  const b = source.replace(CLIP, "");
+  if (a.length === 0 || b.length === 0) return false;
+  return a.startsWith(b) || b.startsWith(a);
+}
+function findRead(entries, ev) {
+  const candidates = entries.filter(
+    (e) => e.phase === "post" && e.tool === ev.tool && sameSource(e.summary, ev.source)
+  );
+  if (candidates.length === 0) return null;
+  const at = Date.parse(ev.at);
+  const before = candidates.filter((e) => Date.parse(e.ts) <= at + 1e3);
+  return (before.length > 0 ? before : candidates)[(before.length > 0 ? before : candidates).length - 1];
+}
+function taintingReads(entries) {
+  return entries.filter((e) => e.phase === "post" && e.scan?.verdict === "suspect");
+}
+function buildReplay(allEntries, sessionId) {
+  const entries = allEntries.filter((e) => e.sessionId === sessionId);
+  const actions = entries.filter((e) => e.phase === "pre");
+  const bySource = /* @__PURE__ */ new Map();
+  const ensure = (tool, source, at, suspect) => {
+    const key = sourceKey(tool, source);
+    const existing = bySource.get(key);
+    if (existing) return existing.list;
+    const list = [];
+    bySource.set(key, {
+      source: {
+        tool,
+        source,
+        at,
+        suspect,
+        read: findRead(entries, { tool, source, at, suspect, kind: "url", excerpt: "" }),
+        consequences: list
+      },
+      list
+    });
+    return list;
+  };
+  for (const read3 of taintingReads(entries)) {
+    ensure(read3.tool, read3.summary, read3.ts, true);
+  }
+  for (const action of actions) {
+    for (const ev of action.provenance ?? []) {
+      ensure(ev.tool, ev.source, ev.at, ev.suspect).push({ action, evidence: ev, alsoCarried: 0 });
+    }
+  }
+  for (const group of bySource.values()) {
+    const byAction = /* @__PURE__ */ new Map();
+    for (const c of group.list) {
+      byAction.set(c.action.seq, [...byAction.get(c.action.seq) ?? [], c]);
+    }
+    const merged = [...byAction.values()].map((carried) => {
+      const best = carried.reduce((a, b) => atomRank(b.evidence) > atomRank(a.evidence) ? b : a);
+      return { ...best, alsoCarried: carried.length - 1 };
+    });
+    group.list.length = 0;
+    group.list.push(...merged.sort((a, b) => a.action.seq - b.action.seq));
+  }
+  const linked = new Set([...bySource.values()].flatMap((g) => g.list.map((c) => c.action.seq)));
+  const secretActions = actions.filter((a) => (a.secrets ?? []).length > 0 && !linked.has(a.seq));
+  const secretSeqs = new Set(secretActions.map((a) => a.seq));
+  const unlinked = actions.filter((a) => !linked.has(a.seq) && !secretSeqs.has(a.seq));
+  const sources = [...bySource.values()].map((g) => ({ ...g.source, consequences: g.list })).sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+  return {
+    sessionId,
+    total: entries.length,
+    first: entries[0]?.ts ?? null,
+    last: entries[entries.length - 1]?.ts ?? null,
+    sources,
+    secretActions,
+    unlinked,
+    denied: actions.filter((a) => a.decision?.effect === "deny").length,
+    asked: actions.filter((a) => a.decision?.effect === "ask").length
+  };
+}
+var RULE_PREVIEW = 3;
+function verdictTag(entry2) {
+  const d = entry2.decision;
+  if (!d) return "";
+  if (d.effect === "deny") return `DENIED  ${d.ruleId ?? "default"}`;
+  if (d.effect === "ask") return `ASKED   ${d.ruleId ?? "default"}`;
+  return `allowed ${d.ruleId ?? "default"}`;
+}
+function readLine(src) {
+  const scan = src.read?.scan;
+  if (!scan) {
+    return src.suspect ? "flagged suspicious" : "no rule matched it, but tool output is data, not instructions";
+  }
+  if (scan.verdict !== "suspect") {
+    return `clean \u2014 no rule matched it, but tool output is data, not instructions`;
+  }
+  const ids = scan.ruleIds.slice(0, RULE_PREVIEW).join(", ");
+  const more = scan.ruleIds.length > RULE_PREVIEW ? `, +${scan.ruleIds.length - RULE_PREVIEW}` : "";
+  const waived = scan.trusted === true ? " \u2014 waived by stroq trust" : "";
+  return `SUSPECT ${scan.score.toFixed(2)} \u2014 ${scan.ruleIds.length} rules: ${ids}${more}${waived}`;
+}
+var secretLine = (s) => `${s.name} from ${s.source}${s.canary ? " (canary)" : ""}`;
+function consequenceBlock(c, last) {
+  const elbow = last ? "  \u2514\u2500\u25BA" : "  \u251C\u2500\u25BA";
+  const rail = last ? "     " : "  \u2502  ";
+  const gap = ageLabel(c.evidence.at, new Date(c.action.ts));
+  return [
+    `${elbow} #${c.action.seq} ${c.action.tool}  ${c.action.summary}`,
+    `${rail}   ${verdictTag(c.action)}${" ".repeat(Math.max(1, 34 - verdictTag(c.action).length))}${gap} later`,
+    `${rail}   carried over: "${c.evidence.excerpt}" (${c.evidence.kind})` + (c.alsoCarried > 0 ? ` and ${c.alsoCarried} more` : "")
+  ];
+}
+function sourceBlock(src) {
+  const seq = src.read ? `#${src.read.seq} ` : "";
+  const head = [`  \u25A0 ${seq}${src.tool}  ${src.source}`, `      ${readLine(src)}`];
+  if (src.consequences.length === 0) {
+    return [...head, "      nothing traced back to it", ""];
+  }
+  const body = src.consequences.flatMap(
+    (c, i) => consequenceBlock(c, i === src.consequences.length - 1)
+  );
+  return [...head, "  \u2502", ...body, ""];
+}
+function duration(model) {
+  if (!model.first || !model.last) return "";
+  return ` \xB7 ${ageLabel(model.first, new Date(model.last))} long`;
+}
+function formatReplay(model) {
+  if (model.total === 0) {
+    return `no audit entries for session ${model.sessionId}
+`;
+  }
+  const traced = new Set(model.sources.flatMap((s) => s.consequences.map((c) => c.action.seq))).size;
+  const lines = [
+    "stroq replay \u2014 what the agent did, and what told it to do it",
+    "",
+    `  session ${model.sessionId} \xB7 ${model.total} events${duration(model)} \xB7 ${model.denied} denied \xB7 ${model.asked} asked`,
+    ""
+  ];
+  if (model.sources.length > 0) {
+    lines.push("CONTENT THE AGENT READ, AND WHAT CAME OUT OF IT", "");
+    for (const src of model.sources) lines.push(...sourceBlock(src));
+  }
+  if (model.secretActions.length > 0) {
+    lines.push("ACTIONS CARRYING A KNOWN SECRET VALUE", "");
+    for (const a of model.secretActions) {
+      lines.push(`  \u25CF #${a.seq} ${a.tool}  ${a.summary}`);
+      lines.push(`      ${verdictTag(a)}`);
+      for (const s of a.secrets ?? []) lines.push(`      ${secretLine(s)}`);
+      lines.push("");
+    }
+  }
+  if (model.unlinked.length > 0) {
+    lines.push(`ACTIONS WITH NO UNTRUSTED ORIGIN (${model.unlinked.length})`, "");
+    for (const a of model.unlinked) {
+      const tag = a.decision ? a.decision.effect : "-";
+      lines.push(`  \u25CB #${a.seq} ${a.tool}  ${a.summary}`);
+      lines.push(`      ${tag}`);
+    }
+    lines.push("");
+  }
+  const judged = traced + model.secretActions.length + model.unlinked.length;
+  lines.push(
+    traced === 0 ? "No action in this session traced back to content the agent read." : `${traced} of ${judged} judged actions traced back to content the agent read.`
+  );
+  return `${lines.join("\n")}
+`;
+}
+function sessionsIn(entries) {
+  const lastSeen = /* @__PURE__ */ new Map();
+  for (const e of entries) lastSeen.set(e.sessionId, e.seq);
+  return [...lastSeen.entries()].sort((a, b) => b[1] - a[1]).map(([id]) => id);
+}
+async function replayTranscript(transcript) {
+  const root = await mkdtemp2(join21(tmpdir2(), "stroq-replay-"));
+  try {
+    const home = join21(root, "home");
+    const engine = createEngineAt({
+      home,
+      userHome: join21(root, "user"),
+      policy: loadPolicy(),
+      env: {}
+    });
+    const cwd = transcript.cwd ?? process.cwd();
+    for (const ev of transcript.events) {
+      const base = {
+        sessionId: transcript.sessionId,
+        toolName: ev.tool,
+        toolInput: ev.input,
+        cwd
+      };
+      try {
+        if (ev.kind === "pre") await engine.pre(base);
+        else await engine.post({ ...base, toolResultText: ev.resultText });
+      } catch {
+      }
+    }
+    return await new AuditLog(auditFileIn(home)).readAll();
+  } finally {
+    await rm5(root, { recursive: true, force: true });
+  }
+}
+async function runReplay(args) {
+  const { values, positionals } = parseArgs8({
+    args: [...args],
+    options: {
+      json: { type: "boolean" },
+      list: { type: "boolean" },
+      transcript: { type: "string" },
+      last: { type: "boolean" }
+    },
+    allowPositionals: true
+  });
+  if (values.transcript !== void 0 || values.last === true) {
+    const path = values.transcript ?? (await findTranscripts(process.cwd()))[0]?.path;
+    if (path === void 0) {
+      process.stdout.write("no agent transcript found \u2014 looked under ~/.claude/projects\n");
+      return 1;
+    }
+    const transcript = await readTranscript(path);
+    if (transcript.events.length === 0) {
+      process.stdout.write(`no tool calls recorded in ${path}
+`);
+      return 1;
+    }
+    const replayed = await replayTranscript(transcript);
+    const model2 = buildReplay(replayed, transcript.sessionId);
+    if (values.json === true) {
+      process.stdout.write(`${JSON.stringify(model2, null, 2)}
+`);
+      return 0;
+    }
+    process.stdout.write(`${formatReplay(model2)}
+replayed from ${path}
+`);
+    return 0;
+  }
+  const entries = await new AuditLog(auditFile()).readAll();
+  const sessions = sessionsIn(entries);
+  if (values.list === true) {
+    if (sessions.length === 0) {
+      process.stdout.write("no audit entries yet\n");
+      return 0;
+    }
+    for (const id of sessions) {
+      const n = entries.filter((e) => e.sessionId === id).length;
+      process.stdout.write(`${id}  ${n} events
+`);
+    }
+    return 0;
+  }
+  const sessionId = positionals[0] ?? sessions[0];
+  if (sessionId === void 0) {
+    process.stdout.write("no audit entries yet\n");
+    return 1;
+  }
+  const model = buildReplay(entries, sessionId);
+  if (values.json === true) {
+    process.stdout.write(`${JSON.stringify(model, null, 2)}
+`);
+    return 0;
+  }
+  process.stdout.write(formatReplay(model));
+  return model.total === 0 ? 1 : 0;
+}
+
 // src/commands/trust.ts
 import { chmodSync as chmodSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync16, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname7, resolve as resolve7 } from "path";
-import { parseArgs as parseArgs8 } from "util";
+import { parseArgs as parseArgs9 } from "util";
 function read2(file) {
   try {
     return parseTrustList(readFileSync16(file, "utf8"));
@@ -8484,7 +8892,7 @@ function formatList(entries) {
 `;
 }
 function runTrust(argv, now = () => /* @__PURE__ */ new Date()) {
-  const { values, positionals } = parseArgs8({
+  const { values, positionals } = parseArgs9({
     args: [...argv],
     options: { list: { type: "boolean" }, remove: { type: "string" }, json: { type: "boolean" } },
     allowPositionals: true
@@ -8519,17 +8927,17 @@ function runTrust(argv, now = () => /* @__PURE__ */ new Date()) {
 
 // src/commands/untaint.ts
 import { existsSync as existsSync14, readdirSync as readdirSync7 } from "fs";
-import { rm as rm5 } from "fs/promises";
-import { join as join20 } from "path";
-import { parseArgs as parseArgs9 } from "util";
+import { rm as rm6 } from "fs/promises";
+import { join as join22 } from "path";
+import { parseArgs as parseArgs10 } from "util";
 var USAGE = "usage: stroq untaint --session <id> | --all\n";
 async function clearAll() {
   const dir = sessionsDir();
   if (!existsSync14(dir)) return;
-  await Promise.all(readdirSync7(dir).map((f) => rm5(join20(dir, f), { force: true })));
+  await Promise.all(readdirSync7(dir).map((f) => rm6(join22(dir, f), { force: true })));
 }
 async function runUntaint(args) {
-  const { values } = parseArgs9({
+  const { values } = parseArgs10({
     args: [...args],
     options: {
       session: { type: "string" },
@@ -8566,7 +8974,7 @@ async function runVerify() {
 }
 
 // src/commands/why.ts
-import { parseArgs as parseArgs10 } from "util";
+import { parseArgs as parseArgs11 } from "util";
 function verdictLine(entry2) {
   if (entry2.decision) {
     return `${entry2.decision.effect} by ${entry2.decision.ruleId ?? "default"}: ${entry2.decision.reason}`;
@@ -8599,7 +9007,7 @@ function formatWhy(entry2, state, now) {
 `;
 }
 async function runWhy(args) {
-  const { values } = parseArgs10({ args: [...args], options: { seq: { type: "string" } } });
+  const { values } = parseArgs11({ args: [...args], options: { seq: { type: "string" } } });
   const entries = await new AuditLog(auditFile()).readAll();
   const seq = values.seq === void 0 ? null : Number.parseInt(values.seq, 10);
   const target = seq === null ? [...entries].reverse().find((e) => e.decision !== void 0 && e.decision.effect !== "allow") : entries.find((e) => e.seq === seq);
@@ -8632,6 +9040,10 @@ Commands:
   verify                             verify the audit hash chain
   untaint [--session <id>] [--all]   clear a false-positive session's taint, or every session's
   why [--seq <n>]                    explain the most recent denied/asked action: rule, provenance, taint
+  replay [<session>] [--last] [--transcript <path>] [--json] [--list]
+                                     rebuild a session's causal history: which content the agent read,
+                                     and which actions came out of it. --last reads the agent's own
+                                     transcript, so it works on sessions that ran before you installed
   canary [--name <NAME>]             print a canary secret to plant; its outbound use is denied and taints the session
   attack [--json] [--only <id>] [--fuzz]
                                      replay recorded incidents against your policy; exit 1 if any gets
@@ -8677,6 +9089,8 @@ async function main(argv) {
       return runTrust(rest);
     case "untaint":
       return runUntaint(rest);
+    case "replay":
+      return runReplay(rest);
     case "why":
       return runWhy(rest);
     case "canary":

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.12.1",
+  "version": "0.13.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stroq-openclaw-plugin",
-  "version": "0.12.1",
+  "version": "0.13.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.12.1",
+  "version": "0.13.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",