@workscribe/cli 3.0.1 → 3.2.0

package/dist/index.js

@@ -378,7 +378,7 @@ var init_logger = __esm({
       success: (msg) => console.log(import_chalk.default.green("\u2713"), msg),
       warn: (msg) => console.log(import_chalk.default.yellow("\u26A0"), msg),
       error: (msg) => console.error(import_chalk.default.red("\u2717"), msg),
-      /** A warning on stderr — keeps stdout clean for JSON output (summary.format=json) and pipes. */
+      /** A warning on stderr — keeps stdout clean for JSON and plain text output, and pipes. */
       notice: (msg) => process.stderr.write(`${import_chalk.default.yellow("\u26A0")} ${msg}
 `),
       plain: (msg) => console.log(msg)
@@ -972,6 +972,13 @@ function maskQuotedText(text) {
   }
   return masked.join("");
 }
+function maskLiteralText(text) {
+  const masked = Array.from({ length: text.length }, () => "_");
+  for (const { index, quote } of quotedCharacters(text)) {
+    if (quote !== "'") masked[index] = text[index];
+  }
+  return masked.join("");
+}
 function startsWithWord(step2, word) {
   return step2 === word || step2.startsWith(`${word} `) || step2.startsWith(`${word}	`);
 }
@@ -1175,57 +1182,6 @@ var init_exclusions = __esm({
   }
 });
 
-// src/normalize/compound.ts
-function rankOf(category) {
-  const index = STEP_CATEGORY_PRIORITY.indexOf(category);
-  if (index !== -1) return index;
-  if (category === UNCLASSIFIED.category) return UNCLASSIFIED_RANK;
-  if (DEFAULT_EXCLUDED_CATEGORIES.has(category)) return EXCLUDED_CATEGORY_RANK;
-  return OTHER_CATEGORY_RANK;
-}
-function primaryStepEvent(steps, matchCommand) {
-  const events = steps.map((step2) => ({ ...matchCommand(simpleCommandOf(step2), step2), matchedStep: step2 }));
-  return events.reduce(
-    (best, event) => rankOf(event.category) < rankOf(best.category) ? event : best,
-    UNCLASSIFIED
-  );
-}
-function classifyCompound(command, matchCommand) {
-  const workSteps = commandSteps(command).filter((step2) => !isGlueStep(step2));
-  const wholeCommandEvent = {
-    ...matchCommand(command, command),
-    matchedStep: workSteps.length === 1 ? workSteps[0] : command
-  };
-  const isRecognisedSingleCommand = workSteps.length <= 1 && wholeCommandEvent.category !== UNCLASSIFIED.category;
-  if (isRecognisedSingleCommand || workSteps.length === 0) return wholeCommandEvent;
-  const primaryEvent = primaryStepEvent(workSteps, matchCommand);
-  return primaryEvent.category === UNCLASSIFIED.category ? wholeCommandEvent : primaryEvent;
-}
-var UNCLASSIFIED, STEP_CATEGORY_PRIORITY, OTHER_CATEGORY_RANK, EXCLUDED_CATEGORY_RANK, UNCLASSIFIED_RANK;
-var init_compound = __esm({
-  "src/normalize/compound.ts"() {
-    "use strict";
-    init_command_steps();
-    init_exclusions();
-    UNCLASSIFIED = { category: "other", metadata: {} };
-    STEP_CATEGORY_PRIORITY = [
-      "testing",
-      "building",
-      "releasing",
-      "shipping",
-      "dependencies",
-      "database",
-      "infrastructure",
-      "running",
-      "files",
-      "versioning"
-    ];
-    OTHER_CATEGORY_RANK = STEP_CATEGORY_PRIORITY.length;
-    EXCLUDED_CATEGORY_RANK = OTHER_CATEGORY_RANK + 1;
-    UNCLASSIFIED_RANK = EXCLUDED_CATEGORY_RANK + 1;
-  }
-});
-
 // src/normalize/git-invocation.ts
 function parseGitInvocation(command) {
   const words = shellWords(command.trim());
@@ -1282,6 +1238,198 @@ var init_git_invocation = __esm({
   }
 });
 
+// src/normalize/read-only.ts
+function hasNoOption(args, options) {
+  return !args.some((arg) => options.some((option) => arg === option || arg.startsWith(`${option}=`)));
+}
+function runsInlineCode(args, inlineFlags) {
+  const firstMeaningful = args.find(
+    (arg) => inlineFlags.includes(arg) || arg.startsWith("--eval=") || !arg.startsWith("-")
+  );
+  return firstMeaningful !== void 0 && (inlineFlags.includes(firstMeaningful) || firstMeaningful.startsWith("--eval="));
+}
+function readSedShortOptions(option, nextArg, parsed) {
+  const letters = option.slice(1);
+  const expressionAt = letters.indexOf("e");
+  if (SED_UNSAFE_SHORT_OPTION.test(letters) || expressionAt !== -1 && expressionAt !== letters.length - 1) {
+    parsed.isSafe = false;
+  }
+  if (letters.includes("n")) parsed.isQuiet = true;
+  if (expressionAt === -1) return 0;
+  parsed.scripts.push(nextArg ?? "");
+  return 1;
+}
+function readSedArguments(args) {
+  const parsed = { isQuiet: false, isSafe: true, scripts: [] };
+  const positional = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--quiet" || arg === "--silent") parsed.isQuiet = true;
+    else if (arg.startsWith("--in-place") || arg.startsWith("--file")) parsed.isSafe = false;
+    else if (arg === "--expression") parsed.scripts.push(args[++index] ?? "");
+    else if (arg.startsWith("--expression=")) parsed.scripts.push(arg.slice("--expression=".length));
+    else if (SED_SHORT_OPTIONS.test(arg)) index += readSedShortOptions(arg, args[index + 1], parsed);
+    else if (!arg.startsWith("-")) positional.push(arg);
+  }
+  return { ...parsed, positional };
+}
+function sedOnlyPrints(args) {
+  const { isQuiet, isSafe, scripts, positional } = readSedArguments(args);
+  const allScripts = scripts.length > 0 ? scripts : positional.slice(0, 1);
+  if (!isQuiet || !isSafe || allScripts.length === 0) return false;
+  return allScripts.every(
+    (script) => script.split(";").filter((part) => part.trim() !== "").every((part) => SED_PRINT_COMMAND.test(part.trim()))
+  );
+}
+function isGitRead(command) {
+  const invocation = parseGitInvocation(command);
+  if (!invocation?.subcommand) return false;
+  const args = invocation.args.map(({ word }) => word);
+  if (invocation.subcommand === "branch") return args.length === 0;
+  return GIT_READS.has(invocation.subcommand) && hasNoOption(args, GIT_UNSAFE_OPTIONS);
+}
+function isReadingStage(stage, checks) {
+  const command = simpleCommandOf(stage);
+  const [name, ...args] = shellWords(command).map(({ word }) => word);
+  if (name === "git") return isGitRead(command);
+  return Object.hasOwn(checks, name ?? "") && checks[name](args);
+}
+function substitutionsOnlyRead(step2) {
+  if (!containsCommandSubstitution(step2)) return true;
+  if (PROCESS_SUBSTITUTION.test(maskQuotedText(step2))) return false;
+  const literalMasked = maskLiteralText(step2);
+  const commands = substitutionCommands(literalMasked);
+  const openers = literalMasked.split("$(").length - 1 + Math.ceil((literalMasked.split("`").length - 1) / 2);
+  return commands.length === openers && commands.every(isReadOnlyCommand);
+}
+function isReadOnlyStep(step2) {
+  if (!substitutionsOnlyRead(step2)) return false;
+  const [firstStage = "", ...laterStages] = splitOutsideQuotes(step2, PIPE_SEPARATORS2);
+  return isReadingStage(firstStage, READERS) && laterStages.every((stage) => isReadingStage(stage, { ...READERS, ...PIPE_FILTERS }));
+}
+function writesToFile(step2) {
+  return [...maskQuotedText(step2).matchAll(OUTPUT_REDIRECTION)].some(([, target]) => !HARMLESS_TARGET.test(target));
+}
+function isReadOnlyCommand(command) {
+  const steps = commandSteps(command);
+  if (steps.some(writesToFile)) return false;
+  const workSteps = steps.filter((step2) => !isGlueStep(step2));
+  return workSteps.length > 0 && workSteps.every(isReadOnlyStep);
+}
+function readOnlyMetadata(command) {
+  const firstWorkStep = commandSteps(command).find((step2) => !isGlueStep(step2)) ?? "";
+  const [firstStage = ""] = splitOutsideQuotes(firstWorkStep, PIPE_SEPARATORS2);
+  const simple = simpleCommandOf(firstStage);
+  const invocation = parseGitInvocation(simple);
+  return invocation ? { subcommand: invocation.subcommand } : { tool: shellWords(simple)[0]?.word ?? null };
+}
+var READ_ONLY_CATEGORY, PIPE_SEPARATORS2, ALWAYS_READS, GIT_READS, GIT_UNSAFE_OPTIONS, FIND_UNSAFE_ACTION, SED_ADDRESS, SED_PRINT_COMMAND, SED_SHORT_OPTIONS, SED_UNSAFE_SHORT_OPTION, OUTPUT_REDIRECTION, HARMLESS_TARGET, PROCESS_SUBSTITUTION, READERS, PIPE_FILTERS;
+var init_read_only = __esm({
+  "src/normalize/read-only.ts"() {
+    "use strict";
+    init_command_steps();
+    init_shell_syntax();
+    init_git_invocation();
+    READ_ONLY_CATEGORY = "exploring";
+    PIPE_SEPARATORS2 = ["|"];
+    ALWAYS_READS = () => true;
+    GIT_READS = /* @__PURE__ */ new Set(["diff", "log", "show", "status"]);
+    GIT_UNSAFE_OPTIONS = ["--output", "--ext-diff", "--textconv"];
+    FIND_UNSAFE_ACTION = /^-(?:delete|exec|execdir|ok|okdir|fls|fprint\w*)$/;
+    SED_ADDRESS = String.raw`(?:\d+|\$|/(?:[^/\\]|\\.)*/)`;
+    SED_PRINT_COMMAND = new RegExp(String.raw`^(?:${SED_ADDRESS}(?:,${SED_ADDRESS})?)?\s*!?\s*[p=]$`);
+    SED_SHORT_OPTIONS = /^-[a-zA-Z]+$/;
+    SED_UNSAFE_SHORT_OPTION = /[iIf]/;
+    OUTPUT_REDIRECTION = /(?:&>>?|\d*>>?\|?)\s*(&?[^\s;|&()]*)/g;
+    HARMLESS_TARGET = /^(?:&\d+|\/dev\/null)$/;
+    PROCESS_SUBSTITUTION = /[<>]\(/;
+    READERS = {
+      grep: ALWAYS_READS,
+      egrep: ALWAYS_READS,
+      fgrep: ALWAYS_READS,
+      ag: ALWAYS_READS,
+      ack: ALWAYS_READS,
+      cat: ALWAYS_READS,
+      bat: ALWAYS_READS,
+      less: ALWAYS_READS,
+      more: ALWAYS_READS,
+      head: ALWAYS_READS,
+      tail: ALWAYS_READS,
+      ls: ALWAYS_READS,
+      wc: ALWAYS_READS,
+      // `--pre` runs a command on every file
+      rg: (args) => hasNoOption(args, ["--pre"]),
+      ripgrep: (args) => hasNoOption(args, ["--pre"]),
+      find: (args) => !args.some((arg) => FIND_UNSAFE_ACTION.test(arg)),
+      sed: sedOnlyPrints,
+      python: (args) => runsInlineCode(args, ["-c", "-"]),
+      python3: (args) => runsInlineCode(args, ["-c", "-"]),
+      node: (args) => runsInlineCode(args, ["-e", "--eval"])
+    };
+    PIPE_FILTERS = {
+      sort: (args) => hasNoOption(args, ["-o", "--output"]) && !args.some((arg) => /^-[a-zA-Z]*o/.test(arg)),
+      // `uniq in out` writes to `out`
+      uniq: (args) => args.filter((arg) => !arg.startsWith("-")).length <= 1,
+      cut: ALWAYS_READS,
+      tr: ALWAYS_READS,
+      jq: ALWAYS_READS
+    };
+  }
+});
+
+// src/normalize/compound.ts
+function rankOf(category) {
+  const index = STEP_CATEGORY_PRIORITY.indexOf(category);
+  if (index !== -1) return index;
+  if (category === UNCLASSIFIED.category) return UNCLASSIFIED_RANK;
+  if (category === READ_ONLY_CATEGORY) return READ_ONLY_RANK;
+  if (DEFAULT_EXCLUDED_CATEGORIES.has(category)) return EXCLUDED_CATEGORY_RANK;
+  return OTHER_CATEGORY_RANK;
+}
+function primaryStepEvent(stepEvents) {
+  return stepEvents.reduce((best, event) => rankOf(event.category) < rankOf(best.category) ? event : best);
+}
+function classifyCompound(command, matchCommand) {
+  const workSteps = commandSteps(command).filter((step2) => !isGlueStep(step2));
+  const wholeCommandEvent = {
+    ...matchCommand(command, command),
+    matchedStep: workSteps.length === 1 ? workSteps[0] : command
+  };
+  const isRecognisedSingleCommand = workSteps.length <= 1 && wholeCommandEvent.category !== UNCLASSIFIED.category;
+  if (isRecognisedSingleCommand || workSteps.length === 0) return wholeCommandEvent;
+  const stepEvents = workSteps.map((step2) => ({ ...matchCommand(simpleCommandOf(step2), step2), matchedStep: step2 }));
+  const primaryEvent = primaryStepEvent(stepEvents);
+  if (primaryEvent.category !== UNCLASSIFIED.category) return primaryEvent;
+  const isAnyStepRecognised = stepEvents.some((event) => event.category !== UNCLASSIFIED.category);
+  return isAnyStepRecognised ? { ...UNCLASSIFIED, matchedStep: command } : wholeCommandEvent;
+}
+var UNCLASSIFIED, STEP_CATEGORY_PRIORITY, OTHER_CATEGORY_RANK, EXCLUDED_CATEGORY_RANK, UNCLASSIFIED_RANK, READ_ONLY_RANK;
+var init_compound = __esm({
+  "src/normalize/compound.ts"() {
+    "use strict";
+    init_command_steps();
+    init_exclusions();
+    init_read_only();
+    UNCLASSIFIED = { category: "other", metadata: {} };
+    STEP_CATEGORY_PRIORITY = [
+      "testing",
+      "building",
+      "releasing",
+      "shipping",
+      "dependencies",
+      "database",
+      "infrastructure",
+      "running",
+      "files",
+      "versioning"
+    ];
+    OTHER_CATEGORY_RANK = STEP_CATEGORY_PRIORITY.length;
+    EXCLUDED_CATEGORY_RANK = OTHER_CATEGORY_RANK + 1;
+    UNCLASSIFIED_RANK = EXCLUDED_CATEGORY_RANK + 1;
+    READ_ONLY_RANK = UNCLASSIFIED_RANK + 1;
+  }
+});
+
 // src/normalize/commit-message.ts
 function firstLineOf(text) {
   const line = text?.split("\n").map((part) => part.trim()).find((part) => part !== "");
@@ -1435,7 +1583,7 @@ function matchRules(command, context) {
 function normalizeCommand(command) {
   return classifyCompound(command, (simple, raw) => matchRules(simple, { raw, original: command }));
 }
-var NX_TARGET_CATEGORIES, NX_COMMAND, nxRule, BASE_RULES, activeRules;
+var NX_TARGET_CATEGORIES, NX_COMMAND, nxRule, readOnlyRule, BASE_RULES, activeRules;
 var init_patterns = __esm({
   "src/normalize/patterns.ts"() {
     "use strict";
@@ -1446,6 +1594,7 @@ var init_patterns = __esm({
     init_commit_message();
     init_dependency_metadata();
     init_git_invocation();
+    init_read_only();
     NX_TARGET_CATEGORIES = {
       build: "building",
       test: "testing",
@@ -1463,7 +1612,13 @@ var init_patterns = __esm({
         return category ? { category, metadata: { tool: "nx", target } } : null;
       }
     };
+    readOnlyRule = {
+      match(_cmd, { raw }) {
+        return isReadOnlyCommand(raw) ? { category: READ_ONLY_CATEGORY, metadata: readOnlyMetadata(raw) } : null;
+      }
+    };
     BASE_RULES = [
+      readOnlyRule,
       // ─── Git operations ───────────────────────────────────────────────────────
       makeRule(/^git\s+commit\b/, "shipping", (_m, _cmd, { raw, original }) => {
         const commitMessage = commitMessageOf(raw, original);
@@ -1648,13 +1803,6 @@ var init_patterns = __esm({
         tool: "bun",
         script: cmd.split(/\s+/)[2]
       })),
-      // ─── Code search ─────────────────────────────────────────────────────────
-      makeRule(/^(grep|egrep|fgrep)\b/, "exploring", (match) => ({ tool: match[1] })),
-      makeRule(/^(rg|ag|ack|ripgrep)\b/, "exploring", (match) => ({ tool: match[1] })),
-      makeRule(/^find\s/, "exploring", () => ({ tool: "find" })),
-      // ─── Code read ────────────────────────────────────────────────────────────
-      makeRule(/^(cat|bat|less|more)\s+\S+/, "exploring", (match) => ({ tool: match[1] })),
-      makeRule(/^(head|tail)\b/, "exploring", (match) => ({ tool: match[1] })),
       // ─── File operations ──────────────────────────────────────────────────────
       makeRule(/^(cp|rsync)\b/, "files", (match) => ({ tool: match[1] })),
       makeRule(/^(mv)\b/, "files", () => ({ tool: "mv" })),
@@ -2635,6 +2783,29 @@ var init_db = __esm({
 });
 
 // src/capture/redact.ts
+function sameCommand(maxParts) {
+  const quoted = String.raw`"[^"]{0,${MAX_QUOTED_LENGTH}}"|'[^']{0,${MAX_QUOTED_LENGTH}}'`;
+  return String.raw`(?:(?:${quoted}|\\\n|[^|;&\n"']){0,${maxParts}}?|[^|;&\n]{0,${maxParts}}?)`;
+}
+function valueAfter(prefix, flags = "g") {
+  return new RegExp(`(?<=${prefix})${VALUE}`, flags);
+}
+function toolFlagValue(tools, flag) {
+  return valueAfter(String.raw`${TOOL_WORD_START}(?:${tools})${TOOL_WORD_END}${SAME_COMMAND}\s${flag}`);
+}
+function quotedValuesAfterName(prefix, name, flags = "g") {
+  return [
+    new RegExp(String.raw`(?<=${prefix}"${name})[^"\s][^"\n]*`, flags),
+    new RegExp(String.raw`(?<=${prefix}'${name})[^'\s][^'\n]*`, flags)
+  ];
+}
+function valuesAfterName(prefix, name, flags = "g") {
+  return [
+    ...quotedValuesAfterName(prefix, name, flags),
+    new RegExp(String.raw`(?<=${prefix}${name})(?:${QUOTED})`, flags),
+    new RegExp(String.raw`(?<=${prefix}${name})[^\s"'|;&]+`, flags)
+  ];
+}
 function redact(command, extraPatterns = []) {
   let result = command;
   const allPatterns = [...BUILTIN_PATTERNS];
@@ -2646,22 +2817,73 @@ function redact(command, extraPatterns = []) {
   }
   for (const pattern of allPatterns) {
     pattern.lastIndex = 0;
-    result = result.replace(pattern, "[REDACTED]");
+    result = result.replace(pattern, REDACTED_TEXT);
   }
   return result;
 }
-var BUILTIN_PATTERNS;
+var QUOTED, WORD_REST, VALUE, VALUE_OR_DASHED, MAX_COMMAND_PARTS, MAX_QUOTED_LENGTH, MAX_PARTS_BEFORE_LOGIN, MAX_PARTS_AFTER_LOGIN, SAME_COMMAND, NOT_PART_OF_A_WORD, NOT_A_NAME, NOT_IN_A_MESSAGE, TOOL_WORD_START, TOOL_WORD_END, NOT_A_PORT_MAPPING, LONG_SECRET_FLAGS, LONG_FLAG_VALUE_START, MAX_SORT_FIELD_DIGITS, SORT_FIELD, NOT_A_KEY, MAX_SLUG_WORD_LENGTH, MAX_SLUG_WORDS_AFTER_FIRST, SLUG_WORD, UUID_IN_A_KEY, SLUG_AFTER_SK, CONTAINER_LOGIN_TOOLS, EVERYDAY_HEADERS, DISTINCTIVE_HEADERS, HEADER_FLAG, SENSITIVE_VARIABLE_WORDS, QUERY_SECRET_NAME, JSON_SECRET_NAME, BUILTIN_PATTERNS, REDACTED_TEXT;
 var init_redact = __esm({
   "src/capture/redact.ts"() {
     "use strict";
+    QUOTED = String.raw`"[^"]*"|'[^']*'`;
+    WORD_REST = String.raw`(?:[^\s"');&|]|["');&|](?=[^\s;&|)]))*`;
+    VALUE = String.raw`(?:${QUOTED}|[^\s"'\-]${WORD_REST})`;
+    VALUE_OR_DASHED = String.raw`(?:${QUOTED}|[^\s"']${WORD_REST})`;
+    MAX_COMMAND_PARTS = 1e3;
+    MAX_QUOTED_LENGTH = 64e3;
+    MAX_PARTS_BEFORE_LOGIN = 200;
+    MAX_PARTS_AFTER_LOGIN = 300;
+    SAME_COMMAND = sameCommand(MAX_COMMAND_PARTS);
+    NOT_PART_OF_A_WORD = String.raw`(?<![\w.:@-])`;
+    NOT_A_NAME = String.raw`(?<!--name(?:\s+|=)|\bssh\s+)`;
+    NOT_IN_A_MESSAGE = String.raw`(?<!\s(?:-[as]*m|--message|--title|--body|--subject)[\s=]*["'][^"'\n]{0,${MAX_COMMAND_PARTS}})`;
+    TOOL_WORD_START = `${NOT_IN_A_MESSAGE}${NOT_A_NAME}${NOT_PART_OF_A_WORD}`;
+    TOOL_WORD_END = String.raw`(?:\.exe)?["'\x60)]?(?=\s)`;
+    NOT_A_PORT_MAPPING = String.raw`(?!(?:[\d.]+:)?\d+:\d+(?:\/\w+)?(?=\s|$))`;
+    LONG_SECRET_FLAGS = [
+      "password",
+      "(?!no-)[\\w-]*-password",
+      "passwd",
+      "passphrase",
+      "pass",
+      "pwd",
+      "secret(?:-key)?",
+      "client[-_]secret",
+      "token",
+      "access-token",
+      "refresh-token",
+      "auth[-_]?token",
+      "private-key",
+      "api[-_]?key"
+    ].join("|");
+    LONG_FLAG_VALUE_START = String.raw`(?:=|\s+(?!--))`;
+    MAX_SORT_FIELD_DIGITS = 2;
+    SORT_FIELD = String.raw`\d{1,${MAX_SORT_FIELD_DIGITS}}`;
+    NOT_A_KEY = String.raw`(?:${SORT_FIELD}(?:[.,]${SORT_FIELD})*|[\w./~-]*\.(?:key|pem|crt|p12|pfx|der)|[\w./~-]*\/id_\w+)(?=\s|$)`;
+    MAX_SLUG_WORD_LENGTH = 15;
+    MAX_SLUG_WORDS_AFTER_FIRST = 8;
+    SLUG_WORD = `[a-z0-9]{1,${MAX_SLUG_WORD_LENGTH}}`;
+    UUID_IN_A_KEY = String.raw`[a-z-]{0,20}[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}`;
+    SLUG_AFTER_SK = String.raw`(?!${UUID_IN_A_KEY})${SLUG_WORD}(?:-${SLUG_WORD}){0,${MAX_SLUG_WORDS_AFTER_FIRST}}(?![\w-])`;
+    CONTAINER_LOGIN_TOOLS = "docker|podman|podman-remote|nerdctl|helm";
+    EVERYDAY_HEADERS = "api-key|cookie|set-cookie";
+    DISTINCTIVE_HEADERS = "x-api-key|x-auth-token|x-access-token";
+    HEADER_FLAG = String.raw`(?<![\w-])(?:-\w*H|--(?:proxy-)?header)[\s=]*`;
+    SENSITIVE_VARIABLE_WORDS = "TOKEN|SECRET|KEY|PASSWORD|PASS|AUTH|CREDENTIAL|_PWD";
+    QUERY_SECRET_NAME = String.raw`key|[\w-]*(?:token|secret|password|passwd|pwd|api[-_]?key)`;
+    JSON_SECRET_NAME = String.raw`[\w-]*(?:token|secret|password|passwd|pwd|api[-_]?key)`;
     BUILTIN_PATTERNS = [
       // AWS access keys
       /AKIA[0-9A-Z]{16}/g,
       // AWS secret access keys (40 char base64-ish after common env vars)
-      /(?<=AWS_SECRET_ACCESS_KEY[=\s]+)\S+/gi,
+      new RegExp(String.raw`(?<=AWS_SECRET_ACCESS_KEY[=\s]+)${VALUE_OR_DASHED}`, "gi"),
       // GitHub tokens
-      /ghp_[a-zA-Z0-9]{36}/g,
+      /\bgh[pousr]_[a-zA-Z0-9]{36}/g,
       /github_pat_[a-zA-Z0-9_]{82}/g,
+      // AI provider, Google and npm keys
+      new RegExp(String.raw`\bsk-(?!${SLUG_AFTER_SK})[\w-]{20,}`, "g"),
+      /\bAIza[a-zA-Z0-9_-]{30,}/g,
+      /\bnpm_[a-zA-Z0-9]{30,}/g,
       // GitLab tokens
       /glpat-[a-zA-Z0-9\-]{20}/g,
       // Generic JWTs (three base64url segments)
@@ -2671,17 +2893,85 @@ var init_redact = __esm({
       /https:\/\/hooks\.slack\.com\/services\/[A-Z0-9]+\/[A-Z0-9]+\/[a-zA-Z0-9]+/g,
       // Stripe keys
       /sk_(live|test)_[a-zA-Z0-9]{24,}/g,
-      // Values after long-form secret flags (single-char flags like -t/-p/-k are too ambiguous)
-      /(?<=--(password|passwd|secret|token|key|api[-_]?key|auth[-_]?token)\s+)\S+/gi,
+      // Values after long-form secret flags, `--flag value` or `--flag=value`. `--password-stdin` isn't one: no match on its
+      // `-stdin`. A bare short flag means nothing without knowing the tool: see below
+      new RegExp(String.raw`(?<=(?<![\w-])--(?:${LONG_SECRET_FLAGS})${LONG_FLAG_VALUE_START})${VALUE_OR_DASHED}`, "gi"),
+      new RegExp(String.raw`(?<=(?<![\w-])--key${LONG_FLAG_VALUE_START})(?!${NOT_A_KEY})${VALUE_OR_DASHED}`, "gi"),
+      // A password attached to the flag: `mysql -pSECRET`. `mysql -p db` prompts, so there's no value to remove, and
+      // `psql -p 5432` is a port, so psql isn't listed
+      toolFlagValue(
+        "mysql|mysqldump|mysqladmin|mysqlimport|mysqlshow|mysqlcheck|mariadb|mariadb-dump|mariadb-admin|mariadb-import|mariadb-show|mariadb-check",
+        "-p"
+      ),
+      // Short flags that take a secret, for the tools where they do
+      toolFlagValue("sshpass", String.raw`-p\s*`),
+      toolFlagValue("mongosh|mongo|mongodump|mongorestore|mongoexport|mongoimport", String.raw`-p\s*${NOT_A_PORT_MAPPING}`),
+      toolFlagValue("redis-cli", String.raw`-a\s*`),
+      toolFlagValue("ssh-keygen", String.raw`-[NP]\s*`),
+      toolFlagValue("zip|unzip", String.raw`-P\s*`),
+      valueAfter(
+        String.raw`${TOOL_WORD_START}(?:${CONTAINER_LOGIN_TOOLS})${TOOL_WORD_END}[^|;&\n]{0,${MAX_PARTS_BEFORE_LOGIN}}?\slogin` + String.raw`${TOOL_WORD_END}${sameCommand(MAX_PARTS_AFTER_LOGIN)}\s-p\s*${NOT_A_PORT_MAPPING}`
+      ),
+      // openssl's `-pass pass:SECRET`, also -passin and -passout
+      /(?<=\s-pass(?:in|out|word)?\s+pass:)\S+/g,
+      // curl's cookies, which also covers a cookie file's name: `curl -b s=SECRET`
+      valueAfter(String.raw`\bcurl\b["']?${SAME_COMMAND}\s(?:--cookie|-\w*b)[\s=]+`),
+      // The password half of `curl -u user:password`
+      ...valuesAfterName(String.raw`\bcurl\b["']?${SAME_COMMAND}\s(?:-\w*u[\s=]*|--user[\s=]+)`, String.raw`[^:\s"']*:`),
+      // Tokens handed over on stdin: `echo SECRET | docker login --password-stdin`, `gh auth login --with-token <<< SECRET`
+      new RegExp(
+        String.raw`(?<=\b(?:echo(?:\s+-[neE]+)*|printf(?:\s+["']?%s(?:\\n)?["']?)?)\s+)${VALUE}` + String.raw`(?=\s*\|[^;&\n]{0,${MAX_COMMAND_PARTS}}?--(?:password-stdin|with-token))`,
+        "g"
+      ),
+      valueAfter(String.raw`--(?:password-stdin|with-token)\s*<<<\s*`),
+      // Headers. A scheme or a header flag is required for Authorization, so prose like "Authorization: added middleware"
+      // stays. An everyday word needs to look like a header, so `git commit -m "cookie: rotate on login"` stays: a header
+      // flag, `Cookie:value` with no space, or a quoted `"Cookie: value"` outside a message
+      /(?<=\bauthorization:\s*(?:bearer|basic|token)\s+)[^\s"']+/gi,
+      /(?<=\bbearer\s+)(?=[A-Za-z0-9._~+/=-]*\d)[A-Za-z0-9._~+/=-]{8,}/gi,
+      ...valuesAfterName(HEADER_FLAG, String.raw`(?:${EVERYDAY_HEADERS}):\s*`, "gi"),
+      ...valuesAfterName(HEADER_FLAG, String.raw`authorization:\s*(?!(?:bearer|basic|token)\s)`, "gi"),
+      ...quotedValuesAfterName("", String.raw`${NOT_IN_A_MESSAGE}(?:${EVERYDAY_HEADERS}):\s*`, "gi"),
+      ...valuesAfterName("", String.raw`(?<![\w-])(?:${EVERYDAY_HEADERS}):`, "gi"),
+      ...valuesAfterName("", String.raw`\b(?:${DISTINCTIVE_HEADERS}):\s*`, "gi"),
+      // Private keys, whole blocks, as heredocs and `echo` can carry them
+      /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+      // password=... inside a string or query: `psql "host=x password=SECRET"`, `--set db.password=SECRET`
+      /(?<=(?:^|[\s"'?&=.])(?:password|passwd|pwd)=)[^\s"';&]+/gi,
+      // A secret in a query string or in JSON: `curl "x.io?token=SECRET"`, `curl -d '{"password":"SECRET"}'`
+      new RegExp(String.raw`(?<=[?&](?:${QUERY_SECRET_NAME})=)[^\s"'&#]+`, "gi"),
+      new RegExp(String.raw`(?<=["'](?:${JSON_SECRET_NAME})\\?["']\s*:\s*\\?")[^"\\\n]+`, "gi"),
+      // npm's auth settings, with or without `=`: `npm config set //registry/:_password SECRET`
+      /(?<=:_(?:password|auth|authToken)[=\s]+)\S+/g,
       // export VAR=VALUE where VAR looks sensitive
-      /(?<=export\s+(?:[A-Z_]*(?:TOKEN|SECRET|KEY|PASSWORD|PASS|AUTH|CREDENTIAL)[A-Z_]*)=)\S+/gi,
+      new RegExp(String.raw`(?<=export\s+(?:[A-Z_]*(?:${SENSITIVE_VARIABLE_WORDS})[A-Z_]*)=)${VALUE_OR_DASHED}`, "gi"),
       // Inline assignment: VAR_WITH_SENSITIVE_KEYWORD=value cmd  (e.g. API_KEY=secret npm start)
       // Lookbehind matches only the variable-name= prefix, so only the value is replaced
-      /(?<=[A-Z_][A-Z0-9_]*(?:TOKEN|SECRET|KEY|PASSWORD|PASS|AUTH|CREDENTIAL)[A-Z0-9_]*=)\S+/gi,
+      new RegExp(String.raw`(?<=[A-Z_][A-Z0-9_]*(?:${SENSITIVE_VARIABLE_WORDS})[A-Z0-9_]*=)${VALUE_OR_DASHED}`, "gi"),
+      // The same with nothing before the keyword: `TOKEN=SECRET npm start`. Capitals only, so `--author=me` and `key=value` stay
+      new RegExp(
+        String.raw`(?<=(?:^|[\s;&|(])(?:TOKEN|SECRET|KEY|PASSWORD|PASS|AUTH|CREDENTIALS?)=)${VALUE_OR_DASHED}`,
+        "g"
+      ),
       // Credentials embedded in connection string URLs (e.g. DATABASE_URL=postgres://user:pass@host/db)
       // Matches the password segment between :// user : password @ — preserves scheme and host
-      /(?<=[a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^:@\s/]+:)[^@\s]+(?=@)/g
+      /(?<=[a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^:@\s/]*:)[^@\s]+(?=@)/g,
+      // A token as the whole userinfo of an https URL: `git clone https://TOKEN@github.com/org/repo`
+      /(?<=https?:\/\/)[^\s:@/?#]+(?=@)/g
     ];
+    REDACTED_TEXT = "[REDACTED]";
+  }
+});
+
+// src/capture/hint.ts
+function commandHint(safeCommand) {
+  return safeCommand.trim().slice(0, HINT_LENGTH);
+}
+var HINT_LENGTH;
+var init_hint = __esm({
+  "src/capture/hint.ts"() {
+    "use strict";
+    HINT_LENGTH = 120;
   }
 });
 
@@ -2853,13 +3143,13 @@ var init_git_snapshot = __esm({
 });
 
 // src/capture/aider.ts
-function readLastAiderPrompt(cwd) {
+function readLastAiderPrompt(cwd, extraRedactions = []) {
   try {
     const histPath = import_path8.default.join(cwd, HISTORY_FILE);
     const content = import_fs10.default.readFileSync(histPath, "utf-8");
     const matches = [...content.matchAll(/^#### (.+)$/gm)];
     if (!matches.length) return null;
-    return matches[matches.length - 1][1].trim().slice(0, PROMPT_MAX_LENGTH);
+    return redact(matches[matches.length - 1][1].trim(), extraRedactions).slice(0, PROMPT_MAX_LENGTH);
   } catch {
     return null;
   }
@@ -2870,6 +3160,7 @@ var init_aider = __esm({
     "use strict";
     import_fs10 = __toESM(require("fs"));
     import_path8 = __toESM(require("path"));
+    init_redact();
     HISTORY_FILE = ".aider.chat.history.md";
     PROMPT_MAX_LENGTH = 200;
   }
@@ -2878,7 +3169,7 @@ var init_aider = __esm({
 // src/capture/workscribe-command.ts
 function isWorkscribeStep(step2) {
   if (containsCommandSubstitution(step2)) return false;
-  const stages = splitOutsideQuotes(step2, PIPE_SEPARATORS2);
+  const stages = splitOutsideQuotes(step2, PIPE_SEPARATORS3);
   if (startsWithWord(stages[0] ?? "", "workscribe")) return true;
   const isTextOrWorkscribe = (stage) => startsWithWord(stage, "workscribe") || TEXT_SOURCES.some((source) => startsWithWord(stage, source));
   return stages.every(isTextOrWorkscribe) && stages.some((stage) => startsWithWord(stage, "workscribe"));
@@ -2888,13 +3179,13 @@ function isWorkscribeOnlyCommand(rawCommand) {
   const workSteps = steps.filter((step2) => !isGlueStep(step2));
   return workSteps.length > 0 && workSteps.every(isWorkscribeStep);
 }
-var PIPE_SEPARATORS2;
+var PIPE_SEPARATORS3;
 var init_workscribe_command = __esm({
   "src/capture/workscribe-command.ts"() {
     "use strict";
     init_shell_syntax();
     init_command_steps();
-    PIPE_SEPARATORS2 = ["|"];
+    PIPE_SEPARATORS3 = ["|"];
   }
 });
 
@@ -3115,7 +3406,7 @@ function captureCommand(opts) {
         if (Date.now() - lastTime < TASK_RUN_DEDUP_WINDOW_MS) return;
       }
     }
-    const command2 = opts.command ?? opts.file ?? opts.type;
+    const command2 = opts.command === void 0 ? opts.file ?? opts.type : redact(opts.command, config.redact.extra);
     const context2 = getRepoContext(cwd, config);
     const { repoName: repoName2, branch: branch2 } = context2;
     const ideEvent = {
@@ -3149,17 +3440,17 @@ function captureCommand(opts) {
   if (category === "other") {
     const firstToken = safeCommand.trim().split(/\s+/)[0];
     if (firstToken) metadata.tool = firstToken;
-    metadata.hint = safeCommand.trim().slice(0, 120);
+    metadata.hint = commandHint(safeCommand);
   }
   if (category === "ai_session") {
     if (opts.gitBefore) {
       const commits = getCommitsSince(opts.gitBefore, workDirectory);
-      if (commits.length > 0) metadata.commits = commits;
+      if (commits.length > 0) metadata.commits = commits.map((subject) => redact(subject, config.redact.extra));
     }
     if (config.capture.includeAiderPrompt !== false) {
       const toolEntry = loadAIToolRegistry().find((entry) => entry.tool === metadata.tool);
       if (toolEntry?.contextSource === "history-file") {
-        const prompt = readLastAiderPrompt(cwd);
+        const prompt = readLastAiderPrompt(cwd, config.redact.extra);
         if (prompt) metadata.prompt = prompt;
       }
     }
@@ -3192,6 +3483,7 @@ var init_capture = __esm({
     import_fs14 = __toESM(require("fs"));
     init_db();
     init_redact();
+    init_hint();
     init_git();
     init_git_snapshot();
     init_aider();
@@ -4373,10 +4665,10 @@ function installIntoFolder(options) {
     const outcome = installSkill({
       sourceDir: options.sourceDir,
       skillsFolder: target.skillsFolder,
-      version: "3.0.1",
+      version: "3.2.0",
       force: options.force
     });
-    return describeInstallOutcome({ ...target, outcome, version: "3.0.1" });
+    return describeInstallOutcome({ ...target, outcome, version: "3.2.0" });
   } catch (error) {
     return describeInstallFailure({ ...target, error });
   }
@@ -4395,8 +4687,8 @@ function removeSkills(agents, options) {
 }
 function formatAgentSkillLine(agent, homeDir = import_os6.default.homedir()) {
   const location = displayPath(import_path19.default.join(homeDir, agent.skillsFolder, SKILL_NAME), homeDir);
-  const installState = readInstallState(import_path19.default.join(homeDir, agent.skillsFolder), "3.0.1");
-  const status = describeSkillStatus(installState, "3.0.1");
+  const installState = readInstallState(import_path19.default.join(homeDir, agent.skillsFolder), "3.2.0");
+  const status = describeSkillStatus(installState, "3.2.0");
   return `${agent.name.padEnd(AGENT_NAME_COLUMN_WIDTH)} ${STATUS_COLOURS[status.level](status.text)}  ${import_chalk2.default.dim(location)}`;
 }
 function formatUndetectedAgentLine(agent) {
@@ -4688,10 +4980,10 @@ async function runAIToolsStep() {
 }
 async function offerSkillInstall(group, sourceDir) {
   const target = describeTarget(group);
-  const state = readInstallState(target.skillsFolder, "3.0.1");
+  const state = readInstallState(target.skillsFolder, "3.2.0");
   const knownOutcome = outcomeWithoutPrompt(state);
   if (knownOutcome) {
-    printMessage(describeInstallOutcome({ ...target, outcome: knownOutcome, version: "3.0.1" }));
+    printMessage(describeInstallOutcome({ ...target, outcome: knownOutcome, version: "3.2.0" }));
     return;
   }
   const { installSkill: shouldInstall } = await (0, import_prompts2.default)({
@@ -5668,6 +5960,184 @@ var init_ticket_refs = __esm({
   }
 });
 
+// src/db/jobs/scrub-secrets.ts
+function scrubValue(value, command) {
+  if (command.after.includes(value)) return value;
+  const redacted = redact(value);
+  if (redacted !== value) return redacted;
+  return command.before.includes(value) ? REDACTED_TEXT : value;
+}
+function scrubStrings(value, command) {
+  if (typeof value === "string") return scrubValue(value, command);
+  if (Array.isArray(value)) return value.map((item) => scrubStrings(item, command));
+  if (value === null || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, scrubStrings(item, command)]));
+}
+function hasHint(value) {
+  return typeof value?.hint === "string";
+}
+function scrubMetadata(metadata, command) {
+  if (metadata === null) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(metadata);
+  } catch {
+    return redact(metadata);
+  }
+  const scrubbed = scrubStrings(parsed, command);
+  if (command.after !== command.before && hasHint(scrubbed)) scrubbed.hint = commandHint(command.after);
+  const rewritten = JSON.stringify(scrubbed);
+  return rewritten === JSON.stringify(parsed) ? metadata : rewritten;
+}
+function scrubEvent({ command, metadata }) {
+  const scrubbedCommand = redact(command);
+  const scrubbedMetadata = scrubMetadata(metadata, { before: command, after: scrubbedCommand });
+  if (scrubbedCommand === command && scrubbedMetadata === metadata) return null;
+  return { command: scrubbedCommand, metadata: scrubbedMetadata };
+}
+function readEvents(db, afterId, limit) {
+  return db.prepare(
+    `SELECT id, command, metadata FROM events
+       WHERE id > ? AND command IS NOT file_path
+       ORDER BY id LIMIT ?`
+  ).all(afterId, limit);
+}
+function runBatch5(db, afterId, limit) {
+  const events = readEvents(db, afterId, limit);
+  if (events.length === 0) return { lastId: null, issues: [] };
+  const update = db.prepare("UPDATE events SET command = ?, metadata = ? WHERE id = ?");
+  for (const event of events) {
+    const scrubbed = scrubEvent(event);
+    if (scrubbed) update.run(scrubbed.command, scrubbed.metadata, event.id);
+  }
+  return { lastId: events[events.length - 1].id, issues: [] };
+}
+function verify4(db) {
+  let checked = 0;
+  let unresolved = 0;
+  let afterId = 0;
+  for (; ; ) {
+    const events = readEvents(db, afterId, VERIFY_PAGE_SIZE);
+    if (events.length === 0) break;
+    checked += events.length;
+    unresolved += events.filter((event) => scrubEvent(event) !== null).length;
+    afterId = events[events.length - 1].id;
+  }
+  const notes = unresolved > 0 ? [`events that would still change: ${unresolved}`] : [];
+  return { checked, resolved: checked - unresolved, unresolved, hasPassed: true, notes };
+}
+function cleanUpFile(db) {
+  db.exec(`PRAGMA busy_timeout = ${CLEANUP_LOCK_WAIT_MS}`);
+  try {
+    if (getMetaValue(db, CLEANUP_KEY) === CLEANUP_NEEDS_VACUUM) {
+      db.exec("VACUUM");
+      setMetaValue(db, CLEANUP_KEY, CLEANUP_NEEDS_CHECKPOINT);
+    }
+    const result = db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+    if (result?.busy) {
+      debugLog(`data job ${JOB_NAME}: file cleanup`, "left for later, a reader is busy");
+      return;
+    }
+    deleteMetaValue(db, CLEANUP_KEY);
+  } finally {
+    db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
+  }
+}
+var JOB_NAME, VERIFY_PAGE_SIZE, CLEANUP_KEY, CLEANUP_NEEDS_VACUUM, CLEANUP_NEEDS_CHECKPOINT, CLEANUP_LOCK_WAIT_MS, scrubSecretsJob;
+var init_scrub_secrets = __esm({
+  "src/db/jobs/scrub-secrets.ts"() {
+    "use strict";
+    init_transaction();
+    init_store2();
+    init_hint();
+    init_redact();
+    init_logger();
+    JOB_NAME = "scrub-secrets";
+    VERIFY_PAGE_SIZE = 500;
+    CLEANUP_KEY = "scrub-secrets:file-cleanup";
+    CLEANUP_NEEDS_VACUUM = "vacuum";
+    CLEANUP_NEEDS_CHECKPOINT = "checkpoint";
+    CLEANUP_LOCK_WAIT_MS = 200;
+    scrubSecretsJob = {
+      name: JOB_NAME,
+      version: 1,
+      description: "Remove secrets from stored commands and metadata",
+      // Redacting what's already redacted changes nothing, so a rerun only needs the file cleaned again
+      prepare: (db) => setMetaValue(db, CLEANUP_KEY, CLEANUP_NEEDS_VACUUM),
+      runBatch: runBatch5,
+      verify: verify4,
+      cleanup: { isPending: (db) => getMetaValue(db, CLEANUP_KEY) !== null, run: cleanUpFile }
+    };
+  }
+});
+
+// src/db/jobs/read-only-commands.ts
+function parsedObject(metadata) {
+  try {
+    const parsed = JSON.parse(metadata);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function movedMetadata({ command, metadata }) {
+  if (metadata === null) return JSON.stringify(readOnlyMetadata(command));
+  const parsed = parsedObject(metadata);
+  if (parsed === null) return metadata;
+  const { hint: _hint, tool: _tool, ...kept } = parsed;
+  return JSON.stringify({ ...kept, ...readOnlyMetadata(command) });
+}
+function readCandidates(db, afterId, limit) {
+  return db.prepare(
+    `SELECT id, command, metadata FROM events
+       WHERE id > ? AND category IN (${CATEGORY_PLACEHOLDERS})
+       ORDER BY id LIMIT ?`
+  ).all(afterId, ...MOVABLE_CATEGORIES, limit);
+}
+function runBatch6(db, afterId, limit) {
+  const events = readCandidates(db, afterId, limit);
+  if (events.length === 0) return { lastId: null, issues: [] };
+  const update = db.prepare("UPDATE events SET category = ?, metadata = ? WHERE id = ?");
+  for (const event of events) {
+    if (isReadOnlyCommand(event.command)) update.run(READ_ONLY_CATEGORY, movedMetadata(event), event.id);
+  }
+  return { lastId: events[events.length - 1].id, issues: [] };
+}
+function verify5(db) {
+  let checked = 0;
+  let unresolved = 0;
+  let afterId = 0;
+  for (; ; ) {
+    const events = readCandidates(db, afterId, VERIFY_PAGE_SIZE2);
+    if (events.length === 0) break;
+    checked += events.length;
+    unresolved += events.filter((event) => isReadOnlyCommand(event.command)).length;
+    afterId = events[events.length - 1].id;
+  }
+  const notes = unresolved > 0 ? [`read-only events not moved: ${unresolved}`] : [];
+  return { checked, resolved: checked - unresolved, unresolved, hasPassed: true, notes };
+}
+var JOB_NAME2, VERIFY_PAGE_SIZE2, MOVABLE_CATEGORIES, CATEGORY_PLACEHOLDERS, readOnlyCommandsJob;
+var init_read_only_commands = __esm({
+  "src/db/jobs/read-only-commands.ts"() {
+    "use strict";
+    init_read_only();
+    JOB_NAME2 = "read-only-commands";
+    VERIFY_PAGE_SIZE2 = 500;
+    MOVABLE_CATEGORIES = ["versioning", "other", "files", "running"];
+    CATEGORY_PLACEHOLDERS = MOVABLE_CATEGORIES.map(() => "?").join(", ");
+    readOnlyCommandsJob = {
+      name: JOB_NAME2,
+      version: 1,
+      description: "Move stored read-only commands out of summaries",
+      // Moved rows are simply not candidates any more, so a rerun has nothing to clear first
+      prepare: () => void 0,
+      runBatch: runBatch6,
+      verify: verify5
+    };
+  }
+});
+
 // src/db/jobs/index.ts
 var JOBS;
 var init_jobs = __esm({
@@ -5678,10 +6148,14 @@ var init_jobs = __esm({
     init_summary_anchors();
     init_drop_old_sessions();
     init_ticket_refs();
+    init_scrub_secrets();
+    init_read_only_commands();
     JOBS = [
       createProjectDimensionsJob({ probeDirectory }),
       summaryAnchorsJob,
       ticketRefsJob,
+      scrubSecretsJob,
+      readOnlyCommandsJob,
       dropOldSessionsJob
     ];
   }
@@ -5846,9 +6320,22 @@ function recordFailure(db, job, message) {
     debugLog(`data job ${job.name}: couldn't record the failure`, error);
   }
 }
+function runPendingCleanups(db, jobs) {
+  for (const job of jobs) {
+    if (!job.cleanup || !isJobDone(getJobRow(db, job.name), job)) continue;
+    try {
+      if (job.cleanup.isPending(db)) job.cleanup.run(db);
+    } catch (error) {
+      debugLog(`data job ${job.name}: cleanup`, error);
+    }
+  }
+}
 function runPendingJobs(db, jobs, options) {
   const pending = jobs.filter((job) => !isJobDone(getJobRow(db, job.name), job));
-  if (pending.length === 0) return { backup: "not-needed", jobs: [] };
+  if (pending.length === 0) {
+    runPendingCleanups(db, jobs);
+    return { backup: "not-needed", jobs: [] };
+  }
   const backup = options.ensureBackup();
   if (backup !== "ready") return { backup, jobs: [] };
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
@@ -5865,6 +6352,7 @@ function runPendingJobs(db, jobs, options) {
     results.push(result);
     if (result.outcome !== "done") break;
   }
+  runPendingCleanups(db, jobs);
   return { backup: "ready", jobs: results };
 }
 var DEFAULT_BATCH_SIZE, BATCH_LOCK_WAIT_MS, NEWER_VERSION_ERROR, SupersededError;
@@ -6565,6 +7053,7 @@ function eventRowToPayload(row) {
     branch: row.branch,
     capturedAt: row.captured_at,
     ...row.source ? { source: row.source } : {},
+    ...row.agent_session_id == null ? {} : { agentSessionId: row.agent_session_id },
     ...gitMovesField(row)
   };
   if (row.category !== "other" || typeof metadata.hint !== "string") return payload;
@@ -7378,8 +7867,52 @@ var init_sessions = __esm({
   }
 });
 
+// src/ai/engines/template/utils.ts
+function pluralize(count, noun) {
+  return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function stringsIn(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item !== "") : [];
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function eventsOf(events, category) {
+  return events.filter((event) => event.category === category);
+}
+function toBulletList(bullets) {
+  return bullets.map((bullet) => `- ${bullet}`).join("\n");
+}
+var init_utils3 = __esm({
+  "src/ai/engines/template/utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/ai/engines/template/agents.ts
+function joinNames(names) {
+  if (names.length <= 1) return names.join("");
+  return `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+}
+function describeAgents(events) {
+  const agentEvents = events.filter((event) => event.source !== void 0 && AGENT_NAMES.has(event.source));
+  if (agentEvents.length === 0) return null;
+  const names = [...new Set(agentEvents.map((event) => AGENT_NAMES.get(event.source)))];
+  const sessionIds = new Set(agentEvents.flatMap((event) => event.agentSessionId ?? []));
+  return sessionIds.size > 0 ? `${joinNames(names)} (${pluralize(sessionIds.size, "session")})` : joinNames(names);
+}
+var AGENT_NAMES;
+var init_agents2 = __esm({
+  "src/ai/engines/template/agents.ts"() {
+    "use strict";
+    init_ai_tools();
+    init_utils3();
+    AGENT_NAMES = new Map(ai_tools_default.flatMap((tool) => tool.hook ? [[tool.hook, tool.displayName]] : []));
+  }
+});
+
 // src/ai/engines/template/constants.ts
-var MAX_SESSION_BULLETS, MAX_COMMIT_BULLETS, MAX_DAY_BULLETS, MAX_LISTED_PACKAGES, AGENT_SOURCES, TEST_WORDING, BUILD_WORDING, STORY_TEST_WORDING, STORY_BUILD_WORDING;
+var MAX_SESSION_BULLETS, MAX_COMMIT_BULLETS, MAX_DAY_BULLETS, MAX_LISTED_PACKAGES, TEST_WORDING, BUILD_WORDING, STORY_TEST_WORDING, STORY_BUILD_WORDING;
 var init_constants2 = __esm({
   "src/ai/engines/template/constants.ts"() {
     "use strict";
@@ -7387,7 +7920,6 @@ var init_constants2 = __esm({
     MAX_COMMIT_BULLETS = 3;
     MAX_DAY_BULLETS = 5;
     MAX_LISTED_PACKAGES = 6;
-    AGENT_SOURCES = ["claude-code"];
     TEST_WORDING = {
       category: "testing",
       resolved: "Resolved failing tests",
@@ -7416,28 +7948,6 @@ var init_constants2 = __esm({
   }
 });
 
-// src/ai/engines/template/utils.ts
-function pluralize(count, noun) {
-  return `${count} ${noun}${count === 1 ? "" : "s"}`;
-}
-function stringsIn(value) {
-  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item !== "") : [];
-}
-function unique(values) {
-  return [...new Set(values)];
-}
-function eventsOf(events, category) {
-  return events.filter((event) => event.category === category);
-}
-function toBulletList(bullets) {
-  return bullets.map((bullet) => `- ${bullet}`).join("\n");
-}
-var init_utils3 = __esm({
-  "src/ai/engines/template/utils.ts"() {
-    "use strict";
-  }
-});
-
 // src/ai/engines/template/describe.ts
 function describeNotes(events) {
   return eventsOf(events, "note").flatMap((event) => stringsIn([event.metadata.text]).map((text) => `Note: ${text}`));
@@ -7509,8 +8019,8 @@ function describePushes(events) {
   return targets.length > 0 ? `Pushed to ${targets.join(", ")}` : null;
 }
 function describeAgentWork(events) {
-  const agentCommands = events.filter((event) => event.source !== void 0 && AGENT_SOURCES.includes(event.source));
-  return agentCommands.length > 0 ? `Worked with an AI coding assistant (${pluralize(agentCommands.length, "command")})` : null;
+  const agents = describeAgents(events);
+  return agents === null ? null : `Worked with ${agents}`;
 }
 function describeEdits(events) {
   const saves = eventsOf(events, "code_edit").length;
@@ -7542,6 +8052,7 @@ var init_describe = __esm({
     "use strict";
     init_commits();
     init_exclusions();
+    init_agents2();
     init_constants2();
     init_utils3();
   }
@@ -7681,12 +8192,10 @@ function branchBullets(group) {
   ].filter((bullet) => bullet !== null);
 }
 function describeActivityLine(allEvents, events) {
-  const agentCommands = allEvents.filter(
-    (event) => event.source !== void 0 && AGENT_SOURCES.includes(event.source)
-  ).length;
+  const agents = describeAgents(allEvents);
   const saves = eventsOf(events, "code_edit").length;
   const parts = [
-    agentCommands > 0 ? `With an AI coding assistant (${pluralize(agentCommands, "command")})` : null,
+    agents === null ? null : `With ${agents}`,
     saves > 0 ? `${pluralize(saves, "file save")} in the editor` : null
   ].filter((part) => part !== null);
   return parts.length > 0 ? parts.join(" \xB7 ") : null;
@@ -7731,6 +8240,7 @@ var init_story = __esm({
   "src/ai/engines/template/story.ts"() {
     "use strict";
     init_heading();
+    init_agents2();
     init_constants2();
     init_describe();
     init_branch_moves();
@@ -8120,6 +8630,28 @@ var init_day = __esm({
   }
 });
 
+// src/summary/output-format.ts
+function keepsStdoutClean(format) {
+  return format === "json" || format === "text";
+}
+var SUMMARY_FORMATS;
+var init_output_format = __esm({
+  "src/summary/output-format.ts"() {
+    "use strict";
+    SUMMARY_FORMATS = ["markdown", "json", "text"];
+  }
+});
+
+// src/summary/plain-text.ts
+function toPlainText(markdown) {
+  return markdown.replace(/^#{1,6} +/gm, "").replace(/^([ \t]*)[*•] +/gm, "$1- ").replace(/\*\*([^*\n]+)\*\*/g, "$1").replace(/`([^`\n]+)`/g, "$1").replace(/\[([^\]\n]+)\]\(([^)\s]+)\)/g, "$1 ($2)").trim();
+}
+var init_plain_text = __esm({
+  "src/summary/plain-text.ts"() {
+    "use strict";
+  }
+});
+
 // src/cli/day-notes.ts
 function printExcludedFooter(sessionPayloads, excluded) {
   const excludedCounts = countExcludedEvents(sessionPayloads, excluded);
@@ -8195,10 +8727,11 @@ async function runWeeklySummary({ options, config, provider, loadDay }) {
   }
   const payload = { weekStart, weekEnd: today, by: options.by ?? "project", days };
   const summary = await writeWeeklySummary(provider, payload);
-  const isJson = config.summary?.format === "json";
-  if (isJson) log.plain(weekJson(payload, config.summary?.includeCategories ?? []));
+  const format = options.format ?? config.summary?.format;
+  if (format === "json") log.plain(weekJson(payload, config.summary?.includeCategories ?? []));
+  else if (format === "text") log.plain(toPlainText(summary));
   else printSummary(summary);
-  await postSummary({ options, config, summary, statusToStderr: isJson });
+  await postSummary({ options, config, summary, statusToStderr: keepsStdoutClean(format) });
 }
 var WEEK_GIT_BUDGET_MS;
 var init_weekly = __esm({
@@ -8209,6 +8742,8 @@ var init_weekly = __esm({
     init_payload();
     init_webhook2();
     init_day_commits();
+    init_output_format();
+    init_plain_text();
     init_week();
     WEEK_GIT_BUDGET_MS = DAY_GIT_BUDGET_MS;
   }
@@ -8224,14 +8759,24 @@ function parseWeekLayout(value) {
   if (!layout) fail("--by must be project or day");
   return layout;
 }
+function addSummaryFormatOption(command) {
+  return command.option("--format <format>", "print as markdown, json or text, overriding summary.format");
+}
+function parseSummaryFormat(value) {
+  if (value === void 0) return void 0;
+  const format = SUMMARY_FORMATS.find((candidate) => candidate === value);
+  if (!format) fail("--format must be markdown, json or text");
+  return format;
+}
 async function runWeekCommand(options) {
   const by = parseWeekLayout(options.by);
+  const format = parseSummaryFormat(options.format);
   const config = readConfig();
   printLegacyAiNotice(config);
   requireThreadData();
   try {
     await runWeeklySummary({
-      options: { ...options, by },
+      options: { ...options, by, format },
       config,
       provider: createSummaryWriter(config),
       loadDay: loadDayThreads
@@ -8242,13 +8787,14 @@ async function runWeekCommand(options) {
 }
 function registerWeek(program) {
   const weekCommand = program.command("week").description("Summarize the current week (Mon\u2013today) \u2014 the same as summary --week").option("--fresh", "accepted for 1.x scripts \u2014 the week is always rendered fresh").option("--slack", "post to Slack webhook from config").option("--webhook <url>", "post to a custom webhook URL");
-  addWeekLayoutOption(weekCommand).action(runWeekCommand);
+  addSummaryFormatOption(addWeekLayoutOption(weekCommand)).action(runWeekCommand);
 }
 var WEEK_LAYOUTS;
 var init_week2 = __esm({
   "src/cli/week.ts"() {
     "use strict";
     init_config();
+    init_output_format();
     init_weekly();
     init_writer();
     init_notices();
@@ -8293,8 +8839,9 @@ function printCapturedEvents(sessionPayloads, excluded) {
 }
 function registerSummary(program) {
   const summaryCommand = program.command("summary").description("Generate a work summary").option("--date <YYYY-MM-DD>", "date to summarize (default: today)").option("--week", "summarize the current week").option("--fresh", "ignore saved summaries and render the template").option("--verbose", "show all captured events, including those left out of the summary").option("--slack", "post summary to Slack webhook from config").option("--webhook <url>", "post summary to a custom webhook URL");
-  addWeekLayoutOption(summaryCommand).action(async (options) => {
+  addSummaryFormatOption(addWeekLayoutOption(summaryCommand)).action(async (options) => {
     if (options.by !== void 0 && !options.week) fail("--by only applies to --week");
+    const formatOption = parseSummaryFormat(options.format);
     if (options.week) {
       await runWeekCommand(options);
       return;
@@ -8317,7 +8864,8 @@ function registerSummary(program) {
       log.plain(`No activity captured for ${date}`);
       return;
     }
-    const jsonMode = config.summary?.format === "json";
+    const format = formatOption ?? config.summary?.format;
+    const keepsStdoutToOutput = keepsStdoutClean(format);
     let day;
     try {
       day = await renderDay({ date, blocks, config, provider, fresh: options.fresh });
@@ -8328,11 +8876,13 @@ function registerSummary(program) {
     const { sessionPayloads, saved, fullSummary, needsGeneration } = day;
     const excluded = buildExcludedSet(config.summary?.includeCategories ?? []);
     if (needsGeneration && options.verbose) {
-      if (jsonMode) log.notice("--verbose is skipped when summary.format is json, to keep the JSON output clean");
+      if (keepsStdoutToOutput) log.notice(`--verbose is skipped with the ${format} format, to keep the output clean`);
       else printCapturedEvents(sessionPayloads, excluded);
     }
-    if (jsonMode) {
+    if (format === "json") {
       log.plain(toJsonOutput(day, date));
+    } else if (format === "text") {
+      log.plain(toPlainText(fullSummary));
     } else {
       log.plain("");
       log.plain(fullSummary);
@@ -8340,7 +8890,7 @@ function registerSummary(program) {
       printSavedNote(saved);
       if (needsGeneration) printExcludedFooter(sessionPayloads, excluded);
     }
-    await postSummary({ options, config, summary: fullSummary, statusToStderr: jsonMode });
+    await postSummary({ options, config, summary: fullSummary, statusToStderr: keepsStdoutToOutput });
   });
 }
 var import_chalk8;
@@ -8357,6 +8907,8 @@ var init_summary = __esm({
     init_notices();
     init_webhook2();
     init_day();
+    init_output_format();
+    init_plain_text();
     init_day_notes();
     init_thread_day();
     init_week2();
@@ -8980,7 +9532,8 @@ var init_profile = __esm({
 function registerNote(program) {
   program.command("note <text>").description("Attach a free-text annotation to the current session").action((text) => {
     const directory = currentDirectory();
-    const context = getRepoContext(directory, readConfig());
+    const config = readConfig();
+    const context = getRepoContext(directory, config);
     const { repoName, branch } = context;
     insertEvent({
       captured_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -8991,7 +9544,7 @@ function registerNote(program) {
       repo_name: repoName,
       branch,
       category: "note",
-      metadata: JSON.stringify({ text }),
+      metadata: JSON.stringify({ text: redact(text, config.redact.extra) }),
       source: null,
       file_path: null,
       dimensions: eventDimensions(context)
@@ -9005,6 +9558,7 @@ var init_note = __esm({
     init_db();
     init_git();
     init_dimensions3();
+    init_redact();
     init_config();
     init_working_directory();
     init_logger();
@@ -9034,7 +9588,7 @@ function registerBugReport(program) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const reportPath = import_path30.default.join(WORKSCRIBE_DIR, `bug-report-${timestamp}.txt`);
     const systemInfo = [
-      `Workscribe version : ${"3.0.1"}`,
+      `Workscribe version : ${"3.2.0"}`,
       `Node.js version    : ${process.version}`,
       `Platform           : ${process.platform}`,
       `Architecture       : ${process.arch}`,
@@ -9065,7 +9619,7 @@ function registerBugReport(program) {
       process.exit(1);
     }
     const params = new URLSearchParams({
-      title: `Bug report \u2014 workscribe ${"3.0.1"}`,
+      title: `Bug report \u2014 workscribe ${"3.2.0"}`,
       body: `<!-- Attach ${import_path30.default.basename(reportPath)} or paste the relevant sections below -->
 
 **Describe the issue:**
@@ -9156,7 +9710,7 @@ function reportRun(result) {
 function registerUpgrade(program) {
   program.command("upgrade").description("Bring your stored data up to date after updating Workscribe (backs it up first)").action(() => {
     const announced = /* @__PURE__ */ new Set();
-    const result = runDataJobs("3.0.1", {
+    const result = runDataJobs("3.2.0", {
       onProgress: ({ job }) => {
         if (announced.has(job.name)) return;
         announced.add(job.name);
@@ -9646,7 +10200,7 @@ function isNewer(latest, current) {
   return latestPatch > currentPatch;
 }
 function checkForUpdate() {
-  const current = "3.0.1";
+  const current = "3.2.0";
   const cache = readCache();
   if (cache && isNewer(cache.latestVersion, current)) {
     process.stderr.write(
@@ -9669,7 +10223,7 @@ function checkForUpdate() {
 function buildTelemetryPayload(config) {
   return {
     installId: config.telemetry.installId,
-    cliVersion: "3.0.1",
+    cliVersion: "3.2.0",
     platform: import_os12.default.platform(),
     nodeVersion: process.version
   };
@@ -9747,10 +10301,10 @@ var require_main = __commonJS({
       pingTelemetry();
     }
     if (shouldRunDataJobs(process.argv.slice(2))) {
-      runDataJobsBeforeCommand(invokedCommand, "3.0.1");
+      runDataJobsBeforeCommand(invokedCommand, "3.2.0");
     }
     var program = new import_commander.Command();
-    program.name("workscribe").description("Automatic developer work journal").version("3.0.1");
+    program.name("workscribe").description("Automatic developer work journal").version("3.2.0");
     registerCapture(program);
     registerHook(program);
     registerInit(program);