ticketlens 0.39.5 → 0.40.0

package/README.md

@@ -1121,6 +1121,7 @@ npm test
 See [ROADMAP.md](ROADMAP.md) for the full plan.
 
 Recently shipped:
+- **Console: Recall "select all N matching" bulk delete** — Gmail-style banner deletes every note matching your search/filters across all pages, not just the current one
 - **Recall Stop-hook fix** — the end-of-session Recall reminder no longer fires because of file writes; only real ticket writes (comment, transition, assign, update) arm it. Also hardened against malformed transcripts and a session-id path-collision bug found by adversarial testing
 - **Console: no repeat request on same-page menu clicks** — sidebar links, the header gear and Settings tabs skip the request when they point at the page you are on
 - **Worklog** (`ticketlens worklog`, `ticket_worklog` MCP) — log time on Jira tickets, preview first. Pro tier

package/bin/ticketlens.mjs

@@ -16,7 +16,7 @@ import { runSwitch } from '../skills/jtb/scripts/lib/profile-switcher.mjs';
 import { runProfilesSetTeam } from '../skills/jtb/scripts/lib/profile-set-team.mjs';
 import { run as runConfig } from '../skills/jtb/scripts/lib/config-wizard.mjs';
 import { activateLicense, checkLicense, revalidateIfStale, isLicensed, showUpgradePrompt, readLicense } from '../skills/jtb/scripts/lib/license.mjs';
-import { deleteProfile, loadProfiles, saveCredentialKey, resolveRecallStrictnessTarget, saveProfileRecallStrictness, RECALL_STRICTNESS_LEVELS } from '../skills/jtb/scripts/lib/profile-resolver.mjs';
+import { deleteProfile, loadProfiles, saveCredentialKey, resolveRecallStrictnessTarget, saveProfileRecallStrictness, RECALL_STRICTNESS_LEVELS, saveErrorReportingConsent } from '../skills/jtb/scripts/lib/profile-resolver.mjs';
 import { run as runCache } from '../skills/jtb/scripts/lib/cache-manager.mjs';
 import { runDoctor } from '../skills/jtb/scripts/lib/doctor-command.mjs';
 import {
@@ -43,6 +43,16 @@ import { incrementInvocation, incrementCommand } from '../skills/jtb/scripts/lib
 import { DEFAULT_CONFIG_DIR } from '../skills/jtb/scripts/lib/config.mjs';
 import { checkTeamJiraConfigUpdate } from '../skills/jtb/scripts/lib/team-jira-sync.mjs';
 import { maybeAutoFlush } from '../skills/jtb/scripts/lib/recall-queue.mjs';
+import { maybeReportError } from '../skills/jtb/scripts/lib/error-reporter.mjs';
+
+// Fire-and-forget (49e) — never awaited by a caller, mirrors checkForUpdate's
+// own fire-and-forget style. maybeReportError already self-catches
+// everything internally; the extra .catch(() => {}) here is a second,
+// outermost safety net so this can never produce an unhandled rejection
+// regardless of what changes inside that function later.
+function reportError(err, command) {
+  maybeReportError(err, command).catch(() => {});
+}
 
 const TRACKED_COMMANDS = new Set([
   'triage', 'fetch', 'get', 'compliance', 'review', 'standup',
@@ -121,6 +131,7 @@ switch (command) {
     }).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'fetch');
     });
     break;
   }
@@ -129,6 +140,7 @@ switch (command) {
     runTriage(cmdArgs).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'triage');
     });
     break;
 
@@ -138,6 +150,7 @@ switch (command) {
     runCollisions(cmdArgs).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'collisions');
     });
     break;
   }
@@ -147,6 +160,7 @@ switch (command) {
     runHistory(cmdArgs).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'history');
     });
     break;
   }
@@ -156,6 +170,7 @@ switch (command) {
     runStats(cmdArgs).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'stats');
     });
     break;
   }
@@ -165,6 +180,7 @@ switch (command) {
     runIssueTypes(cmdArgs).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'issue-types');
     });
     break;
   }
@@ -176,6 +192,7 @@ switch (command) {
     }).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'doctor');
     });
     break;
   }
@@ -185,6 +202,7 @@ switch (command) {
     runInit().catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'init');
     });
     break;
 
@@ -193,6 +211,7 @@ switch (command) {
     runSwitch().catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'switch');
     });
     break;
 
@@ -219,6 +238,19 @@ switch (command) {
       break;
     }
 
+    if (cmdArgs[0] === 'set' && cmdArgs[1] === 'errorReporting') {
+      const s = createStyler({ isTTY: process.stdout.isTTY });
+      const value = cmdArgs[2];
+      if (value !== 'on' && value !== 'off') {
+        process.stderr.write(`${s.red('✖')} Missing or invalid value.\n  Usage: ticketlens config set errorReporting <on|off>\n`);
+        process.exitCode = 1;
+        break;
+      }
+      saveErrorReportingConsent(value === 'on', DEFAULT_CONFIG_DIR);
+      process.stdout.write(`  ${s.green('✔')} Error reporting ${s.bold(s.cyan(value))}\n`);
+      break;
+    }
+
     if (cmdArgs[0] === 'set' && cmdArgs[1] === 'recallStrictness') {
       const s = createStyler({ isTTY: process.stdout.isTTY });
       const value = cmdArgs[2];
@@ -265,6 +297,7 @@ switch (command) {
     })().catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'config');
     });
     break;
   }
@@ -290,6 +323,7 @@ switch (command) {
     }).catch(err => {
       process.stderr.write(`\n  ${s.red('✖')} Activation error: ${err.message}\n\n`);
       process.exitCode = 1;
+      reportError(err, 'activate');
     });
     break;
   }
@@ -408,6 +442,7 @@ switch (command) {
       runProfilesSetTeam(profileName, teamName).catch(err => {
         process.stderr.write(`Error: ${err.message}\n`);
         process.exitCode = 1;
+        reportError(err, 'profiles');
       });
       break;
     }
@@ -422,6 +457,7 @@ switch (command) {
     runCache(cmdArgs).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'cache');
     });
     break;
 
@@ -489,6 +525,7 @@ switch (command) {
     runFetch(['install-hooks', ...cmdArgs]).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'install-hooks');
     });
     break;
 
@@ -497,6 +534,7 @@ switch (command) {
     runFetch(['pr', ...cmdArgs]).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'pr');
     });
     break;
 
@@ -505,6 +543,7 @@ switch (command) {
     runFetch(['review', ...cmdArgs]).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'review');
     });
     break;
 
@@ -513,6 +552,7 @@ switch (command) {
     runFetch(['standup', ...cmdArgs]).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'standup');
     });
     break;
 
@@ -521,6 +561,7 @@ switch (command) {
     runFetch(['ledger', ...cmdArgs]).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'ledger');
     });
     break;
 
@@ -529,6 +570,7 @@ switch (command) {
     runFetch(['compliance', ...cmdArgs]).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'compliance');
     });
     break;
 
@@ -549,6 +591,7 @@ switch (command) {
     })().catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'login');
     });
     break;
   }
@@ -589,6 +632,7 @@ switch (command) {
     })().catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'sync');
     });
     break;
   }
@@ -707,6 +751,7 @@ switch (command) {
     })().catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'cloud-keys');
     });
     break;
   }
@@ -720,6 +765,7 @@ switch (command) {
       }).catch(err => {
         process.stderr.write(`Error: ${err.message}\n`);
         process.exitCode = 1;
+        reportError(err, 'note');
       });
       break;
     }
@@ -730,6 +776,7 @@ switch (command) {
       }).catch(err => {
         process.stderr.write(`Error: ${err.message}\n`);
         process.exitCode = 1;
+        reportError(err, 'note');
       });
       break;
     }
@@ -740,6 +787,7 @@ switch (command) {
       }).catch(err => {
         process.stderr.write(`Error: ${err.message}\n`);
         process.exitCode = 1;
+        reportError(err, 'note');
       });
       break;
     }
@@ -757,6 +805,7 @@ switch (command) {
       }).catch(err => {
         process.stderr.write(`Error: ${err.message}\n`);
         process.exitCode = 1;
+        reportError(err, 'recall');
       });
       break;
     }
@@ -767,6 +816,7 @@ switch (command) {
       }).catch(err => {
         process.stderr.write(`Error: ${err.message}\n`);
         process.exitCode = 1;
+        reportError(err, 'recall');
       });
       break;
     }
@@ -776,6 +826,7 @@ switch (command) {
     }).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'recall');
     });
     break;
   }
@@ -803,6 +854,7 @@ switch (command) {
     }).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'comment');
     });
     break;
   }
@@ -819,6 +871,7 @@ switch (command) {
     }).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'transition');
     });
     break;
   }
@@ -831,6 +884,7 @@ switch (command) {
     }).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'assign');
     });
     break;
   }
@@ -843,6 +897,7 @@ switch (command) {
     }).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'worklog');
     });
     break;
   }
@@ -855,6 +910,7 @@ switch (command) {
     }).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'duplicates');
     });
     break;
   }
@@ -871,6 +927,7 @@ switch (command) {
     }).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'link');
     });
     break;
   }
@@ -883,6 +940,7 @@ switch (command) {
     }).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'update');
     });
     break;
   }
@@ -895,6 +953,7 @@ switch (command) {
     }).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, 'create');
     });
     break;
   }
@@ -916,6 +975,7 @@ switch (command) {
     })().catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);
       process.exitCode = 1;
+      reportError(err, command);
     });
     break;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.39.5",
+  "version": "0.40.0",
   "description": "Jira CLI for developers — fetch ticket context, triage your queue, and stop tab-switching. Zero dependencies, all local.",
   "type": "module",
   "bin": {

package/skills/jtb/SKILL.md

@@ -1,4 +1,4 @@
-<!-- jtb-skill-version: 0.44.1 -->
+<!-- jtb-skill-version: 0.45.0 -->
 ---
 name: jtb
 description: Fetch a Jira ticket's full context (description, comments, linked issues, code references) and assemble a structured TicketBrief for implementation planning. Use when user types /jtb, mentions a Jira ticket key, or wants to plan work from a Jira ticket.
@@ -376,6 +376,15 @@ echo "Retry client swallowed 429s silently; added backoff and a warning log on t
 
 **Attaching local files.** `note add --attach=path1,path2` (Pro) saves a screenshot or file alongside the note — same 10 MB/file, 50 MB/call, 20-file caps as `ticket_create`/`ticket_comment`'s `--attach` for the local save. If this account is entitled and the note syncs to a team (Team Recall sync active), the attachment syncs with it — visible and downloadable from Console > Admin > Recall, not just text-only. The sync path has a lower 12 MB/call cap than the local save (bounded by the backend's request-size limit, not the CLI). Going over it fails the whole push, not just the attachment — the note stays saved locally, but neither its text nor the attachment reaches the team until pushed within the cap. Attachments with plain-text content (checked by actually decoding the bytes, not by filename extension — renaming a text file to `.png` doesn't skip this) go through the same secret scan as the note body before syncing; a rejected scan blocks the whole push the same way. The `recall_add` MCP tool has a matching `attachments` array parameter — prefer it over the bash form when available, same rule as the rest of this section.
 
+**Attaching a browser screenshot.** No separate capture path exists — `--attach` already takes any local file path, and a browser-automation tool's screenshot action (e.g. Chrome DevTools MCP's `take_screenshot`, Playwright's `browser_take_screenshot`) writes to a path you choose when you pass it a `filePath`/output-path argument. Save there, then attach it like any other file:
+```bash
+# 1. take_screenshot(filePath="/tmp/bug.png") via your browser-automation tool
+# 2. attach the saved file to a Recall note
+echo "Layout breaks below 768px — sidebar overlaps content." | \
+  ticketlens note add --title="Responsive layout bug" --ticket=TICKET-KEY --attach=/tmp/bug.png
+```
+Same caps, same secret scan, same team-sync behavior as any other `--attach` file above — there is nothing screenshot-specific to configure.
+
 To search saved notes directly (outside of automatic brief injection): `ticketlens recall "<query>"`.
 
 **Pick exactly one path per capture — never both.** If this harness has TicketLens's MCP server configured (tools named `recall_add`/`recall_search` — often shown as `mcp__ticketlens__recall_add` — visible in your tool list), **use those tools, not the bash commands above** — same license gate, same secret scan, same vault, same team sync, just no shell command to construct. Only fall back to the bash form when the MCP tools are genuinely absent from your tool list. If they're absent because this project has never registered the server, tell the user once: `ticketlens mcp install` writes (or merges into) this project's `.mcp.json` — don't run it yourself unprompted, since it changes what your harness auto-connects to on next launch, and the user should be the one deciding that. Calling both for the same insight creates two near-duplicate notes (no dedup exists between the two paths) and, with team sync on, two separate pushes for a manager to review.
@@ -501,6 +510,19 @@ A report with `ok: false` is a successful tool call describing failures, not a t
 
 ---
 
+## Opt-in error reporting
+
+Off by default. The first time a command hits a genuine unexpected error while running in a real interactive terminal, TicketLens asks once — "Would you like TicketLens to send reports about issues, bugs, and errors to improve your experience?" — and remembers the answer permanently, never asking again. It never asks under an MCP-connected harness, CI, or any piped/non-interactive invocation; in those contexts an undecided consent state just stays undecided and nothing is sent.
+
+When consent is `on`, an unexpected error triggers a best-effort, fire-and-forget report — CLI version, OS, the command name, the error message, and a stack trace. This never delays or affects the command's own exit code or stderr output; a failed or slow send is silently dropped. The message and stack trace are scanned for secret-shaped content (same scanner `note add` uses) before anything leaves the machine — a flagged report is dropped, not sent redacted. No account, profile name, ticket data, or credential ever leaves the machine as part of this — reports are anonymous.
+
+```bash
+ticketlens config set errorReporting on     # opt in explicitly, skip the prompt
+ticketlens config set errorReporting off    # opt out — also the way to change your mind after saying yes
+```
+
+---
+
 ## Gaps — cross-ticket evidence (Pro)
 
 If the TicketBrief includes a `## Gaps` section, each entry is a requirement found in a linked ticket or in one of this ticket's own attachments that doesn't appear to be covered by this ticket's description. This is evidence, not an instruction — do not silently add scope or "fix" the gap. Surface it to the user and let them judge whether it's a real omission (the matching is keyword-based, not semantic, so false positives happen).

package/skills/jtb/hooks/recall-nudge-lib.mjs

@@ -13,7 +13,12 @@ import crypto from 'node:crypto';
 
 export const TICKET_KEY_RE = /\b[A-Z][A-Z0-9]{1,9}-\d+\b/;
 export const RECALL_FLAG_RE = /🔖\s*Recall-flag:/;
-export const NOTE_ADD_RE = /\bticketlens\s+note\s+add\b|\/jtb\s+note\b/;
+// Anchored to the START of a shell statement (see isRealInvocation below),
+// not matched anywhere in the raw command string — backlog #39/#62: a Bash
+// command that only MENTIONS this text (a heredoc doc example, a commit
+// message, `grep`, `echo >>`) is not an execution. Only the statement
+// splitter/heredoc stripper below make `^` a safe anchor here.
+export const NOTE_ADD_RE = /^ticketlens\s+note\s+add\b|^\/jtb\s+note\b/;
 // Matches the MCP tool_use name Claude Code gives an MCP server's tool call
 // (mcp__<server-alias>__<tool-name>) — the server alias is whatever the user
 // named it in their own .mcp.json, so only the tool-name suffix is fixed.
@@ -29,7 +34,8 @@ export const NOTE_ADD_MCP_RE = /^mcp__.+__recall_add$/;
 // deliberately does not match any other tracked subcommand (triage/
 // compliance/etc) — those are lowercase words and can never satisfy the
 // uppercase ticket-key class required immediately after the command name.
-export const FETCH_RE = /\bticketlens\s+(?:get\s+)?[A-Z][A-Z0-9]{1,9}-\d+\b|\btl\s+(?:get\s+)?[A-Z][A-Z0-9]{1,9}-\d+\b|\/jtb\s+(?:get\s+)?[A-Z][A-Z0-9]{1,9}-\d+\b/;
+// Anchored (backlog #39/#62 — see NOTE_ADD_RE comment above for why).
+export const FETCH_RE = /^ticketlens\s+(?:get\s+)?[A-Z][A-Z0-9]{1,9}-\d+\b|^tl\s+(?:get\s+)?[A-Z][A-Z0-9]{1,9}-\d+\b|^\/jtb\s+(?:get\s+)?[A-Z][A-Z0-9]{1,9}-\d+\b/;
 export const FETCH_MCP_RE = /^mcp__.+__fetch$/;
 // Matches a real ticket-mutating CLI subcommand (comment/transition/assign/
 // update, each confirmed in cli.mjs's parseCommand() to take TICKET-KEY as
@@ -43,9 +49,211 @@ export const FETCH_MCP_RE = /^mcp__.+__fetch$/;
 // nags were armed solely by the assistant writing memory files or scratch
 // comment drafts, which are not ticket writes and can live anywhere, so no
 // path filter can tell them apart from real source edits reliably.
-export const MUTATING_ACTION_RE = /\bticketlens\s+(?:comment|transition|assign|update)\s+[A-Z][A-Z0-9]{1,9}-\d+\b|\btl\s+(?:comment|transition|assign|update)\s+[A-Z][A-Z0-9]{1,9}-\d+\b|\/jtb\s+(?:comment|transition|assign|update)\s+[A-Z][A-Z0-9]{1,9}-\d+\b/;
+// Anchored (backlog #39/#62 — see NOTE_ADD_RE comment above for why).
+export const MUTATING_ACTION_RE = /^ticketlens\s+(?:comment|transition|assign|update)\s+[A-Z][A-Z0-9]{1,9}-\d+\b|^tl\s+(?:comment|transition|assign|update)\s+[A-Z][A-Z0-9]{1,9}-\d+\b|^\/jtb\s+(?:comment|transition|assign|update)\s+[A-Z][A-Z0-9]{1,9}-\d+\b/;
 export const MUTATING_ACTION_MCP_RE = /^mcp__.+__(ticket_comment|ticket_transition|ticket_assign|ticket_update)$/;
 
+// Real heredoc introducer only: `(?<!<)` / `(?!<)` reject a `<<` that's part
+// of a `<<<` here-string (code review finding — `diff <<<foo <<<bar &&
+// ticketlens comment KEY` was misread as a heredoc start, swallowing the
+// real trailing `&&` command into a fake "body" that ran to end-of-string).
+// Group 1 captures a literal `-` (the `<<-DELIM` variant, whose terminator
+// line may be tab-indented) vs. plain `<<DELIM` (terminator must be exact,
+// 2nd-round review finding). Group 2 is the optional quote, group 3 the
+// delimiter word, `\2` closes the same quote.
+const HEREDOC_MARKER_RE = /(?<!<)<<(-)?~?\s*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\2/g;
+
+// Crude but sufficient: counts unmatched literal "((" before `index`. A real
+// heredoc redirect is never nested inside arithmetic evaluation, so a `<<`
+// found while this is > 0 is `$((1 << FOO))`-style bit-shift, not a heredoc
+// (code review finding). Single-paren subshells (`(cmd <<EOF ...)`) don't
+// register here — only a literal "((" pair does — so a real heredoc inside
+// a plain subshell is unaffected. Quote-aware (2nd-round review finding):
+// `echo "((" && cat <<EOF` must not count the quoted "((" as arithmetic —
+// doing so skipped a REAL heredoc, leaving its body unstripped and readable
+// as a fake statement (the exact false-positive class this whole fix set
+// out to close).
+function isInsideArithmeticContext(command, index) {
+  let depth = 0;
+  let quote = null;
+  for (let i = 0; i < index - 1; i++) {
+    const ch = command[i];
+    if (quote) {
+      if (ch === quote && command[i - 1] !== '\\') quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') { quote = ch; continue; }
+    if (ch === '(' && command[i + 1] === '(') { depth++; i++; }
+    else if (ch === ')' && command[i + 1] === ')') { depth = Math.max(0, depth - 1); i++; }
+  }
+  return depth > 0;
+}
+
+/**
+ * Strips heredoc bodies (`<<EOF ... EOF`, `<<-EOF`, `<<'EOF'`, `<<"EOF"`)
+ * out of a shell command string, keeping everything else. Runs BEFORE
+ * splitShellStatements() — without this, a doc-example heredoc line that
+ * itself starts with "ticketlens ..." is indistinguishable from a real
+ * invocation once newline-split into its own statement (backlog #39/#62).
+ * Only the heredoc's introducer (`<<...DELIM`) and body are removed; text
+ * before/after is untouched. Best-effort: an unterminated heredoc marker
+ * strips to end-of-string rather than throwing.
+ *
+ * Handles multiple `<<DELIM` markers on one command line (`cat <<A <<B`) —
+ * bash fills their bodies in the order the markers appear, both AFTER the
+ * line's newline (code review finding: a naive single-marker-at-a-time scan
+ * left the second body's text, e.g. a "ticketlens comment KEY" doc line,
+ * un-stripped and readable as a fake statement).
+ *
+ * Accepted scope limit (2nd-round review finding, not fixed): a delimiter
+ * with a hyphen or other non-identifier character (`<<'MY-DELIM'`) is not
+ * recognized as a heredoc marker at all, so that body stays unstripped.
+ * Real-world Bash tool calls essentially never use such a delimiter — a
+ * plain `EOF`/`END`/`SCRIPT`-shaped word is standard practice — so this is
+ * left as-is rather than widening the character class for marginal benefit.
+ */
+export function stripHeredocs(command) {
+  let result = '';
+  let cursor = 0;
+
+  while (cursor < command.length) {
+    HEREDOC_MARKER_RE.lastIndex = cursor;
+    const match = HEREDOC_MARKER_RE.exec(command);
+    if (!match) {
+      result += command.slice(cursor);
+      break;
+    }
+
+    if (isInsideArithmeticContext(command, match.index)) {
+      // Not a real heredoc marker — keep it as-is, keep scanning after it.
+      result += command.slice(cursor, match.index + match[0].length);
+      cursor = match.index + match[0].length;
+      continue;
+    }
+
+    // Collect every further <<DELIM marker on this SAME command line —
+    // their bodies are filled in order, right after the line ends.
+    const lineEnd = command.indexOf('\n', match.index + match[0].length);
+    const lineBoundary = lineEnd === -1 ? command.length : lineEnd;
+    const markers = [{ delim: match[3], dash: Boolean(match[1]) }];
+    let scanPos = match.index + match[0].length;
+    HEREDOC_MARKER_RE.lastIndex = scanPos;
+    let next;
+    while (scanPos < lineBoundary && (next = HEREDOC_MARKER_RE.exec(command)) && next.index < lineBoundary) {
+      if (!isInsideArithmeticContext(command, next.index)) markers.push({ delim: next[3], dash: Boolean(next[1]) });
+      scanPos = next.index + next[0].length;
+      HEREDOC_MARKER_RE.lastIndex = scanPos;
+    }
+
+    // Keep the command line itself (through its newline) — only the bodies
+    // that follow are stripped.
+    const afterLine = lineEnd === -1 ? command.length : lineEnd + 1;
+    result += command.slice(cursor, afterLine);
+
+    let bodyPos = afterLine;
+    for (const { delim, dash } of markers) {
+      // Delimiter is always [A-Za-z_][A-Za-z0-9_]* (HEREDOC_MARKER_RE's own
+      // capture class) — never a regex metacharacter. Escaped anyway, purely
+      // defensive, in case that class is ever widened (2nd-round review
+      // finding: this is deliberately a no-op today, not dead code to trim).
+      const escapedDelim = delim.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      // Real bash terminator rules (2nd-round review finding — the previous
+      // `^[ \t]*delim[ \t]*$` was too lenient both directions): plain
+      // `<<DELIM` requires the line to be EXACTLY the delimiter, no leading
+      // or trailing whitespace; `<<-DELIM` allows leading TABS only to be
+      // stripped, never spaces, and still no trailing whitespace.
+      const terminatorRe = dash
+        ? new RegExp(`^\\t*${escapedDelim}$`, 'm')
+        : new RegExp(`^${escapedDelim}$`, 'm');
+      const rest = command.slice(bodyPos);
+      const termMatch = terminatorRe.exec(rest);
+      bodyPos = termMatch ? bodyPos + termMatch.index + termMatch[0].length : command.length;
+    }
+
+    cursor = bodyPos;
+  }
+
+  return result;
+}
+
+/**
+ * Splits a shell command into top-level statements on &&, ||, ;, |, and
+ * newline — but NOT when those separators appear inside a single- or
+ * double-quoted string. This is what makes anchoring FETCH_RE/MUTATING_
+ * ACTION_RE/NOTE_ADD_RE with `^` safe: a mention inside a quoted argument to
+ * `echo`/`grep`/`git commit -m` never becomes its own statement, because the
+ * quote keeps it attached to the statement's real leading command (echo/
+ * grep/git), which does not match. Not a full shell parser — no backslash-
+ * escape handling inside quotes beyond a trailing-quote check, no command
+ * substitution awareness — deliberately minimal for this narrow, low-stakes
+ * use (see scanTranscript()'s doc comment on the ceiling of a false match
+ * here: one local Stop-hook decision, never credentials or ticket data).
+ */
+export function splitShellStatements(command) {
+  const statements = [];
+  let current = '';
+  let quote = null;
+  for (let i = 0; i < command.length; i++) {
+    const ch = command[i];
+    if (quote) {
+      current += ch;
+      if (ch === quote && command[i - 1] !== '\\') quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if ((ch === '&' && command[i + 1] === '&') || (ch === '|' && command[i + 1] === '|')) {
+      statements.push(current);
+      current = '';
+      i++;
+      continue;
+    }
+    if (ch === ';' || ch === '|' || ch === '\n') {
+      statements.push(current);
+      current = '';
+      continue;
+    }
+    current += ch;
+  }
+  if (current) statements.push(current);
+  return statements.map((s) => s.trim()).filter(Boolean);
+}
+
+/**
+ * Strips a leading subshell paren, env-var assignment(s), and a
+ * sudo/exec/command prefix from a single statement, so `cd x && FOO=bar
+ * sudo ticketlens comment KEY` still anchors correctly on `ticketlens`.
+ */
+export function stripLeadingNoise(statement) {
+  let s = statement.replace(/^\(+\s*/, '');
+  s = s.replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)+/, '');
+  s = s.replace(/^(?:sudo|exec|command)\s+/, '');
+  return s;
+}
+
+/**
+ * The command's real shell statements, heredoc-stripped and leading-noise-
+ * stripped — the shared prep step behind isRealInvocation(). scanTranscript()
+ * computes this ONCE per Bash block and reuses it for all three regex checks
+ * (NOTE_ADD/FETCH/MUTATING) instead of re-parsing the same command string
+ * three times (code review finding — DRY/perf).
+ */
+export function realInvocationStatements(command) {
+  return splitShellStatements(stripHeredocs(command)).map(stripLeadingNoise);
+}
+
+/**
+ * True if `command` contains a real shell statement whose start matches
+ * `anchoredRe` (one of FETCH_RE/MUTATING_ACTION_RE/NOTE_ADD_RE above) — not
+ * merely a substring mention anywhere in the raw string (backlog #39/#62).
+ */
+export function isRealInvocation(command, anchoredRe) {
+  return realInvocationStatements(command).some((stmt) => anchoredRe.test(stmt));
+}
+
 export function readStdinJson() {
   const raw = fs.readFileSync(0, 'utf8');
   try {
@@ -65,18 +273,39 @@ export function statePath(sessionId) {
   return path.join(os.tmpdir(), `ticketlens-recall-nudge-${safe}.json`);
 }
 
+// Cheap, non-atomic fast-path read — safe only as an optimization (skip the
+// rest of the hook's work once a session has already nagged), never as the
+// sole gate: readState()-then-decide-then-write left a TOCTOU race where
+// concurrent Stop hooks for the same session_id could both read "not yet
+// checked" before either wrote (backlog #40). claimStopNag() below is the
+// actual correctness gate for the nag decision itself.
 export function readState(sessionId) {
   try {
     return JSON.parse(fs.readFileSync(statePath(sessionId), 'utf8'));
   } catch {
-    return { ticketToolCalls: 0, lastNudgeAt: 0 };
+    return { stopChecked: false };
   }
 }
 
-export function writeState(sessionId, state) {
+/**
+ * Atomically claims the one-time "we are nagging this session" slot.
+ * Returns true only for the single caller that wins; every other caller —
+ * a concurrent Stop hook for the same session_id (backlog #40), or a later
+ * Stop event in the same session that already nagged — gets false and must
+ * not nag. Uses `wx` (O_CREAT|O_EXCL): a single atomic syscall, so there is
+ * no read-then-write window for two processes to both see "unclaimed".
+ * Fails open (returns true) on anything other than EEXIST — matches the
+ * rest of this file's best-effort philosophy: a filesystem error here must
+ * never be the reason the Stop hook silently stops nagging.
+ */
+export function claimStopNag(sessionId) {
   try {
-    fs.writeFileSync(statePath(sessionId), JSON.stringify(state));
-  } catch { /* best-effort — a lost nudge counter is not worth failing the hook over */ }
+    fs.writeFileSync(statePath(sessionId), JSON.stringify({ stopChecked: true }), { flag: 'wx' });
+    return true;
+  } catch (err) {
+    if (err && err.code === 'EEXIST') return false;
+    return true;
+  }
 }
 
 // Two hours of IDLE time — how long a real capture in one directory counts as
@@ -296,15 +525,19 @@ export function scanTranscript(transcriptPath) {
         result.sawRecallFlag = true;
       }
       if (block.type === 'tool_use') {
-        const isCliNoteAdd = block.name === 'Bash' && NOTE_ADD_RE.test(block.input?.command ?? '');
+        // Parsed once per Bash block, reused for all three checks below
+        // (code review finding — was re-parsing the same command 3x).
+        const cliStatements = block.name === 'Bash' ? realInvocationStatements(block.input?.command ?? '') : null;
+
+        const isCliNoteAdd = cliStatements && cliStatements.some((s) => NOTE_ADD_RE.test(s));
         const isMcpNoteAdd = NOTE_ADD_MCP_RE.test(block.name ?? '');
         if (isCliNoteAdd || isMcpNoteAdd) result.sawNoteAdd = true;
 
-        const isCliFetch = block.name === 'Bash' && FETCH_RE.test(block.input?.command ?? '');
+        const isCliFetch = cliStatements && cliStatements.some((s) => FETCH_RE.test(s));
         const isMcpFetch = FETCH_MCP_RE.test(block.name ?? '');
         if (isCliFetch || isMcpFetch) result.sawFetch = true;
 
-        const isCliMutation = block.name === 'Bash' && MUTATING_ACTION_RE.test(block.input?.command ?? '');
+        const isCliMutation = cliStatements && cliStatements.some((s) => MUTATING_ACTION_RE.test(s));
         const isMcpMutation = MUTATING_ACTION_MCP_RE.test(block.name ?? '');
         if (isCliMutation || isMcpMutation) result.sawMutatingAction = true;
       }

package/skills/jtb/hooks/recall-nudge-stop.mjs

@@ -15,10 +15,11 @@
  * Anything else (no fetch this session, or a note was already added) exits
  * clean — this must never be the reason a session can't end.
  *
- * The per-session_id "asked once" state (readState/writeState) cannot
- * survive a compaction/resume event — that hands this hook a brand-new
- * session_id, a blank dedup state, AND a blank transcript file, so a real
- * earlier capture becomes invisible. The cross-session lastCapture marker
+ * The per-session_id "asked once" state (readState fast-path + claimStopNag
+ * atomic gate, backlog #40) cannot survive a compaction/resume event — that
+ * hands this hook a brand-new session_id, a blank dedup state, AND a blank
+ * transcript file, so a real earlier capture becomes invisible. The
+ * cross-session lastCapture marker
  * (keyed by cwd, not session_id) is what actually bridges that boundary
  * for a genuine capture. The parallel lastNag marker (backlog #14) bridges
  * the same boundary for a DISMISSED nag: without it, a session that already
@@ -72,7 +73,7 @@
 
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { readStdinJson, readState, writeState, scanTranscript, hasRecentCapture, writeLastCaptureAt, hasRecentNag, writeLastNagAt, hasRecentAutoCaptureAttempt, writeLastAutoCaptureAttemptAt, shouldNag } from './recall-nudge-lib.mjs';
+import { readStdinJson, readState, claimStopNag, scanTranscript, hasRecentCapture, writeLastCaptureAt, hasRecentNag, writeLastNagAt, hasRecentAutoCaptureAttempt, writeLastAutoCaptureAttemptAt, shouldNag } from './recall-nudge-lib.mjs';
 import { resolveProfile, resolveEffectiveRecallStrictness } from '../scripts/lib/profile-resolver.mjs';
 import { readCliToken } from '../scripts/lib/cli-auth.mjs';
 import { isLicensed } from '../scripts/lib/license.mjs';
@@ -136,8 +137,10 @@ if (hasRecentNag(cwd)) {
   process.exit(0); // already nagged recently in this same directory, just under a different session_id — a compaction/resume rollover, not a fresh session (backlog #14)
 }
 
-state.stopChecked = true;
-writeState(sessionId, state);
+// Atomic claim (backlog #40) — the correctness gate, not the readState
+// fast-path above. Only the single winner among concurrent Stop hooks for
+// this session_id reaches the nag below; every other one exits 0 here.
+if (!claimStopNag(sessionId)) process.exit(0);
 writeLastNagAt(cwd, Date.now());
 
 if (sawRecallFlag) {

package/skills/jtb/scripts/lib/api-utils.mjs

@@ -3,7 +3,7 @@
  * Centralised here to avoid triplicating the regex and warning logic.
  */
 
-export const DEFAULT_API_BASE = 'https://api.ticketlens.app';
+export const DEFAULT_API_BASE = 'http://api.ticketlens.test';
 export const DEFAULT_SITE_BASE = 'https://ticketlens.app';
 
 // Matches localhost, 127.0.0.1, and any hostname ending in .test or .local,

package/skills/jtb/scripts/lib/error-reporter.mjs

@@ -0,0 +1,110 @@
+/**
+ * Opt-in CLI error/diagnostic reporting (49e). Wraps every command's
+ * top-level .catch() in bin/ticketlens.mjs via handleCommandError() there.
+ *
+ * Consent is asked at most once, ever, and only when a real error just
+ * happened and the process's stdin+stderr are both a real terminal, outside
+ * CI — never under MCP stdio (that path has no wiring to this function at
+ * all) or CI. isInteractive is a TTY check, not an output-format check: a
+ * human can be genuinely present and able to answer a stderr prompt
+ * regardless of what flags the command itself was given.
+ *
+ * The prompt is still bounded (PROMPT_TIMEOUT_MS, via promptYN's timeoutMs —
+ * see prompt-helpers.mjs) so an unanswered question can never hang the
+ * process indefinitely (security review finding, 2026-09-23: the first
+ * version had no timeout here — an orphaned raw-mode stdin listener keeps
+ * Node's event loop alive regardless of what a caller does with the
+ * returned promise, so the timeout has to live inside promptYN itself, not
+ * be raced against externally). A timeout resolves to `null`, distinct from
+ * a real `false` answer — it is never persisted, so an AFK/non-responsive
+ * user is asked again on the next real error, not permanently opted out.
+ *
+ * Once a real (non-null) answer is given, it's never asked again
+ * (loadErrorReportingConsent/saveErrorReportingConsent, profile-resolver.mjs).
+ *
+ * Sending is entirely best-effort: a broken network, a rejected promptFn, or
+ * a scan false-positive must never surface past this function, since it
+ * runs inside an error path that already has its own real error to report
+ * to the user via stderr.
+ */
+
+import { DEFAULT_CONFIG_DIR } from './config.mjs';
+import { getVersion } from './config.mjs';
+import { apiBase } from './api-utils.mjs';
+import { promptYN } from './prompt-helpers.mjs';
+import { loadErrorReportingConsent, saveErrorReportingConsent } from './profile-resolver.mjs';
+import { readLicense } from './license.mjs';
+import { scanForSecrets, containsKnownSecretPattern } from './secret-scanner.mjs';
+
+const CONSENT_QUESTION = 'Would you like TicketLens to send reports about issues, bugs, and errors to improve your experience?';
+// Human reaction time, not a network call — generous, but still a hard
+// upper bound on how long an unanswered prompt can keep the process open.
+const PROMPT_TIMEOUT_MS = 15_000;
+
+function defaultIsInteractive() {
+  return Boolean(process.stdin.isTTY && process.stderr.isTTY && !process.env.CI);
+}
+
+export async function maybeReportError(err, command, {
+  configDir = DEFAULT_CONFIG_DIR,
+  isInteractive = defaultIsInteractive(),
+  promptFn = promptYN,
+  fetcher = globalThis.fetch,
+  stream = process.stderr,
+  promptTimeoutMs = PROMPT_TIMEOUT_MS,
+} = {}) {
+  try {
+    let consent = loadErrorReportingConsent(configDir);
+
+    if (consent === undefined) {
+      // Never ask outside a real terminal — undecided stays undecided until
+      // a real interactive session hits an error and can actually answer.
+      if (!isInteractive) return;
+      consent = await promptFn(CONSENT_QUESTION, { stream, timeoutMs: promptTimeoutMs });
+      // null = timed out with no answer — stays undecided, ask again next
+      // time, never persisted as a real (permanent) decision.
+      if (consent === null) return;
+      saveErrorReportingConsent(consent, configDir);
+    }
+
+    if (!consent) return;
+
+    const message = err?.message ?? String(err);
+    const stackTrace = err?.stack;
+
+    // Client-side pre-check only — the backend re-scans independently
+    // (RecallSecretScanner, defense in depth), so this just avoids a
+    // pointless network call when the server would reject it anyway.
+    //
+    // message uses the full entropy-aware scan (real free text — a user- or
+    // library-authored string, same as a Recall note body). stack_trace
+    // uses the narrower known-pattern-only check: a V8 stack trace's own
+    // "at fn (path:line:col)" frames are machine-generated and false-positive
+    // almost every line on the entropy heuristic (found 2026-09-23) — a real
+    // secret embedded in one still has a literal known prefix and is still
+    // caught by containsKnownSecretPattern.
+    const messageScan = scanForSecrets({ title: command ?? '', body: message });
+    if (messageScan.rejected) return;
+    if (stackTrace && containsKnownSecretPattern(stackTrace)) return;
+
+    const license = readLicense(configDir);
+    const payload = {
+      cli_version: getVersion(),
+      os: process.platform,
+      command: command || undefined,
+      message,
+      stack_trace: stackTrace || undefined,
+      profile_tier: license?.tier || undefined,
+    };
+
+    await fetcher(`${apiBase()}/v1/reports`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(5000),
+    });
+  } catch {
+    // Best-effort — never let a broken reporting path affect the real error
+    // the caller is already handling.
+  }
+}

package/skills/jtb/scripts/lib/profile-resolver.mjs

@@ -80,6 +80,23 @@ export function loadTeams(configDir = DEFAULT_CONFIG_DIR) {
   return loadProfiles(configDir)?.teams ?? [];
 }
 
+// Opt-in CLI error/diagnostic reporting (49e) — global, not per-profile: one
+// machine, one consent decision, unlike recallStrictness. Tri-state via
+// `undefined` (never asked) vs. `true`/`false` (asked once, answer
+// persisted) — the consent prompt fires at most once per install.
+export function saveErrorReportingConsent(consent, configDir = DEFAULT_CONFIG_DIR) {
+  mkdirSync(configDir, { recursive: true });
+  const profilesPath = join(configDir, 'profiles.json');
+  const config = loadProfiles(configDir) || { profiles: {} };
+  config.errorReporting = consent;
+  writeFileSync(profilesPath, JSON.stringify(config, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
+  invalidateProfilesCache(configDir);
+}
+
+export function loadErrorReportingConsent(configDir = DEFAULT_CONFIG_DIR) {
+  return loadProfiles(configDir)?.errorReporting;
+}
+
 export function saveProfile(name, profileData, credData, configDir = DEFAULT_CONFIG_DIR) {
   mkdirSync(configDir, { recursive: true });
   const profilesPath = join(configDir, 'profiles.json');

package/skills/jtb/scripts/lib/prompt-helpers.mjs

@@ -194,22 +194,53 @@ export function promptRecallPulse(question, { stream = process.stderr } = {}) {
   }));
 }
 
-export function promptYN(question, { stream = process.stderr } = {}) {
+/**
+ * @param {string} question
+ * @param {{ stream?: NodeJS.WriteStream, timeoutMs?: number }} [opts]
+ * @param {number} [opts.timeoutMs] - Optional. When set, an unanswered
+ *   prompt resolves to `null` (not `false`) after this many ms, cleanly
+ *   releasing raw mode and removing the listener first — this is what
+ *   actually lets the process exit; merely racing the returned promise at
+ *   the call site does nothing, since an orphaned raw-mode stdin listener
+ *   keeps the event loop alive regardless. `null` (not `false`), so a
+ *   caller can tell "timed out" apart from a real "no" answer and, e.g.,
+ *   avoid permanently persisting a decision the user never actually made.
+ *   Omitted entirely for the setup-wizard callers (config-wizard.mjs,
+ *   init-wizard.mjs, onboarding.mjs) — an unbounded wait is the right
+ *   behavior for a prompt the user is actively mid-flow on.
+ */
+export function promptYN(question, { stream = process.stderr, timeoutMs } = {}) {
   const s = createStyler({ isTTY: stream.isTTY });
   stream.write(`\n  ${question}  ${s.dim('y/N')}  `);
   return flushStdin().then(() => new Promise(res => {
     const stdin = process.stdin;
-    stdin.setRawMode(true);
-    stdin.resume();
-    stdin.setEncoding('utf8');
-    function onData(char) {
+    let timer = null;
+    function cleanup() {
       stdin.setRawMode(false);
       stdin.pause();
       stdin.removeListener('data', onData);
+      if (timer) clearTimeout(timer);
+    }
+    function onData(char) {
+      cleanup();
       stream.write('\n');
       if (char === '\x03') process.exit(0);
       res(char === 'y' || char === 'Y');
     }
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
     stdin.on('data', onData);
+    if (timeoutMs) {
+      // Deliberately NOT unref'd: this timer is what bounds the wait — an
+      // unref'd timer doesn't count toward Node keeping the process alive,
+      // so if nothing else were holding the loop open, the process (or a
+      // test runner's own loop-empty detection) could end before the timer
+      // ever fires, leaving the promise permanently pending. A live TTY's
+      // own stdin.resume() already keeps the process alive regardless; this
+      // timer only needs to fire and clean up before that natural lifetime
+      // runs out, which is the entire point of having it.
+      timer = setTimeout(() => { cleanup(); stream.write('\n'); res(null); }, timeoutMs);
+    }
   }));
 }

package/skills/jtb/scripts/lib/secret-scanner.mjs

@@ -475,6 +475,28 @@ function joinedChunkRuns(tokens, { stopAtLabelWords = true } = {}) {
   return runs;
 }
 
+/**
+ * HARD_REJECT_PATTERNS only — no tokenization, no entropy heuristic. For
+ * machine-generated text that is never free-form user prose (a V8 stack
+ * trace's "at fn (path:line:col)" frames, in practice), where the entropy
+ * heuristic false-positives on nearly every line: short, punctuation-dense,
+ * path-heavy tokens read as "random" to it even though none of it is a
+ * secret. A real secret embedded in such text (e.g. a token baked into an
+ * error message that then appears in the trace's own first line) still has
+ * a literal prefix (AKIA/eyJ/sk-/-----BEGIN/etc.) and is still caught here —
+ * only the generic "long random-looking string" class of rejection is
+ * skipped, deliberately, for this one call site.
+ *
+ * @param {string} text
+ * @returns {boolean}
+ */
+export function containsKnownSecretPattern(text) {
+  const tokens = text.split(WHITESPACE_SPLIT_RE).filter(Boolean);
+  const despaced = text.replace(WHITESPACE_STRIP_RE, '');
+  const runs = joinedChunkRuns(tokens, { stopAtLabelWords: false });
+  return HARD_REJECT_PATTERNS.some(({ re }) => re.test(text) || runs.some(c => re.test(c)) || re.test(despaced));
+}
+
 /**
  * @param {{ title?: string, tags?: string[], body?: string }} note
  * @returns {{ rejected: boolean, reasons: string[], warnings: string[] }}