ticketlens 0.38.44 → 0.38.46

package/README.md

@@ -452,6 +452,8 @@ Every note is scanned before saving — anything shaped like a real secret (API
 
 **Queue settings:** the retry cooldown (default 15 min), per-request timeout (4s), max queued notes (200), and queued-note expiry (30 days) are set by your team manager at `console/admin/recall` and apply to every member's CLI — solo users get the same platform defaults. `ticketlens recall settings` shows the values currently in effect, fetched live: a manager's change is visible the moment your CLI's next retry decision runs, not on a delay.
 
+**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.
+
 **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; `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. `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).
@@ -808,7 +810,7 @@ ticketlens note delete --id="..." --ticket=CNV1-2  # Remove a note from your loc
 ticketlens recall CNV1-2                      # Search saved notes by ticket key [Pro]
 ticketlens recall "retry backoff"             # Free-text search across all notes [Pro]
 ticketlens recall sync                        # Retry any notes stuck in the local queue [Team+]
-ticketlens recall settings                    # Show effective retry-queue settings, fetched live [Team+]
+ticketlens recall settings                    # Show effective retry-queue settings + capture strictness, fetched live [Team+]
 ticketlens mcp                                # Start the MCP stdio server (recall/ticket write tools) [Pro]
 ticketlens mcp install                        # Register it into the current project's .mcp.json
 ticketlens mcp install --dry-run              # Preview the registration without writing
@@ -920,7 +922,7 @@ ticketlens note add --title="..."        # Save a Recall note (body from stdin)
 ticketlens note delete --id="..."        # Remove a note from your local vault
 ticketlens recall <query|TICKET-KEY>     # Search your saved Recall notes
 ticketlens recall sync                   # Retry any notes stuck in the local queue
-ticketlens recall settings               # Show effective retry-queue settings, fetched live
+ticketlens recall settings               # Show effective retry-queue settings + capture strictness, fetched live
 ticketlens mcp                           # Start the MCP stdio server (recall/ticket write tools)
 ticketlens comment CNV1-2 --body="..."   # Post a comment to the tracker
 ticketlens comment CNV1-2 --body="..." --attach=./bug.png  # Attach local files (comment/create only)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.38.44",
+  "version": "0.38.46",
   "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.42.3 -->
+<!-- jtb-skill-version: 0.42.5 -->
 ---
 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.
@@ -62,7 +62,7 @@ Fetches a Jira ticket and produces a structured brief with code references, then
 /jtb note add --title="..." --attach=./shot.png,./log.txt # attach local files to a Recall note (Pro, local vault only — see note below)
 /jtb recall PROD-1234                  # search saved Recall notes (Pro)
 /jtb recall sync                       # retry any notes stuck in the local queue (Team+)
-/jtb recall settings                   # show effective retry-queue settings, fetched live (Team+)
+/jtb recall settings                   # show effective retry-queue settings + Recall capture strictness, fetched live (Team+)
 /jtb comment PROD-1234 --body="..."    # post a comment to the tracker (Pro)
 /jtb transition PROD-1234              # list the tracker's current valid transitions (Pro)
 /jtb transition PROD-1234 --target="Done" --confirm  # execute the transition (Pro)
@@ -356,6 +356,8 @@ Example that qualifies: an undocumented schema quirk found only by reading raw D
 
 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.
 
+**Length:** keep both the title and body brief — a sharp one- or two-sentence takeaway, not a paragraph. The recommended max scales with the same strictness level as the section above: 20 words (strict), 30 words (balanced, default), 50 words (loose). Going over doesn't block the save — the CLI/MCP tool prints a non-blocking warning so you can tighten it, the same way it prints warnings for a detected email address or similar low-severity secret-scan hit.
+
 Capture **at the moment you confirm the insight**, not deferred to the end of the session — don't ask the user first, just do it. It requires a Pro license; on a Free account it will no-op with an upgrade hint on stderr, which is fine to ignore. It never blocks or fails the session.
 
 Immediately before dispatching the call, say one line in your response: `🔖 Recall-flag: <one-line reason>`. This is a fixed marker some harness setups scan for to confirm captures are actually happening — always emit it right when you decide to capture, even if you go on to call `note add` in the same breath.
@@ -365,7 +367,7 @@ Immediately before dispatching the call, say one line in your response: `🔖 Re
 If your environment lets you dispatch a tool call without waiting for its result — a background task, an async subagent, a fire-and-forget job — try it **once**. If it errors for any reason, don't retry the background path — fall back to calling it synchronously immediately. It's fast and never blocks or fails your session either way, so the synchronous fallback costs nothing; repeatedly retrying a broken background mechanism only adds visible noise for no benefit.
 
 ```bash
-echo "The body text of the note, one or more paragraphs." | \
+echo "Retry client swallowed 429s silently; added backoff and a warning log on the third failure." | \
   ticketlens note add --title="Short title" --ticket=TICKET-KEY --tags=a,b
 ```
 

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

@@ -26,9 +26,12 @@
  * again after the next compaction/resume rollover, since that dismissal
  * was never recorded anywhere — only a real capture was.
  *
- * 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.
+ * Which of the two cases above actually blocks is governed by the effective
+ * recallStrictness — the active profile's own explicit config-set value, or
+ * else the team's Console-set default (backlog #20), resolved entirely from
+ * local state via resolveEffectiveRecallStrictness() so this hook never
+ * touches the network. 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
@@ -40,7 +43,8 @@
  */
 
 import { readStdinJson, readState, writeState, scanTranscript, hasRecentCapture, writeLastCaptureAt, hasRecentNag, writeLastNagAt, shouldNag } from './recall-nudge-lib.mjs';
-import { resolveProfile, normalizeRecallStrictness } from '../scripts/lib/profile-resolver.mjs';
+import { resolveProfile, resolveEffectiveRecallStrictness } from '../scripts/lib/profile-resolver.mjs';
+import { readCliToken } from '../scripts/lib/cli-auth.mjs';
 
 const input = readStdinJson();
 const sessionId = input?.session_id;
@@ -60,7 +64,8 @@ const state = readState(sessionId);
 if (state.stopChecked) process.exit(0); // already asked once this session — respect the answer
 
 const profile = resolveProfile(ticketKey, { cwd });
-const recallStrictness = normalizeRecallStrictness(profile?.recallStrictness);
+const cliToken = readCliToken();
+const recallStrictness = resolveEffectiveRecallStrictness({ profile, cliToken });
 
 if (!shouldNag({ sawFetch, sawRecallFlag, sawNoteAdd, recallStrictness })) {
   process.exit(0); // nothing this strictness level requires a capture for

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/help.mjs

@@ -53,7 +53,7 @@ export function printHelp({ stream = process.stdout } = {}) {
     `    ${s.brand('ticketlens')} note delete ${s.dim('--id=... [--ticket=KEY]')}  Remove a note from your local vault  ${s.dim('[Pro]')}`,
     `    ${s.brand('ticketlens')} recall ${s.dim('<query|TICKET-KEY>')}   Search your saved Recall notes  ${s.dim('[Pro]')}`,
     `    ${s.brand('ticketlens')} recall sync                 Retry any notes stuck in the local queue  ${s.dim('[Team+]')}`,
-    `    ${s.brand('ticketlens')} recall settings             Show effective retry-queue settings, fetched live  ${s.dim('[Team+]')}`,
+    `    ${s.brand('ticketlens')} recall settings             Show effective retry-queue settings + capture strictness, fetched live  ${s.dim('[Team+]')}`,
     `    ${s.brand('ticketlens')} mcp                         Start the MCP stdio server (Recall + ticket writes)  ${s.dim('[Pro]')}`,
     `    ${s.brand('ticketlens')} comment ${s.dim('<TICKET-KEY> --body=... [--attach=...]')}  Post a comment to the tracker  ${s.dim('[Pro]')}`,
     `    ${s.brand('ticketlens')} transition ${s.dim('<TICKET-KEY> [--target=... --confirm]')}  Move ticket status  ${s.dim('[Pro]')}`,

package/skills/jtb/scripts/lib/mcp-tool-schemas.mjs

@@ -161,10 +161,10 @@ export const TOOLS = [
     inputSchema: {
       type: 'object',
       properties: {
-        title: { type: 'string', description: 'Short one-line title.' },
+        title: { type: 'string', description: 'Short one-line title, ~20 (strict), 30 (balanced), or 50 (loose) words max — scales with recallStrictness — going over doesn\'t block the save, but prints a non-blocking warning.' },
         ticket: { type: 'string', description: 'Optional ticket key, e.g. PROJ-123.' },
         tags: { type: 'array', items: { type: 'string' }, description: 'Optional tags derived from this note\'s actual content — the specific technology, error type, root cause, or affected component (e.g. "retry-backoff", "null-pointer", "auth-middleware"). Never the project name or a generic category word like "gotcha" or "bug" — those provide no search signal to someone else looking for this note later. A tag that just restates the title in different words, or one you cannot trace to a specific sentence in the body, gives that same zero signal — if you cannot point to the exact phrase that justifies it, drop it.' },
-        body: { type: 'string', description: 'The note body — one or more paragraphs.' },
+        body: { type: 'string', description: 'The note body — brief, not a paragraph. ~20 (strict), 30 (balanced), or 50 (loose) words max — scales with recallStrictness — going over doesn\'t block the save, but prints a non-blocking warning.' },
         attachments: { type: 'array', items: { type: 'string' }, description: 'Local file paths to attach (screenshots, logs, etc.), saved next to the note in the local vault. Same 10MB/file, 50MB/call, 20-file caps as ticket_comment/ticket_create for the local save. If this account is entitled and the note syncs to a team, attachments sync too — visible and downloadable from Console > Admin > Recall — but the sync path has a lower 12MB/call cap than the local save (backend request-size limit). Going over it fails the WHOLE push (note text included), not just the attachment; the note stays saved locally either way.' },
       },
       required: ['title', 'body'],
@@ -177,7 +177,7 @@ export const TOOLS = [
       type: 'object',
       properties: {
         id: { type: 'string', description: 'Note id to patch, as printed by recall_add or recall_search.' },
-        body: { type: 'string', description: 'The replacement note body.' },
+        body: { type: 'string', description: 'The replacement note body — brief, not a paragraph. ~20 (strict), 30 (balanced), or 50 (loose) words max — scales with recallStrictness — going over doesn\'t block the update, but prints a non-blocking warning.' },
         ticket: { type: 'string', description: 'Ticket key the note is about, e.g. PROJ-123. Optional — narrows the search when omitted, the vault is searched across all ticket prefixes.' },
         expectMtime: { type: 'number', description: 'The note file\'s mtime (ms) last observed by the caller. If the note changed since then, the patch is a no-op rather than an overwrite — optimistic concurrency, not a hard requirement.' },
       },

package/skills/jtb/scripts/lib/note-command.mjs

@@ -10,10 +10,10 @@ import path from 'node:path';
 import { DEFAULT_CONFIG_DIR } from './config.mjs';
 import { isLicensed, showUpgradePrompt } from './license.mjs';
 import { scanForSecrets } from './secret-scanner.mjs';
-import { checkNoteStructure } from './note-structural-check.mjs';
+import { checkNoteStructure, checkWordCount, WORD_LIMITS } from './note-structural-check.mjs';
 import { writeNote, patchNoteBody, deleteNote, deleteNoteAnyPrefix, rebuildIndex } from './recall-vault.mjs';
 import { readCliToken } from './cli-auth.mjs';
-import { resolveProfile, loadProfileRecallTeamId } from './profile-resolver.mjs';
+import { resolveProfile, loadProfileRecallTeamId, resolveEffectiveRecallStrictness } from './profile-resolver.mjs';
 import { pushNote } from './recall-sync.mjs';
 import { enqueueNote, isRetryableFailure, maybeAutoFlush } from './recall-queue.mjs';
 import { incrementDraftKept, incrementDraftDeleted } from './activity-counter.mjs';
@@ -103,10 +103,12 @@ export async function runNoteAdd(cmdArgs, {
   readStdin = defaultReadStdin,
   isLicensedFn = isLicensed,
   checkNoteStructureFn = checkNoteStructure,
+  checkWordCountFn = checkWordCount,
   scanForSecretsFn = scanForSecrets,
   writeNoteFn = writeNote,
   readCliTokenFn = readCliToken,
   resolveProfileFn = resolveProfile,
+  resolveEffectiveRecallStrictnessFn = resolveEffectiveRecallStrictness,
   loadProfileRecallTeamIdFn = loadProfileRecallTeamId,
   pushNoteFn = pushNote,
   enqueueNoteFn = enqueueNote,
@@ -153,6 +155,19 @@ export async function runNoteAdd(cmdArgs, {
     return { written: false };
   }
 
+  // Resolved once here (not just inside the push block below) so the
+  // word-count warning below can read this profile's effective recallStrictness
+  // regardless of whether a CLI token is configured for pushing. cliToken is
+  // read here too (not just in the push block) since resolveEffectiveRecallStrictness
+  // needs it to validate a team-default cache entry belongs to this account.
+  const profile = resolveProfileFn(ticketKey || null, { configDir, cwd: process.cwd() });
+  const cliToken = readCliTokenFn(configDir);
+  const strictness = resolveEffectiveRecallStrictnessFn({ profile, configDir, cliToken });
+  const wordCount = checkWordCountFn({ title, body }, { maxWords: WORD_LIMITS[strictness] });
+  for (const warning of wordCount.warnings) {
+    stream.write(`  Warning: ${warning}\n`);
+  }
+
   const scan = scanForSecretsFn({ title, tags, body });
   if (scan.rejected) {
     stream.write(`  Note not saved — ${scan.reasons.join(' ')}\n`);
@@ -182,12 +197,11 @@ export async function runNoteAdd(cmdArgs, {
   const savedLine = `Saved note "${title}" (${id})${attachSuffix}`;
   stream.write(styled ? `\n  ${s.green('✔')} ${savedLine}\n\n` : `  ${savedLine}\n`);
 
-  const cliToken = readCliTokenFn(configDir);
   if (cliToken) {
     const warn = (s) => stream.write(s);
     // Field names match PushRequest's validation rules (external_id, tickets) —
     // the backend wire contract, not the local vault's internal camelCase shape.
-    const profile = resolveProfileFn(ticketKey || null, { configDir, cwd: process.cwd() });
+    // `profile` was already resolved above (needed there for the word-count check).
     const recallTeamId = profile ? loadProfileRecallTeamIdFn(profile.name, configDir) : null;
     const payload = { external_id: id, title, tickets: ticketKeys, tags, author, sources: [], body, captured_at: capturedAt.toISOString() };
     if (recallTeamId !== null) payload.group_id = recallTeamId;
@@ -225,6 +239,10 @@ export async function runNotePatch(cmdArgs, {
   readStdin = defaultReadStdin,
   isLicensedFn = isLicensed,
   checkNoteStructureFn = checkNoteStructure,
+  checkWordCountFn = checkWordCount,
+  resolveProfileFn = resolveProfile,
+  readCliTokenFn = readCliToken,
+  resolveEffectiveRecallStrictnessFn = resolveEffectiveRecallStrictness,
   scanForSecretsFn = scanForSecrets,
   patchNoteBodyFn = patchNoteBody,
 } = {}) {
@@ -253,6 +271,14 @@ export async function runNotePatch(cmdArgs, {
     return { patched: false };
   }
 
+  const profile = resolveProfileFn(ticketKey || null, { configDir, cwd: process.cwd() });
+  const cliToken = readCliTokenFn(configDir);
+  const strictness = resolveEffectiveRecallStrictnessFn({ profile, configDir, cliToken });
+  const wordCount = checkWordCountFn({ body }, { maxWords: WORD_LIMITS[strictness] });
+  for (const warning of wordCount.warnings) {
+    stream.write(`  Warning: ${warning}\n`);
+  }
+
   const scan = scanForSecretsFn({ title: '', tags: [], body });
   if (scan.rejected) {
     stream.write(`  Note not updated — ${scan.reasons.join(' ')}\n`);

package/skills/jtb/scripts/lib/note-structural-check.mjs

@@ -31,3 +31,39 @@ export function checkNoteStructure({ body = '' } = {}) {
 
   return { rejected: false, reason: null };
 }
+
+// Backlog #18 — mandatory brevity cap, one entry per recallStrictness level.
+// Warning-only: a rambling note still saves, it just gets flagged so the
+// caller can tighten it, same non-blocking pattern scanForSecrets uses for
+// its `warnings` array.
+export const WORD_LIMITS = { strict: 20, balanced: 30, loose: 50 };
+
+function countWords(text) {
+  const trimmed = text.trim();
+  return trimmed.length === 0 ? 0 : trimmed.split(/\s+/).length;
+}
+
+/**
+ * Warning-only companion to checkNoteStructure: flags a title/body that runs
+ * long instead of rejecting it. `maxWords` is a plain number so this stays
+ * dependency-free — the caller maps recallStrictness to a number.
+ *
+ * @param {{ title?: string, body?: string }} note
+ * @param {{ maxWords?: number }} opts
+ * @returns {{ warnings: string[] }}
+ */
+export function checkWordCount({ title = '', body = '' } = {}, { maxWords = WORD_LIMITS.balanced } = {}) {
+  const warnings = [];
+
+  const titleWords = countWords(title);
+  if (titleWords > maxWords) {
+    warnings.push(`Note title is ${titleWords} words (recommended max: ${maxWords}).`);
+  }
+
+  const bodyWords = countWords(body);
+  if (bodyWords > maxWords) {
+    warnings.push(`Note body is ${bodyWords} words (recommended max: ${maxWords}).`);
+  }
+
+  return { warnings };
+}

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

@@ -8,6 +8,10 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { DEFAULT_CONFIG_DIR } from './config.mjs';
 import { sanitizeUntrustedText } from './ansi.mjs';
+import { readEffectiveRecallSettings } from './recall-settings-sync.mjs';
+import { RECALL_STRICTNESS_LEVELS, DEFAULT_RECALL_STRICTNESS } from './recall-strictness.mjs';
+
+export { RECALL_STRICTNESS_LEVELS, DEFAULT_RECALL_STRICTNESS };
 
 /** Simple Levenshtein distance for "did you mean" suggestions. */
 function levenshtein(a, b) {
@@ -100,13 +104,32 @@ 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;
 }
 
+/**
+ * Effective recallStrictness for a profile (backlog #20) — an explicit local
+ * `config set recallStrictness` always wins; only falls back to the team's
+ * Console-set default (read from the same local, network-free settings cache
+ * queue-settings already uses) when the profile has none. Synchronous and
+ * local-only by design — this is what the Stop hook calls, and it must never
+ * touch the network on every session end.
+ *
+ * @param {object} [opts]
+ * @param {{recallStrictness?: string}} [opts.profile]
+ * @param {string} [opts.configDir]
+ * @param {string} [opts.cliToken]
+ * @returns {string}
+ */
+export function resolveEffectiveRecallStrictness({ profile, configDir = DEFAULT_CONFIG_DIR, cliToken } = {}) {
+  if (profile?.recallStrictness && RECALL_STRICTNESS_LEVELS.includes(profile.recallStrictness)) {
+    return profile.recallStrictness;
+  }
+  const cached = readEffectiveRecallSettings(configDir, { cliToken });
+  return normalizeRecallStrictness(cached.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}"`);

package/skills/jtb/scripts/lib/recall-command.mjs

@@ -15,7 +15,7 @@ import { TICKET_KEY_PATTERN } from './cli.mjs';
 import { isLicensed, showUpgradePrompt } from './license.mjs';
 import { listNotes } from './recall-vault.mjs';
 import { readCliToken } from './cli-auth.mjs';
-import { resolveProfile, loadProfileRecallTeamId } from './profile-resolver.mjs';
+import { resolveProfile, loadProfileRecallTeamId, resolveEffectiveRecallStrictness, RECALL_STRICTNESS_LEVELS } from './profile-resolver.mjs';
 import { pullNotes } from './recall-sync.mjs';
 import { maybeAutoFlush, flushQueue, readQueue } from './recall-queue.mjs';
 import { getEffectiveRecallSettingsWithSource } from './recall-settings-sync.mjs';
@@ -128,7 +128,9 @@ export async function runRecallSettings(cmdArgs, {
   stream = process.stdout,
   isLicensedFn = isLicensed,
   readCliTokenFn = readCliToken,
+  resolveProfileFn = resolveProfile,
   getEffectiveRecallSettingsWithSourceFn = getEffectiveRecallSettingsWithSource,
+  resolveEffectiveRecallStrictnessFn = resolveEffectiveRecallStrictness,
 } = {}) {
   if (!isLicensedFn('pro', configDir)) {
     showUpgradePrompt('pro', 'ticketlens recall', { stream });
@@ -143,5 +145,16 @@ export async function runRecallSettings(cmdArgs, {
   stream.write(`  Max queued notes:    ${settings.max_queue_size}\n`);
   stream.write(`  Queued note expiry:  ${settings.max_entry_age_ms / 86_400_000} days\n`);
   stream.write(`  Source: ${SOURCE_LABELS[source]}\n`);
+
+  // recall_strictness has its own precedence, separate from the queue
+  // settings above: an explicit local `config set recallStrictness` always
+  // wins over the team's Console default (backlog #20) — so its effective
+  // value and source are reported independently rather than reusing `source`.
+  const profile = resolveProfileFn(null, { configDir, cwd: process.cwd() });
+  const hasLocalOverride = RECALL_STRICTNESS_LEVELS.includes(profile?.recallStrictness);
+  const recallStrictness = resolveEffectiveRecallStrictnessFn({ profile, configDir, cliToken });
+  const strictnessSource = hasLocalOverride ? 'your local `config set recallStrictness`' : SOURCE_LABELS[source];
+  stream.write(`  Recall capture strictness: ${recallStrictness}\n`);
+  stream.write(`  Source: ${strictnessSource}\n`);
   return { ok: true };
 }

package/skills/jtb/scripts/lib/recall-settings-sync.mjs

@@ -26,6 +26,7 @@ import { DEFAULT_CONFIG_DIR } from './config.mjs';
 import { apiBase } from './api-utils.mjs';
 import { writeFileAtomically } from './recall-vault.mjs';
 import { hashToken } from './recall-sync.mjs';
+import { RECALL_STRICTNESS_LEVELS, DEFAULT_RECALL_STRICTNESS } from './recall-strictness.mjs';
 
 const SETTINGS_PATH = '/v1/recall/settings';
 const CACHE_FILE = 'recall-settings-cache.json';
@@ -37,14 +38,19 @@ const CACHE_FILE = 'recall-settings-cache.json';
 const FETCH_TIMEOUT_MS = 3_000;
 
 // Platform defaults — must match RecallSettings::DEFAULTS in ticketlens-api.
+// recall_strictness (backlog #20) is a team default only — a profile's own
+// explicit `config set recallStrictness` always wins over it; see
+// profile-resolver.mjs's resolveEffectiveRecallStrictness().
 export const DEFAULT_RECALL_SETTINGS = {
   flush_cooldown_ms: 900_000,       // 15 minutes
   timeout_ms: 4_000,                // 4 seconds
   max_queue_size: 200,
   max_entry_age_ms: 2_592_000_000,  // 30 days
+  recall_strictness: DEFAULT_RECALL_STRICTNESS,
 };
 
 // Inclusive [min, max] bounds — must match RecallSettings::BOUNDS in ticketlens-api.
+// recall_strictness is an enum, not a numeric range — see recall-strictness.mjs.
 export const RECALL_SETTINGS_BOUNDS = {
   flush_cooldown_ms: [60_000, 86_400_000],       // 1m .. 24h
   timeout_ms: [1_000, 30_000],                   // 1s .. 30s
@@ -57,6 +63,9 @@ function cachePath(configDir) {
 }
 
 function clamp(field, value) {
+  if (field === 'recall_strictness') {
+    return RECALL_STRICTNESS_LEVELS.includes(value) ? value : DEFAULT_RECALL_SETTINGS.recall_strictness;
+  }
   if (typeof value !== 'number' || !Number.isFinite(value)) return DEFAULT_RECALL_SETTINGS[field];
   const [min, max] = RECALL_SETTINGS_BOUNDS[field];
   return Math.min(Math.max(value, min), max);

package/skills/jtb/scripts/lib/recall-strictness.mjs

@@ -0,0 +1,9 @@
+/**
+ * The three Recall-capture strictness levels — single source of truth.
+ * Zero imports of its own (a leaf module) so both profile-resolver.mjs and
+ * recall-settings-sync.mjs can import it without risking a circular import
+ * between those two.
+ */
+
+export const RECALL_STRICTNESS_LEVELS = ['loose', 'balanced', 'strict'];
+export const DEFAULT_RECALL_STRICTNESS = 'balanced';