ticketlens 0.38.28 → 0.38.30

package/README.md

@@ -670,6 +670,7 @@ ticketlens switch                             # Switch between configured profil
 ticketlens config                             # Edit the active profile
 ticketlens config --profile=acme             # Edit a specific profile
 ticketlens config set aiProvider groq        # Set default AI provider (groq|openai|anthropic)
+ticketlens config set recallStrictness strict # Tune Recall-capture strictness (loose|balanced|strict)
 ticketlens profiles                           # List all configured profiles
 ticketlens ls                                 # Alias for profiles
 ticketlens profiles --plain                   # Tab-separated (scripts / pipes)

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 } from '../skills/jtb/scripts/lib/profile-resolver.mjs';
+import { deleteProfile, loadProfiles, saveCredentialKey, resolveRecallStrictnessTarget, saveProfileRecallStrictness, RECALL_STRICTNESS_LEVELS } 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 {
@@ -226,6 +226,30 @@ switch (command) {
       break;
     }
 
+    if (cmdArgs[0] === 'set' && cmdArgs[1] === 'recallStrictness') {
+      const s = createStyler({ isTTY: process.stdout.isTTY });
+      const value = cmdArgs[2];
+      const profileArgRS = cmdArgs.find(a => a.startsWith('--profile='));
+      const explicitProfileName = profileArgRS ? profileArgRS.split('=')[1] : undefined;
+      const result = resolveRecallStrictnessTarget({ value, explicitProfileName, configDir: DEFAULT_CONFIG_DIR });
+
+      if (!result.ok) {
+        if (result.reason === 'missing-value') {
+          process.stderr.write(`${s.red('✖')} Missing value.\n  Usage: ticketlens config set recallStrictness <loose|balanced|strict> [--profile=NAME]\n`);
+        } else if (result.reason === 'invalid-level') {
+          process.stderr.write(`${s.red('✖')} Unknown level "${result.value}". Valid: ${RECALL_STRICTNESS_LEVELS.join(', ')}\n`);
+        } else {
+          process.stderr.write(`${s.red('✖')} No profile resolved. Pass --profile=NAME or set a default profile first.\n`);
+        }
+        process.exitCode = 1;
+        break;
+      }
+
+      saveProfileRecallStrictness(result.profileName, result.value, DEFAULT_CONFIG_DIR);
+      process.stdout.write(`  ${s.green('✔')} Recall capture strictness set to ${s.bold(s.cyan(result.value))} for profile "${result.profileName}"\n`);
+      break;
+    }
+
     const profileArg = cmdArgs.find(a => a.startsWith('--profile='));
     const profileName = profileArg ? profileArg.split('=')[1] : undefined;
     const isInteractive = process.stdin.isTTY && process.stdout.isTTY && !process.env.CI && !cmdArgs.includes('--no-input');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.38.28",
+  "version": "0.38.30",
   "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

@@ -213,12 +213,22 @@ If the TicketBrief includes a `## Recall` section, those are the user's own save
 
 ### When to capture a note
 
+If the TicketBrief includes a `**Recall capture:**` line, calibrate against the matching level below. No such line (or `balanced`) uses the **Balanced** rule as-is — this is the default and requires no adjustment.
+
 Capture only when **all three** hold:
 
 1. **Not already written down** — not in the ticket description or comments, not already in an existing `## Recall` note shown in this brief.
 2. **Generalizes beyond this one diff** — useful to a future session on this ticket, this project, or a similar bug class. A fact only relevant to the exact change you just made doesn't qualify.
 3. **Cost real effort to discover** — required debugging, reading multiple files, trial and error, or a decision with a non-obvious rationale. Something obvious from reading the code once doesn't qualify.
 
+Point 1 and the secret/credential exclusion below are correctness checks, not judgment calls — they hold at every strictness level, no exceptions.
+
+**Balanced (default):** the three-part rule above, applied as written.
+
+**Loose (`**Recall capture:** loose`):** raise the bar on points 2 and 3 — only capture when the effort was clearly substantial (real debugging or multiple files, not "read one file twice") and the generalization is concrete, not speculative ("useful to a similar bug class" needs a plausible next occurrence, not just theoretical reuse). When genuinely borderline, skip it.
+
+**Strict (`**Recall capture:** strict`):** lower the bar on points 2 and 3 — capture when in doubt. A decision with a rationale that took even a moment of back-and-forth to land on, or a fact that plausibly helps a future session even if the connection isn't certain, qualifies. Still never capture something that fails point 1, or that's shaped like a credential/API key — the tool rejects those at save time regardless.
+
 Example that qualifies: an undocumented schema quirk found only by reading raw DDL (e.g. a table has no `name` column, it's on a related table instead). Example that doesn't: a one-off typo fix with no broader lesson.
 
 Do not capture: routine/obvious information, anything already fully covered by the ticket description or comments, or content shaped like a credential or API key — the tool rejects those outright at save time.

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

@@ -118,9 +118,17 @@ export function hasRecentCapture(cwd, now = Date.now()) {
  * tool — for note-add. Missing the MCP path here was a real bug: it made
  * the Stop hook nudge even after a note was genuinely captured via MCP,
  * since only the Bash/CLI form was ever recognized.
+ *
+ * `ticketKey` carries the FIRST matched ticket key's literal text (or
+ * `null`), so callers can resolve a profile by ticket-key prefix the same
+ * way `resolveConnection()` does — see recall-nudge-stop.mjs. First match,
+ * not last: the primary ticket a session is about is normally established
+ * early, and picking one deterministic match keeps this function decoupled
+ * from profiles.json (it stays a pure transcript reader; profile lookup
+ * and its own fallback chain belong entirely to resolveProfile()).
  */
 export function scanTranscript(transcriptPath) {
-  const result = { sawTicketKey: false, sawRecallFlag: false, sawNoteAdd: false };
+  const result = { sawTicketKey: false, sawRecallFlag: false, sawNoteAdd: false, ticketKey: null };
   let lines;
   try {
     lines = fs.readFileSync(transcriptPath, 'utf8').split('\n').filter(Boolean);
@@ -136,10 +144,22 @@ export function scanTranscript(transcriptPath) {
       continue;
     }
 
-    // Ticket-key detection stays broad (whole entry, any role) — it's only
-    // the weaker "did ticket work happen at all" signal, and a rare false
-    // positive here just means an extra harmless once-per-session check.
-    if (TICKET_KEY_RE.test(JSON.stringify(entry))) result.sawTicketKey = true;
+    // Ticket-key detection stays broad (whole entry, any role) — for
+    // sawTicketKey alone, it's only the weaker "did ticket work happen at
+    // all" signal, so a rare false positive just means an extra harmless
+    // once-per-session check. The captured ticketKey text carries a bit
+    // more weight (it also selects which profile's recallStrictness
+    // applies, see recall-nudge-stop.mjs), but the ceiling is still just
+    // "the wrong local settings value governs one Stop-hook decision" — no
+    // credentials or ticket data are read using this key, so a false
+    // positive here stays low-consequence, not narrowed further for now.
+    if (!result.ticketKey) {
+      const match = TICKET_KEY_RE.exec(JSON.stringify(entry));
+      if (match) {
+        result.sawTicketKey = true;
+        result.ticketKey = match[0];
+      }
+    }
 
     if (entry.type !== 'assistant') continue;
     const blocks = entry.message?.content;
@@ -159,3 +179,21 @@ export function scanTranscript(transcriptPath) {
 
   return result;
 }
+
+/**
+ * Decides whether the Stop hook should block, calibrated by the active
+ * profile's recallStrictness. `strict` deliberately uses the exact same
+ * trigger as `balanced` — it does not additionally bypass
+ * hasRecentCapture()'s rollover bridge or recall-nudge-stop.mjs's
+ * once-per-session cap, both correctness invariants rather than
+ * calibration knobs. Bypassing either would reintroduce a real bug
+ * (re-nagging after a genuine capture that lands just before a
+ * compaction/session_id rollover, or nagging more than once per session).
+ * Strict's actual effect on capture volume comes from SKILL.md's lowered
+ * in-session capture bar, not from this function.
+ */
+export function shouldNag({ sawTicketKey, sawRecallFlag, sawNoteAdd, recallStrictness = 'balanced' }) {
+  if (!sawTicketKey || sawNoteAdd) return false;
+  if (recallStrictness === 'loose') return sawRecallFlag; // only the broken-promise case
+  return true; // balanced and strict: ticket work with no note is enough
+}

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

@@ -16,9 +16,22 @@
  * 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.
+ *
+ * Which of the two cases above actually blocks is governed by the active
+ * profile's recallStrictness — see recall-nudge-lib.mjs's shouldNag() doc
+ * comment for the calibration and why strict doesn't widen this further.
+ *
+ * resolveProfile() below is given scanTranscript()'s matched ticket key (not
+ * null), so it resolves by ticket-key prefix the same way the brief-injection
+ * lever (resolveConnection(ticketKey, ...) in profile-resolver.mjs) does —
+ * both levers now agree on which profile's recallStrictness applies for a
+ * 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).
  */
 
-import { readStdinJson, readState, writeState, scanTranscript, hasRecentCapture, writeLastCaptureAt } from './recall-nudge-lib.mjs';
+import { readStdinJson, readState, writeState, scanTranscript, hasRecentCapture, writeLastCaptureAt, shouldNag } from './recall-nudge-lib.mjs';
+import { resolveProfile, normalizeRecallStrictness } from '../scripts/lib/profile-resolver.mjs';
 
 const input = readStdinJson();
 const sessionId = input?.session_id;
@@ -27,7 +40,7 @@ const cwd = input?.cwd ?? process.cwd();
 
 if (!sessionId || !transcriptPath) process.exit(0);
 
-const { sawTicketKey, sawRecallFlag, sawNoteAdd } = scanTranscript(transcriptPath);
+const { sawTicketKey, sawRecallFlag, sawNoteAdd, ticketKey } = scanTranscript(transcriptPath);
 
 // Refreshed on every check, independent of the once-per-session gate below —
 // a capture that happens AFTER this session already nagged once must still
@@ -37,8 +50,11 @@ if (sawNoteAdd) writeLastCaptureAt(cwd, Date.now());
 const state = readState(sessionId);
 if (state.stopChecked) process.exit(0); // already asked once this session — respect the answer
 
-if (!sawTicketKey || sawNoteAdd) {
-  process.exit(0); // no ticket work, or already captured — nothing to force
+const profile = resolveProfile(ticketKey, { cwd });
+const recallStrictness = normalizeRecallStrictness(profile?.recallStrictness);
+
+if (!shouldNag({ sawTicketKey, sawRecallFlag, sawNoteAdd, recallStrictness })) {
+  process.exit(0); // nothing this strictness level requires a capture for
 }
 
 if (hasRecentCapture(cwd)) {

package/skills/jtb/scripts/fetch-ticket.mjs

@@ -1124,7 +1124,7 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
 
       // Apply --budget pruning on the plain brief before styling (Pro only).
       // When --budget is active, always output plain text (pruning operates on unescaped chars).
-      let plainBrief = assembleBrief(cached.ticket, codeRefs, templateSections, recallNotes, recallMoreCount, gaps);
+      let plainBrief = assembleBrief(cached.ticket, codeRefs, templateSections, recallNotes, recallMoreCount, gaps, conn.recallStrictness);
       const budgetArgCached = args.find(a => a.startsWith('--budget='));
       if (budgetArgCached) {
         const budgetN = parseInt(budgetArgCached.split('=')[1], 10);
@@ -1138,7 +1138,7 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
       }
       let brief = (budgetArgCached && licensedFn('pro', configDir))
         ? plainBrief
-        : (useStyled ? styleBrief(cached.ticket, codeRefs, { styled: true, templateSections, recallNotes, recallMoreCount, gaps }) : plainBrief);
+        : (useStyled ? styleBrief(cached.ticket, codeRefs, { styled: true, templateSections, recallNotes, recallMoreCount, gaps, recallStrictness: conn.recallStrictness }) : plainBrief);
 
       if (args.includes('--handoff')) {
         const handoffResult = await applyHandoff(cached.ticket, args, opts, configDir, licensedFn, upgradeFn);
@@ -1317,7 +1317,7 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
 
   // Apply --budget pruning on the plain brief before styling (Pro only).
   // When --budget is active, always output plain text (pruning operates on unescaped chars).
-  let plainOutput = assembleBrief(ticket, codeRefs, templateSections, recallNotes, recallMoreCount, gaps);
+  let plainOutput = assembleBrief(ticket, codeRefs, templateSections, recallNotes, recallMoreCount, gaps, conn.recallStrictness);
   const budgetArg = args.find(a => a.startsWith('--budget='));
   if (budgetArg) {
     const budgetN = parseInt(budgetArg.split('=')[1], 10);
@@ -1331,7 +1331,7 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
   }
   let output = (budgetArg && licensedFn('pro', configDir))
     ? plainOutput
-    : (useStyled ? styleBrief(ticket, codeRefs, { styled: true, templateSections, recallNotes, recallMoreCount, gaps }) : plainOutput);
+    : (useStyled ? styleBrief(ticket, codeRefs, { styled: true, templateSections, recallNotes, recallMoreCount, gaps, recallStrictness: conn.recallStrictness }) : plainOutput);
 
   if (args.includes('--handoff')) {
     const handoffResult = await applyHandoff(ticket, args, opts, configDir, licensedFn, upgradeFn);

package/skills/jtb/scripts/lib/brief-assembler.mjs

@@ -6,7 +6,7 @@ import { formatTable } from './table-formatter.mjs';
 import { formatSize } from './attachment-downloader.mjs';
 import { timeAgo, truncate, stripCr, escapeLeadingHeading } from './config.mjs';
 
-export function assembleBrief(ticket, codeRefs = null, templateSections = null, recallNotes = null, recallMoreCount = 0, gaps = null) {
+export function assembleBrief(ticket, codeRefs = null, templateSections = null, recallNotes = null, recallMoreCount = 0, gaps = null, recallStrictness = 'balanced') {
   const s = templateSections;
   const sections = [];
   sections.push(`# ${ticket.key}: ${ticket.summary}`);
@@ -17,6 +17,10 @@ export function assembleBrief(ticket, codeRefs = null, templateSections = null,
   if (ticket.updated) meta.push(`**Updated:** ${ticket.updated.split('T')[0]}`);
   sections.push(meta.join(' | '));
 
+  if (recallStrictness !== 'balanced') {
+    sections.push(`**Recall capture:** ${recallStrictness}`);
+  }
+
   if (ticket.description && (s === null || s.description !== false)) {
     sections.push(`## Description\n\n${stripCr(ticket.description)}`);
   }

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

@@ -937,6 +937,7 @@ export function printConfigHelp({ stream = process.stdout } = {}) {
     '',
     `  ${s.bold(s.brand('ticketlens'))} ${s.bold('config')} ${s.dim('[--profile=NAME]')}`,
     `  ${s.bold(s.brand('ticketlens'))} ${s.bold('config set aiProvider')} ${s.dim('<anthropic|openai|groq>')}`,
+    `  ${s.bold(s.brand('ticketlens'))} ${s.bold('config set recallStrictness')} ${s.dim('<loose|balanced|strict>')}`,
     '',
     `  Edit settings for an existing profile using an interactive wizard.`,
     `  Without ${s.cyan('--profile')}, edits the currently active profile.`,
@@ -951,6 +952,11 @@ export function printConfigHelp({ stream = process.stdout } = {}) {
     `                            ${s.dim('openai')}    = GPT-4o mini ${s.dim('(paid)')}`,
     `                            ${s.dim('groq')}      = Llama 3.1 ${s.dim('(free tier)')}`,
     '',
+    `    ${s.brand('set recallStrictness')} ${s.dim('<LEVEL>')}   Tune Recall-capture strictness`,
+    `                            ${s.dim('loose')}    = capture only strong, clear signals`,
+    `                            ${s.dim('balanced')} = today's default behavior`,
+    `                            ${s.dim('strict')}   = capture more liberally, when in doubt`,
+    '',
     `  ${s.bold('OPTIONS')}`,
     '',
     `    ${s.brand('--profile')}=${s.dim('NAME')}   Profile to configure`,
@@ -962,6 +968,7 @@ export function printConfigHelp({ stream = process.stdout } = {}) {
     `    ${s.dim('$')} ticketlens config --profile=work`,
     `    ${s.dim('$')} ticketlens config set aiProvider groq`,
     `    ${s.dim('$')} ticketlens config set aiProvider anthropic`,
+    `    ${s.dim('$')} ticketlens config set recallStrictness strict`,
     '',
   ];
   stream.write(lines.join('\n') + '\n');

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

@@ -100,6 +100,33 @@ export function saveProfile(name, profileData, credData, configDir = DEFAULT_CON
   invalidateProfilesCache(configDir);
 }
 
+export const RECALL_STRICTNESS_LEVELS = ['loose', 'balanced', 'strict'];
+export const DEFAULT_RECALL_STRICTNESS = 'balanced';
+
+export function normalizeRecallStrictness(value) {
+  return RECALL_STRICTNESS_LEVELS.includes(value) ? value : DEFAULT_RECALL_STRICTNESS;
+}
+
+export function saveProfileRecallStrictness(name, level, configDir = DEFAULT_CONFIG_DIR) {
+  const config = loadProfiles(configDir) || { profiles: {} };
+  if (!config.profiles[name]) throw new Error(`Unknown profile "${name}"`);
+  config.profiles[name] = { ...config.profiles[name], recallStrictness: normalizeRecallStrictness(level) };
+  writeFileSync(join(configDir, 'profiles.json'), JSON.stringify(config, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
+  invalidateProfilesCache(configDir);
+}
+
+export function resolveRecallStrictnessTarget({ value, explicitProfileName, configDir = DEFAULT_CONFIG_DIR } = {}) {
+  if (!value) return { ok: false, reason: 'missing-value' };
+  if (!RECALL_STRICTNESS_LEVELS.includes(value)) return { ok: false, reason: 'invalid-level', value };
+
+  const profilesConfig = loadProfiles(configDir);
+  const targetProfile = explicitProfileName ?? profilesConfig?.default;
+  if (!targetProfile || !profilesConfig?.profiles?.[targetProfile]) {
+    return { ok: false, reason: 'no-profile' };
+  }
+  return { ok: true, profileName: targetProfile, value };
+}
+
 // recallTeamId lives in credentials.json (not profiles.json) — it's a
 // sensitive association (which specific Console team a specific local
 // profile/folder routes Recall notes to), not the non-secret profile shape
@@ -298,6 +325,7 @@ export function resolveConnection(ticketKey, opts = {}) {
       staleRule: profile.staleRule ?? null,
       sortBy: profile.sortBy ?? null,
       allowPrivateIp: profile.allowPrivateIp || false,
+      recallStrictness: normalizeRecallStrictness(profile.recallStrictness),
       source: 'profile',
       profileName: profile.name,
     };

package/skills/jtb/scripts/lib/styled-assembler.mjs

@@ -133,7 +133,7 @@ export function styleRecallResults(digests, opts = {}) {
 }
 
 export function styleBrief(ticket, codeRefs = null, opts = {}) {
-  const { styled = true, templateSections = null, recallNotes = null, recallMoreCount = 0, gaps = null } = opts;
+  const { styled = true, templateSections = null, recallNotes = null, recallMoreCount = 0, gaps = null, recallStrictness = 'balanced' } = opts;
   const ts = templateSections;
   const s = createStyler({ forceColor: styled, noColor: !styled });
 
@@ -154,6 +154,10 @@ export function styleBrief(ticket, codeRefs = null, opts = {}) {
   if (ticket.updated) meta.push(`${s.dim('Updated:')} ${ticket.updated.split('T')[0]}`);
   sections.push(meta.join(s.dim('  ·  ')));
 
+  if (recallStrictness !== 'balanced') {
+    sections.push(`${s.dim('Recall capture:')} ${recallStrictness}`);
+  }
+
   // Description
   if (ticket.description && (ts === null || ts.description !== false)) {
     sections.push(`${s.bold(s.brand('Description'))}\n${s.dim('─'.repeat(divWidth()))}\n${stripCr(ticket.description)}`);