@workscribe/cli 3.1.0 → 3.2.0

package/README.md

@@ -19,7 +19,7 @@ On feature/auth:
 - Committed: add JWT validation middleware
 - Added dependencies: bcrypt, jsonwebtoken
 - Pushed to origin/feature/auth
-With an AI coding assistant (126 commands) · 3 file saves in the editor
+With Claude Code (2 sessions) · 3 file saves in the editor
 
 ## infrastructure — 45m
 - Note: staging was flaky after the compose upgrade

package/dist/index.js

@@ -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" })),
@@ -3021,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"));
@@ -3031,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 = ["|"];
   }
 });
 
@@ -4517,10 +4665,10 @@ function installIntoFolder(options) {
     const outcome = installSkill({
       sourceDir: options.sourceDir,
       skillsFolder: target.skillsFolder,
-      version: "3.1.0",
+      version: "3.2.0",
       force: options.force
     });
-    return describeInstallOutcome({ ...target, outcome, version: "3.1.0" });
+    return describeInstallOutcome({ ...target, outcome, version: "3.2.0" });
   } catch (error) {
     return describeInstallFailure({ ...target, error });
   }
@@ -4539,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.1.0");
-  const status = describeSkillStatus(installState, "3.1.0");
+  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) {
@@ -4832,10 +4980,10 @@ async function runAIToolsStep() {
 }
 async function offerSkillInstall(group, sourceDir) {
   const target = describeTarget(group);
-  const state = readInstallState(target.skillsFolder, "3.1.0");
+  const state = readInstallState(target.skillsFolder, "3.2.0");
   const knownOutcome = outcomeWithoutPrompt(state);
   if (knownOutcome) {
-    printMessage(describeInstallOutcome({ ...target, outcome: knownOutcome, version: "3.1.0" }));
+    printMessage(describeInstallOutcome({ ...target, outcome: knownOutcome, version: "3.2.0" }));
     return;
   }
   const { installSkill: shouldInstall } = await (0, import_prompts2.default)({
@@ -5923,6 +6071,73 @@ var init_scrub_secrets = __esm({
   }
 });
 
+// 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({
@@ -5934,11 +6149,13 @@ var init_jobs = __esm({
     init_drop_old_sessions();
     init_ticket_refs();
     init_scrub_secrets();
+    init_read_only_commands();
     JOBS = [
       createProjectDimensionsJob({ probeDirectory }),
       summaryAnchorsJob,
       ticketRefsJob,
       scrubSecretsJob,
+      readOnlyCommandsJob,
       dropOldSessionsJob
     ];
   }
@@ -6836,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;
@@ -7649,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";
@@ -7658,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",
@@ -7687,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}`));
@@ -7780,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;
@@ -7813,6 +8052,7 @@ var init_describe = __esm({
     "use strict";
     init_commits();
     init_exclusions();
+    init_agents2();
     init_constants2();
     init_utils3();
   }
@@ -7952,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;
@@ -8002,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();
@@ -9349,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.1.0"}`,
+      `Workscribe version : ${"3.2.0"}`,
       `Node.js version    : ${process.version}`,
       `Platform           : ${process.platform}`,
       `Architecture       : ${process.arch}`,
@@ -9380,7 +9619,7 @@ function registerBugReport(program) {
       process.exit(1);
     }
     const params = new URLSearchParams({
-      title: `Bug report \u2014 workscribe ${"3.1.0"}`,
+      title: `Bug report \u2014 workscribe ${"3.2.0"}`,
       body: `<!-- Attach ${import_path30.default.basename(reportPath)} or paste the relevant sections below -->
 
 **Describe the issue:**
@@ -9471,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.1.0", {
+    const result = runDataJobs("3.2.0", {
       onProgress: ({ job }) => {
         if (announced.has(job.name)) return;
         announced.add(job.name);
@@ -9961,7 +10200,7 @@ function isNewer(latest, current) {
   return latestPatch > currentPatch;
 }
 function checkForUpdate() {
-  const current = "3.1.0";
+  const current = "3.2.0";
   const cache = readCache();
   if (cache && isNewer(cache.latestVersion, current)) {
     process.stderr.write(
@@ -9984,7 +10223,7 @@ function checkForUpdate() {
 function buildTelemetryPayload(config) {
   return {
     installId: config.telemetry.installId,
-    cliVersion: "3.1.0",
+    cliVersion: "3.2.0",
     platform: import_os12.default.platform(),
     nodeVersion: process.version
   };
@@ -10062,10 +10301,10 @@ var require_main = __commonJS({
       pingTelemetry();
     }
     if (shouldRunDataJobs(process.argv.slice(2))) {
-      runDataJobsBeforeCommand(invokedCommand, "3.1.0");
+      runDataJobsBeforeCommand(invokedCommand, "3.2.0");
     }
     var program = new import_commander.Command();
-    program.name("workscribe").description("Automatic developer work journal").version("3.1.0");
+    program.name("workscribe").description("Automatic developer work journal").version("3.2.0");
     registerCapture(program);
     registerHook(program);
     registerInit(program);