ticketlens 0.38.27 → 0.38.29

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.27",
+  "version": "0.38.29",
   "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

@@ -159,3 +159,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,23 @@
  * 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.
+ *
+ * Known limitation: resolveProfile(null, { cwd }) below has no ticket key to
+ * match against, so it falls through to cwd/projectPaths then the default
+ * profile — unlike the brief-injection lever (resolveConnection(ticketKey, ...)
+ * in profile-resolver.mjs), which resolves by ticket-key prefix when one is
+ * available. For a multi-profile user these two levers can genuinely resolve
+ * different profiles in the same session, so the recallStrictness setting
+ * doesn't reliably reweight both together outside the single-profile case.
+ * Not fixed here — see design spec §6 for the follow-up.
  */
 
-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;
@@ -37,8 +51,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(null, { 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/api-utils.mjs

@@ -3,7 +3,7 @@
  * Centralised here to avoid triplicating the regex and warning logic.
  */
 
-export const DEFAULT_API_BASE = 'http://api.ticketlens.test';
+export const DEFAULT_API_BASE = 'https://api.ticketlens.app';
 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/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/cli-auth.mjs

@@ -39,27 +39,44 @@ export function readCliToken(configDir = DEFAULT_CONFIG_DIR) {
 // Lets team-invited members get Pro-equivalent CLI access without a personal
 // TL- key, mirroring what the manager already pays for.
 //
-// Signed with a machine-bound HMAC so `tier`/`syncedAt` can't be hand-edited in
-// the file to escalate or extend entitlement. A missing or invalid signature is
-// treated as no tier at all (falls back to free) rather than trusted — self-heals
-// on the next `tl login`/`tl sync`, both of which re-write and re-sign it. A file
-// with no `syncedAt` (written before this grace-period check existed) is rejected
-// outright for the same reason, rather than treated as permanently fresh.
+// Signed with a machine-bound HMAC so `tier`/`syncedAt`/`freshMark` can't be
+// hand-edited in the file to escalate or extend entitlement. A missing or
+// invalid signature is treated as no tier at all (falls back to free) rather
+// than trusted — self-heals on the next `tl login`/`tl sync`, both of which
+// re-write and re-sign it. A file with no `syncedAt` (written before this
+// grace-period check existed) is rejected outright for the same reason,
+// rather than treated as permanently fresh.
 //
 // TEAM_TIER_GRACE_DAYS bounds how long a synced team-seat tier stays valid without
 // a fresh login/sync — mirrors license.mjs's offline GRACE_DAYS so a team member
 // removed server-side can't keep local access indefinitely just by never syncing.
+//
+// `freshMark` is a monotonic high-water mark of the latest wall-clock time this
+// file has ever been read at without a detected rollback. It is ratcheted forward
+// (never backward) on every honest read and is rejected if the clock now reads
+// earlier than it — closing the realistic attack of rolling the OS clock back
+// once, after a team seat is revoked, to keep `syncedAt` looking fresh forever.
+// It does NOT close every variant: an attacker who fakes the clock from the very
+// first read after a real sync, before any honest freshMark is ever recorded past
+// that point, is not caught — that is an inherent limit of any offline,
+// network-free grace period (the same residual gap license.json's GRACE_DAYS has
+// always had), not something this mechanism claims to solve.
 export function readCliTokenTier(configDir = DEFAULT_CONFIG_DIR) {
   const p = cliTokenPath(configDir);
   if (!existsSync(p)) return null;
   try {
     const data = JSON.parse(readFileSync(p, 'utf8'));
-    if (typeof data.tier !== 'string' || typeof data.tierSig !== 'string' || typeof data.syncedAt !== 'string') {
+    if (
+      typeof data.tier !== 'string' ||
+      typeof data.tierSig !== 'string' ||
+      typeof data.syncedAt !== 'string' ||
+      typeof data.freshMark !== 'string'
+    ) {
       return null;
     }
     const secret = readMachineSecret(configDir);
     if (!secret) return null;
-    const signed = { tier: data.tier, syncedAt: data.syncedAt };
+    const signed = { tier: data.tier, syncedAt: data.syncedAt, freshMark: data.freshMark };
     if (!verifyHmac(data.tierSig, signed, `${CLI_TOKEN_HMAC_SALT}:${secret}`)) return null;
 
     // An unparseable syncedAt gives NaN — rejected on its own line rather than
@@ -70,12 +87,38 @@ export function readCliTokenTier(configDir = DEFAULT_CONFIG_DIR) {
     const daysSinceSync = (Date.now() - syncedAtMs) / MS_PER_DAY;
     if (daysSinceSync > TEAM_TIER_GRACE_DAYS) return null;
 
+    const freshMarkMs = new Date(data.freshMark).getTime();
+    if (Number.isNaN(freshMarkMs)) return null;
+
+    const nowMs = Date.now();
+    if (nowMs < freshMarkMs) return null;
+
+    if (nowMs > freshMarkMs) {
+      // Best-effort ratchet — wrapped so a disk-write failure (full disk,
+      // permissions changed mid-session) can't turn an otherwise-valid read
+      // into a null; the mark simply stays where it was for next time.
+      try {
+        writeFreshMark(p, data, secret, nowMs);
+      } catch {
+        // ignore — ratcheting forward is an optimization, not a correctness requirement
+      }
+    }
+
     return data.tier;
   } catch {
     return null;
   }
 }
 
+function writeFreshMark(p, data, secret, nowMs) {
+  const freshMark = new Date(nowMs).toISOString();
+  const signed = { tier: data.tier, syncedAt: data.syncedAt, freshMark };
+  const tierSig = signHmac(signed, `${CLI_TOKEN_HMAC_SALT}:${secret}`);
+  const payload = { token: data.token, ...signed, tierSig };
+  writeFileSync(p, JSON.stringify(payload, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
+  chmodSync(p, 0o600);
+}
+
 export function saveCliToken(token, configDir = DEFAULT_CONFIG_DIR, tier = undefined) {
   mkdirSync(configDir, { recursive: true });
   const p = cliTokenPath(configDir);
@@ -83,8 +126,12 @@ export function saveCliToken(token, configDir = DEFAULT_CONFIG_DIR, tier = undef
   if (tier !== undefined) {
     const secret = readOrCreateMachineSecret(configDir);
     const syncedAt = new Date().toISOString();
-    const tierSig = signHmac({ tier, syncedAt }, `${CLI_TOKEN_HMAC_SALT}:${secret}`);
-    payload = { token, tier, syncedAt, tierSig };
+    // A real login/sync is itself a trusted checkpoint (it round-tripped to the
+    // server), so freshMark resets to "now" here rather than only ratcheting —
+    // unlike a local read, this is not attacker-reachable without valid credentials.
+    const freshMark = syncedAt;
+    const tierSig = signHmac({ tier, syncedAt, freshMark }, `${CLI_TOKEN_HMAC_SALT}:${secret}`);
+    payload = { token, tier, syncedAt, freshMark, tierSig };
   }
   writeFileSync(p, JSON.stringify(payload, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
   chmodSync(p, 0o600);

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)}`);