ticketlens 0.38.51 → 0.38.53

package/README.md

@@ -458,6 +458,8 @@ Every note is scanned before saving — anything shaped like a real secret (API
 
 **Recall capture strictness:** your team manager can also set a team default at `console/admin/recall` (Settings tab). It only applies if you've never run `ticketlens config set recallStrictness` yourself — your own explicit choice always wins over the team default. `ticketlens recall settings` also reports the strictness currently in effect and where it came from.
 
+**Autonomous background capture (Pro+):** inside a Claude Code session using the jtb skill, TicketLens can also judge and save a note on its own, after the session ends — no `note add` call, no user action, reusing your existing `ticketlens login` (no new key or setup). It only runs when real fetch and real mutating ticket work happened that session, applies the same capture criteria as a Claude-triggered note, and goes through the identical license/secret-scan/vault/team-sync pipeline. Throttled to at most once per project directory within a short window, so a long session doesn't trigger it repeatedly.
+
 **Removing a note:** `ticketlens note delete --id="..." [--ticket=KEY]` removes a note from your local vault. Local only — if it was already pushed to a team, teammates who pulled it keep their copy; deleting it there too is a manager action from the Console (Admin > Recall).
 
 **Any MCP-capable AI harness:** `ticketlens mcp` starts a stdio [MCP](https://modelcontextprotocol.io) server exposing `fetch`, `triage`, `compliance`, `review`, `standup`, `pr`, `stats`, `issue_types`, `history`, `collisions`, `ledger`, `doctor`, `recall_add`, `recall_update`, `recall_delete`, `recall_search`, `ticket_comment`, `ticket_transition`, `ticket_assign`, `ticket_duplicates`, `ticket_link`, `ticket_update`, and `ticket_create` as native tools — every CLI action now has an MCP tool, so any MCP-compatible AI assistant, not just Claude Code, can call them directly instead of constructing a shell command. It's a thin adapter over the exact same code as the CLI commands above — same license gate per tool, same secret scan/local vault/tracker writes, same team sync — nothing is reimplemented. `fetch`, `doctor`, and `standup` are Free; `triage`'s base scan is Free with some options gated Pro/Team, same as the CLI (`ticketlens triage --help`); `compliance` and `pr` are Free, sharing a 3-checks/month cap on their requirements-coverage section, Pro unlimited; `compliance` additionally accepts `consensus: true` (Pro) to replace the local deterministic matcher with a multi-agent AI review, run server-side against a "consensus" role configured at Console > Admin > AI Roles (2+ providers from the team's shared pool), and always implies `--yes` under MCP since there's no TTY for the cost-confirmation prompt; `review` is Free for branch/files/ticket context, with its coverage/focus section requiring Pro as a plain license check — it does not draw from that same monthly counter; `stats` is Free with a 7-day lookback cap, Pro extends it to 30 days, same split as the CLI (`ticketlens stats --help`); `issue_types` is Free and Jira-only — pre-fetches and caches a profile's real creatable projects and issue types ahead of a `ticket_create` attempt, sharing its cache with that tool's own reactive enrichment; Linear/GitHub profiles get a clear "not available" instead of an empty result; `history` reads local triage history only (zero network) and requires Pro; `collisions` requires `ticketlens login` (Console access) plus a Team license; `ledger` exports the local, signed compliance audit trail (zero network) and requires Pro; every other tool needs Pro. `recall_update` overwrites an existing Recall note's body — internal plumbing for the note quality loop, not typically called directly; its `attachments` array appends new files to whatever the note already has, same as `recall_add`'s, never replacing existing ones. `recall_delete` is destructive and local-vault-only — requires `confirm: true` alongside `id` to actually execute; there is no interactive y/N prompt under MCP (no real terminal to prompt against), so omitting it always fails rather than silently blocking. Point your harness's MCP config at it: `{ "command": "ticketlens", "args": ["mcp"] }` — or run `ticketlens mcp install` in a project to write that entry into its `.mcp.json` for you (creates the file if it doesn't exist, merges in if it does — never touches any other entry already there; `--dry-run` to preview first).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.38.51",
+  "version": "0.38.53",
   "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.43.1 -->
+<!-- jtb-skill-version: 0.43.2 -->
 ---
 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.
@@ -406,6 +406,12 @@ This never calls any external API or bills any tokens beyond the session you alr
 
 **Known limitation:** `note patch` only updates the local vault copy. If `note add` already pushed the original draft to a team (Team Recall enabled), a later refinement from this loop is *not* re-pushed — teammates who already pulled the note keep the original draft until this is addressed in a future iteration.
 
+### Autonomous background capture (Pro+, independent of you)
+
+TicketLens also judges and captures on its own, in the background, after this session ends — a second, independent path alongside everything above. It reuses your existing `ticketlens login` token (no new key, no new setup) and applies the same three-part rule this section already describes. On a `capture` decision it saves through the exact same gate as a normal `note add` — license check, secret scan, structural/word-cap check, vault write, team push.
+
+This means a note can appear in a future brief that you never called `note add` for — that's expected, not a bug. It also means you should keep capturing proactively as this section instructs: the background path is a safety net for what gets missed, not a reason to skip capturing something you've already confirmed is worth saving. It only runs when a real fetch plus real mutating ticket work happened this session (a pure read-only lookup produces nothing to capture either way) and is throttled to at most once per working directory within a short window, so it won't re-fire on every turn of a long session.
+
 ### Privacy
 Recall notes are stored locally at `~/.ticketlens/recall/`. On a Pro account with no Team Recall entitlement, they never leave the machine — no network calls (Free tier can't use Recall at all). On Team/Enterprise, Recall's team sync is included by default (Pro accounts can get it too, as a separate add-on); notes also sync to the team's shared pool in the background so teammates can benefit from them too, and a team manager reviews and verifies each incoming note before it's marked trusted. If a team push fails for a transient reason (network error, timeout, 5xx), the note is queued locally and retried automatically in the background, or on demand with `ticketlens recall sync` [Team+] — a session-expired or not-entitled push is never queued, since retrying those can't succeed without the user acting first.
 

package/skills/jtb/hooks/recall-auto-capture.mjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+/**
+ * Autonomous background Recall capture (backlog #24, 6th report — combined
+ * with the sawMutatingAction narrowing in recall-nudge-lib.mjs's shouldNag).
+ *
+ * Spawned detached+unref'd by recall-nudge-stop.mjs on every Stop check —
+ * independent of, and unable to see the outcome of, that hook's own
+ * blocking-nag decision. TL judges and captures here, not Claude: reads the
+ * session's own transcript, asks the backend's fixed capture-judgment
+ * prompt (same 3-part SKILL.md rule Claude is asked to apply in-session),
+ * and on a `capture` decision saves the note itself via the existing
+ * `runNoteAdd()` pipeline — same Pro-gate, secret-scan, structural-check,
+ * vault-write, team-push as a human- or Claude-typed `note add`.
+ *
+ * Pro+ / logged-in only, cloud mode only (uses the existing CLI login
+ * token, never a personally-configured API key — the whole point of this
+ * path is zero new user configuration). Free tier / logged-out silently
+ * no-ops; the CLI/MCP surface a user actually sees is entirely unaffected.
+ *
+ * Best-effort throughout, matching every other file in this hook pair:
+ * nothing here is allowed to throw past runAutoCapture(), write to real
+ * stdout/stderr (nothing is watching a detached background process), or
+ * take any action visible to the user beyond the note itself landing in
+ * their vault. Every outcome (skip/capture/error) is appended to a local,
+ * user-private debug log so a silent miss stays diagnosable.
+ */
+
+import { appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { isLicensed } from '../scripts/lib/license.mjs';
+import { readCliToken } from '../scripts/lib/cli-auth.mjs';
+import { buildCaptureExcerpt, privateTmpDir } from './recall-nudge-lib.mjs';
+import { autoCapture } from '../scripts/lib/summarizer.mjs';
+import { runNoteAdd } from '../scripts/lib/note-command.mjs';
+import { DEFAULT_CONFIG_DIR } from '../scripts/lib/config.mjs';
+
+/** Buffers stream.write() calls instead of touching a real stream — same shape mcp-server.mjs's own capturingStream() uses, this process has no real stdout/stderr worth writing to. */
+function capturingStream() {
+  const parts = [];
+  return { write(s) { parts.push(s); return true; }, get text() { return parts.join(''); } };
+}
+
+function logLine(message) {
+  try {
+    const line = `${new Date().toISOString()} ${message}\n`;
+    appendFileSync(join(privateTmpDir(), 'auto-capture.log'), line);
+  } catch { /* best-effort — losing a debug log line is not worth failing over */ }
+}
+
+/**
+ * @param {object} opts
+ * @param {string} opts.transcriptPath
+ * @param {string} [opts.ticketKey]
+ * @param {string} [opts.configDir]
+ * @returns {Promise<{outcome: 'skipped'|'captured'|'not-written'|'error', reason?: string, title?: string, error?: string}>}
+ */
+export async function runAutoCapture({
+  transcriptPath,
+  ticketKey,
+  configDir = DEFAULT_CONFIG_DIR,
+  isLicensedFn = isLicensed,
+  readCliTokenFn = readCliToken,
+  buildCaptureExcerptFn = buildCaptureExcerpt,
+  autoCaptureFn = autoCapture,
+  runNoteAddFn = runNoteAdd,
+} = {}) {
+  if (!isLicensedFn('pro', configDir)) {
+    logLine('skipped: not licensed');
+    return { outcome: 'skipped', reason: 'not licensed' };
+  }
+
+  const cliToken = readCliTokenFn(configDir);
+  if (!cliToken) {
+    logLine('skipped: not logged in');
+    return { outcome: 'skipped', reason: 'not logged in' };
+  }
+
+  const excerpt = buildCaptureExcerptFn(transcriptPath);
+  if (!excerpt) {
+    logLine('skipped: empty excerpt');
+    return { outcome: 'skipped', reason: 'empty excerpt' };
+  }
+
+  let result;
+  try {
+    result = await autoCaptureFn({ excerpt, ticketKey, cliToken });
+  } catch (err) {
+    logLine(`error: ${err.message}`);
+    return { outcome: 'error', error: err.message };
+  }
+
+  if (result.decision !== 'capture') {
+    logLine('skipped: decision=skip');
+    return { outcome: 'skipped', reason: 'decision=skip' };
+  }
+
+  const cmdArgs = [`--title=${result.title}`];
+  if (ticketKey) cmdArgs.push(`--ticket=${ticketKey}`);
+  // Strip any comma an AI-produced tag might contain — runNoteAdd re-splits
+  // --tags on ',', so an un-sanitized tag would silently fork into two.
+  const cleanTags = (result.tags ?? []).map(t => String(t).replace(/,/g, '')).filter(Boolean);
+  if (cleanTags.length > 0) cmdArgs.push(`--tags=${cleanTags.join(',')}`);
+
+  const { written } = await runNoteAddFn(cmdArgs, {
+    configDir,
+    stream: capturingStream(),
+    readStdin: () => Promise.resolve(result.body ?? ''),
+  });
+
+  logLine(written ? `captured: ${result.title}` : `not-written: ${result.title}`);
+  return written ? { outcome: 'captured', title: result.title } : { outcome: 'not-written', title: result.title };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const [, , transcriptPath, ticketKeyArg] = process.argv;
+  runAutoCapture({ transcriptPath, ticketKey: ticketKeyArg || undefined }).catch(() => { /* never escape — nothing is watching this process */ });
+}

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

@@ -31,6 +31,15 @@ export const NOTE_ADD_MCP_RE = /^mcp__.+__recall_add$/;
 // 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/;
 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
+// the immediate next positional arg, same shape FETCH_RE already assumes),
+// across the ticketlens/tl/jtb invocation forms. Distinguishes real ticket
+// work from a read-only fetch — backlog #24's 6th report: a pure multi-
+// ticket status listing (fetch only, no mutation) still nagged, even though
+// nothing about it could ever satisfy SKILL.md's own capture rule.
+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/;
+export const MUTATING_ACTION_MCP_RE = /^mcp__.+__(ticket_comment|ticket_transition|ticket_assign|ticket_update)$/;
 
 export function readStdinJson() {
   const raw = fs.readFileSync(0, 'utf8');
@@ -79,7 +88,7 @@ export const CAPTURE_FRESHNESS_MS = 2 * 60 * 60 * 1000;
  * predictable path directly in shared tmp could be pre-planted by another
  * local user on a shared box.
  */
-function privateTmpDir() {
+export function privateTmpDir() {
   const owner = typeof process.getuid === 'function' ? process.getuid() : os.userInfo().username;
   const dir = path.join(os.tmpdir(), `ticketlens-recall-nudge-${owner}`);
   try {
@@ -156,6 +165,42 @@ export function hasRecentNag(cwd, now = Date.now()) {
   return lastNagAt > 0 && (now - lastNagAt) < CAPTURE_FRESHNESS_MS;
 }
 
+/**
+ * Cross-session/cross-turn AUTO-CAPTURE-ATTEMPT marker — same shape as
+ * lastNagPath/hasRecentNag above, but throttles the autonomous background
+ * spawn (recall-auto-capture.mjs) itself, independent of the sync nag below.
+ * Needed because Stop fires on every turn-end, not once per session (see
+ * recall-nudge-stop.mjs's own doc comment) — without this, a single
+ * multi-turn session would spawn the background judge, and its AI-provider
+ * spend, once per turn (code review, 2026-09-15). Written optimistically at
+ * spawn time, before the child's own outcome is known — a failed/skipped
+ * attempt still counts against the window, same accepted trade-off as
+ * hasRecentNag's own doc comment above.
+ */
+export function lastAutoCaptureAttemptPath(cwd) {
+  const hash = crypto.createHash('sha256').update(cwd || 'unknown').digest('hex').slice(0, 16);
+  return path.join(privateTmpDir(), `lastautocapture-${hash}.json`);
+}
+
+export function readLastAutoCaptureAttemptAt(cwd) {
+  try {
+    return JSON.parse(fs.readFileSync(lastAutoCaptureAttemptPath(cwd), 'utf8')).lastAttemptAt ?? 0;
+  } catch {
+    return 0;
+  }
+}
+
+export function writeLastAutoCaptureAttemptAt(cwd, timestamp) {
+  try {
+    fs.writeFileSync(lastAutoCaptureAttemptPath(cwd), JSON.stringify({ lastAttemptAt: timestamp }));
+  } catch { /* best-effort — losing this marker only costs one extra spawn next window */ }
+}
+
+export function hasRecentAutoCaptureAttempt(cwd, now = Date.now()) {
+  const lastAttemptAt = readLastAutoCaptureAttemptAt(cwd);
+  return lastAttemptAt > 0 && (now - lastAttemptAt) < CAPTURE_FRESHNESS_MS;
+}
+
 /**
  * Reads the transcript (JSONL) and returns simple booleans about what
  * happened this session. Best-effort: any read/parse failure returns all
@@ -195,7 +240,7 @@ export function hasRecentNag(cwd, now = Date.now()) {
  * jtb's fetch was used," so the hook now checks the same thing it backstops.
  */
 export function scanTranscript(transcriptPath) {
-  const result = { sawTicketKey: false, sawRecallFlag: false, sawNoteAdd: false, sawFetch: false, ticketKey: null };
+  const result = { sawTicketKey: false, sawRecallFlag: false, sawNoteAdd: false, sawFetch: false, sawMutatingAction: false, ticketKey: null };
   let lines;
   try {
     lines = fs.readFileSync(transcriptPath, 'utf8').split('\n').filter(Boolean);
@@ -244,6 +289,11 @@ export function scanTranscript(transcriptPath) {
         const isCliFetch = block.name === 'Bash' && FETCH_RE.test(block.input?.command ?? '');
         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 isMcpMutation = MUTATING_ACTION_MCP_RE.test(block.name ?? '');
+        const isCodeEdit = block.name === 'Edit' || block.name === 'Write';
+        if (isCliMutation || isMcpMutation || isCodeEdit) result.sawMutatingAction = true;
       }
     }
   }
@@ -270,9 +320,64 @@ export function scanTranscript(transcriptPath) {
  * matching SKILL.md's own capture-guidance scope exactly ("unconditionally
  * whenever jtb's fetch was used"), instead of firing on any incidental
  * ticket-key-shaped string.
+ *
+ * Also gated on `sawMutatingAction` (backlog #24, 6th report) — a pure
+ * read-only session (multi-ticket status listing, a report, a lookup) can
+ * never satisfy SKILL.md's own 3-part capture rule ("generalizes beyond
+ * this diff", "cost real effort to discover") no matter how many fetches
+ * ran, so gating on `sawFetch` alone false-positived on exactly that shape.
+ * Applies uniformly across all three strictness levels, same blanket
+ * treatment as the `sawFetch` gate above — a session with zero mutation
+ * has nothing any strictness level would ever ask to capture.
  */
-export function shouldNag({ sawFetch, sawRecallFlag, sawNoteAdd, recallStrictness = 'balanced' }) {
+export function shouldNag({ sawFetch, sawMutatingAction, sawRecallFlag, sawNoteAdd, recallStrictness = 'balanced' }) {
   if (!sawFetch || sawNoteAdd) return false;
+  if (!sawMutatingAction) return false;
   if (recallStrictness === 'loose') return sawRecallFlag; // only the broken-promise case
   return true; // balanced and strict: a fetch with no note is enough
 }
+
+/**
+ * Builds a bounded excerpt of this session's assistant-authored text, for
+ * the autonomous background auto-capture path (recall-auto-capture.mjs) to
+ * hand to the server-side capture-judgment prompt — same assistant-text-only
+ * filter scanTranscript() already uses for sawRecallFlag, so this can never
+ * leak a user's own pasted content (secrets, unrelated files) that only
+ * ever appeared in a user-role transcript entry.
+ *
+ * Capped at 8000 chars, truncated from the START (keeps the END of the
+ * session) — the final synthesized insight is far more likely to be near
+ * the end of a session than the beginning, and an unbounded excerpt risks
+ * an oversized request body for no benefit.
+ *
+ * Best-effort: any read/parse failure, or a session with no assistant text
+ * at all, returns '' rather than throwing — this runs in a detached
+ * background process with nothing watching for an unhandled rejection.
+ */
+export function buildCaptureExcerpt(transcriptPath) {
+  let lines;
+  try {
+    lines = fs.readFileSync(transcriptPath, 'utf8').split('\n').filter(Boolean);
+  } catch {
+    return '';
+  }
+
+  const texts = [];
+  for (const line of lines) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type !== 'assistant') continue;
+    const blocks = entry.message?.content;
+    if (!Array.isArray(blocks)) continue;
+    for (const block of blocks) {
+      if (block.type === 'text' && block.text) texts.push(block.text);
+    }
+  }
+
+  const joined = texts.join('\n\n');
+  return joined.length > 8000 ? joined.slice(-8000) : joined;
+}

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

@@ -40,11 +40,42 @@
  * multi-profile user. When no ticket key was seen, or it matches no profile's
  * ticketPrefixes, this falls through to cwd/projectPaths then the default
  * profile, same as before (backlog #12, design spec §6).
+ *
+ * Autonomous background auto-capture (D1): independent of the blocking nag
+ * logic below, a Stop check also fire-and-forgets a detached child
+ * (recall-auto-capture.mjs) that judges and captures without any Claude/user
+ * involvement — Pro+ only, silently no-ops otherwise (see that file). Spawned
+ * detached+unref'd so it survives this process exiting and never counts
+ * against this hook's own 5s timeout (hooks-setup.mjs). The two mechanisms
+ * can't see each other's outcome (the child hasn't run yet when the sync nag
+ * decision below is made) — an occasional double-fire (nag fires, then the
+ * background capture lands moments later anyway) is a known, accepted
+ * overlap, not a bug: suppressing the sync nag whenever a background attempt
+ * is merely *made* would remove the only safety net if that attempt silently
+ * fails (network down, no AI provider configured, malformed response).
+ *
+ * Gated on isLicensed('pro') + a real cliToken, checked HERE (cheap, local,
+ * synchronous) rather than only inside the child — avoids forking a Node
+ * process for every Stop check for the majority free-tier/logged-out
+ * population (code review, 2026-09-15). Also gated on
+ * !hasRecentAutoCaptureAttempt(cwd): Stop fires on every turn-end, not once
+ * per session, so without this a single multi-turn session would spawn the
+ * background judge — and its AI-provider spend — once per turn (same code
+ * review). The spawn's own `cwd` option is set to the real session cwd
+ * (distinct from this hook process's own cwd) so runNoteAdd()'s internal
+ * profile/team resolution — which always reads process.cwd(), no override
+ * param exists — resolves correctly inside the child, not just when the two
+ * happen to coincide.
  */
 
-import { readStdinJson, readState, writeState, scanTranscript, hasRecentCapture, writeLastCaptureAt, hasRecentNag, writeLastNagAt, shouldNag } from './recall-nudge-lib.mjs';
+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 { resolveProfile, resolveEffectiveRecallStrictness } from '../scripts/lib/profile-resolver.mjs';
 import { readCliToken } from '../scripts/lib/cli-auth.mjs';
+import { isLicensed } from '../scripts/lib/license.mjs';
+
+const AUTO_CAPTURE_SCRIPT = fileURLToPath(new URL('./recall-auto-capture.mjs', import.meta.url));
 
 const input = readStdinJson();
 const sessionId = input?.session_id;
@@ -53,7 +84,20 @@ const cwd = input?.cwd ?? process.cwd();
 
 if (!sessionId || !transcriptPath) process.exit(0);
 
-const { sawFetch, sawRecallFlag, sawNoteAdd, ticketKey } = scanTranscript(transcriptPath);
+const { sawFetch, sawMutatingAction, sawRecallFlag, sawNoteAdd, ticketKey } = scanTranscript(transcriptPath);
+const cliToken = readCliToken();
+
+if (isLicensed('pro') && cliToken && !hasRecentAutoCaptureAttempt(cwd)) {
+  try {
+    writeLastAutoCaptureAttemptAt(cwd, Date.now());
+    const child = spawn(process.execPath, [AUTO_CAPTURE_SCRIPT, transcriptPath, ticketKey ?? ''], {
+      cwd,
+      detached: true,
+      stdio: 'ignore',
+    });
+    child.unref();
+  } catch { /* best-effort — never block Stop over this */ }
+}
 
 // Refreshed on every check, independent of the once-per-session gate below —
 // a capture that happens AFTER this session already nagged once must still
@@ -64,10 +108,9 @@ const state = readState(sessionId);
 if (state.stopChecked) process.exit(0); // already asked once this session — respect the answer
 
 const profile = resolveProfile(ticketKey, { cwd });
-const cliToken = readCliToken();
 const recallStrictness = resolveEffectiveRecallStrictness({ profile, cliToken });
 
-if (!shouldNag({ sawFetch, sawRecallFlag, sawNoteAdd, recallStrictness })) {
+if (!shouldNag({ sawFetch, sawMutatingAction, sawRecallFlag, sawNoteAdd, recallStrictness })) {
   process.exit(0); // nothing this strictness level requires a capture for
 }
 

package/skills/jtb/scripts/lib/license.mjs

@@ -130,17 +130,23 @@ export function showUpgradePrompt(requiredTier, featureFlag, { stream = process.
 const LEMONSQUEEZY_ACTIVATE_URL = 'https://api.lemonsqueezy.com/v1/licenses/activate';
 const LEMONSQUEEZY_VALIDATE_URL = 'https://api.lemonsqueezy.com/v1/licenses/validate';
 
-function resolveLicenseUrl(action, fallback) {
+// TL- keys are issued by TicketLens itself (LicenseIssuanceService::KEY_PREFIX), never by
+// LemonSqueezy — sending one to the LemonSqueezy fallback always fails, confusingly (backlog #30).
+const TL_ISSUED_KEY_RE = /^TL-/i;
+
+function resolveLicenseUrl(action, fallback, key) {
   const base = process.env.TICKETLENS_API_URL;
-  return base ? `${base.replace(/\/$/, '')}/v1/licenses/${action}` : fallback;
+  if (base) return `${base.replace(/\/$/, '')}/v1/licenses/${action}`;
+  if (TL_ISSUED_KEY_RE.test(key)) return null;
+  return fallback;
 }
 
-function resolveActivateUrl() {
-  return resolveLicenseUrl('activate', LEMONSQUEEZY_ACTIVATE_URL);
+function resolveActivateUrl(key) {
+  return resolveLicenseUrl('activate', LEMONSQUEEZY_ACTIVATE_URL, key);
 }
 
-function resolveValidateUrl() {
-  return resolveLicenseUrl('validate', LEMONSQUEEZY_VALIDATE_URL);
+function resolveValidateUrl(key) {
+  return resolveLicenseUrl('validate', LEMONSQUEEZY_VALIDATE_URL, key);
 }
 
 function extractTier(meta) {
@@ -154,8 +160,16 @@ export async function activateLicense(key, opts = {}) {
   const { configDir = DEFAULT_CONFIG_DIR, fetcher = globalThis.fetch, instanceName } = opts;
   const instance = instanceName || os.hostname();
 
+  const url = resolveActivateUrl(key);
+  if (url === null) {
+    return {
+      success: false,
+      error: 'TICKETLENS_API_URL is not set — required to activate a TicketLens-issued (TL-) license key. Set it to your TicketLens backend URL and try again.',
+    };
+  }
+
   try {
-    const res = await fetcher(resolveActivateUrl(), {
+    const res = await fetcher(url, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
       body: JSON.stringify({ license_key: key, instance_name: instance }),
@@ -194,8 +208,13 @@ export async function revalidateLicense(opts = {}) {
 
   const instance = instanceName || os.hostname();
 
+  const url = resolveValidateUrl(license.key);
+  if (url === null) {
+    return { success: true, tier: license.tier, cached: true };
+  }
+
   try {
-    const res = await fetcher(resolveValidateUrl(), {
+    const res = await fetcher(url, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
       body: JSON.stringify({ license_key: license.key, instance_name: instance }),

package/skills/jtb/scripts/lib/summarizer.mjs

@@ -162,3 +162,52 @@ async function cloud({ brief, cliToken, fetcher, timeoutMs }) {
   const data = await res.json();
   return data.summary;
 }
+
+/**
+ * Autonomous Recall-capture judgment (backlog #24, D1) — cloud-mode only, no
+ * BYOK equivalent: the whole point is using the account's existing login
+ * token, never a personally-configured API key. Server owns the judgment
+ * prompt (mirrors SKILL.md's 3-part capture rule) — this function never
+ * sends one, only the raw transcript excerpt, so there's no client-supplied-
+ * prompt injection surface on this endpoint.
+ *
+ * Unlike summarize()/cloud() above, the return value is the raw parsed
+ * `{decision, title?, body?, tags?}` object, not unwrapped to a single
+ * string — the caller (recall-auto-capture.mjs) needs the structured shape
+ * to either no-op (`skip`) or feed straight into runNoteAdd (`capture`).
+ *
+ * @param {object} opts
+ * @param {string} opts.excerpt - bounded assistant-text excerpt (buildCaptureExcerpt)
+ * @param {string} [opts.ticketKey]
+ * @param {string} opts.cliToken - required, cloud-mode only
+ * @param {Function} [opts.fetcher]
+ * @param {number} [opts.timeoutMs]
+ * @returns {Promise<{decision: 'capture'|'skip', title?: string, body?: string, tags?: string[]}>}
+ */
+export async function autoCapture({ excerpt, ticketKey, cliToken, fetcher = globalThis.fetch, timeoutMs = 30_000 }) {
+  if (!cliToken) throw new Error('Not logged in. Run `ticketlens login` first.');
+  const payload = { transcript_excerpt: excerpt };
+  if (ticketKey) payload.ticket_key = ticketKey;
+
+  const res = await fetcher(`${apiBase()}/v1/recall/auto-capture`, {
+    method: 'POST',
+    signal: AbortSignal.timeout(timeoutMs),
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${cliToken}`,
+    },
+    body: JSON.stringify(payload),
+  });
+
+  if (!res.ok) {
+    let detail = '';
+    try { detail = (await res.json()).error ?? ''; } catch {}
+    if (!detail && res.status === 503) detail = 'No AI provider configured on the backend.';
+    if (!detail && res.status === 500) detail = 'Server error (the backend may need `php artisan migrate` after a recent update)';
+    const err = new Error(detail || `TicketLens API error ${res.status}`);
+    err.status = res.status;
+    throw err;
+  }
+
+  return res.json();
+}