ticketlens 0.38.45 → 0.38.47

package/README.md

@@ -452,15 +452,17 @@ 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).
+**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; 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).
 
 `note add`'s save confirmation and `recall`'s search results are styled by default in a terminal; add `--plain` to either for bare, pipe-safe output. `recall` always shows each note's file ID (e.g. `[1784135399545-fe01c4.md]`) so you can open it directly (`cat ~/.ticketlens/recall/<PREFIX>/<id>`), or pass `--full` to print the full body content inline instead. Each result shows a relative time (`2h ago`, `3d ago`) rather than a bare date — the full-precision timestamp is always in the note file's own frontmatter.
 
 **Tags matter for search relevance.** `--tags=a,b` accepts anything, but a generic tag (the project name, "gotcha", "bug") gives future search almost nothing to match on. Tag with what the note is actually *about* — the specific technology, error type, or root cause (`retry-backoff`, `null-pointer`, `auth-middleware`) — so it surfaces when someone else hits the same problem.
 
-**Local file attachments.** `note add --attach=path1,path2` (or the `recall_add` MCP tool's `attachments` array) saves a screenshot or file alongside the note, in your local vault (`~/.ticketlens/recall/<PREFIX>/<note-id>/`) — same 10 MB/file, 50 MB/call, 20-file caps as ticket attachments for the local save. With Team Recall sync active, the attachment syncs too — visible and downloadable from Console > Admin > Recall — but the sync path caps at 12 MB/call (the backend's request-size limit, lower than the 50 MB local-save cap). Going over it fails the whole push, not just the attachment — the note stays saved locally, but neither its text nor the attachment reaches the team until it's pushed within the cap. Attachments with plain-text content (detected from the actual bytes, not the filename) go through the same secret scan as the note body before syncing; a rejected scan blocks the whole push the same way.
+**Local file attachments.** `note add --attach=path1,path2` (or the `recall_add` MCP tool's `attachments` array) saves a screenshot or file alongside the note, in your local vault (`~/.ticketlens/recall/<PREFIX>/<note-id>/`) — same 10 MB/file, 50 MB/call, 20-file caps as ticket attachments for the local save. `note patch --attach=path1,path2` (or `recall_update`'s `attachments` array) attaches more files to an existing note later — appended to what's already there, never replacing it; patch is local-vault only, so these are never pushed even if the note's original attachments were. With Team Recall sync active, the attachment syncs too — visible and downloadable from Console > Admin > Recall — but the sync path caps at 12 MB/call (the backend's request-size limit, lower than the 50 MB local-save cap). Going over it fails the whole push, not just the attachment — the note stays saved locally, but neither its text nor the attachment reaches the team until it's pushed within the cap. Attachments with plain-text content (detected from the actual bytes, not the filename) go through the same secret scan as the note body before syncing; a rejected scan blocks the whole push the same way.
 
 **Gaps** — every `ticketlens PROJ-123` brief also diffs the ticket's own description against its linked tickets (from the depth traversal you already requested) and its own downloaded attachments, looking for requirements mentioned there but missing here. Anything uncovered shows up under a `## Gaps` section, citing exactly where it came from — a linked ticket key or an attachment filename — as evidence, never an instruction to act on. Nothing is saved anywhere; it's recomputed fresh on every fetch. Requires a Pro license, same as Recall. No network call beyond what the brief already made.
 
@@ -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.45",
+  "version": "0.38.47",
   "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.4 -->
+<!-- jtb-skill-version: 0.42.6 -->
 ---
 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)
@@ -397,7 +397,9 @@ When it does apply, run up to 3 rounds:
    ```
    `--expect-mtime` is what keeps this safe: if the file changed since step 1 (the user hand-edited it while you were drafting), the patch silently no-ops and prints "not found or already changed" — the user's own edit always wins, never gets clobbered by a stale background draft.
 
-   If this harness has TicketLens's MCP server configured (a tool named `recall_update` — often shown as `mcp__ticketlens__recall_update` — visible in your tool list), prefer it over the bash form: same license gate, same structural/secret-scan checks, same optimistic-concurrency behavior via `expectMtime` — just no shell command or stdin piping to construct. It accepts `id`/`body`/`ticket`/`expectMtime`.
+   `note patch` also takes `--attach=path1,path2` (Pro), same caps and secret-scan treatment as `note add`'s — new files are appended to whatever the note already has, never replacing existing attachments.
+
+   If this harness has TicketLens's MCP server configured (a tool named `recall_update` — often shown as `mcp__ticketlens__recall_update` — visible in your tool list), prefer it over the bash form: same license gate, same structural/secret-scan checks, same optimistic-concurrency behavior via `expectMtime` — just no shell command or stdin piping to construct. It accepts `id`/`body`/`ticket`/`expectMtime`/`attachments`.
 5. Repeat from step 1 (re-capture mtime/body fresh each round) up to 3 total rounds. If no round ever produces a fully-passing draft, patch in whichever round scored highest across all attempts, and let the "not found or already changed" message stand if that patch itself loses a late race — don't retry past round 3.
 
 This never calls any external API or bills any tokens beyond the session you already have open — the generator and validator are subagents inside your own Claude Code session, not a TicketLens server call.

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 = 'https://api.ticketlens.app';
+export const DEFAULT_API_BASE = 'http://api.ticketlens.test';
 export const DEFAULT_SITE_BASE = 'https://ticketlens.app';
 
 // Matches localhost, 127.0.0.1, and any hostname ending in .test or .local,

package/skills/jtb/scripts/lib/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-server.mjs

@@ -393,11 +393,14 @@ async function callRecallAdd(args, { configDir, runNoteAddFn }) {
  * as buildNoteAddArgs above. `expectMtime` is optimistic-concurrency: a
  * caller that fetched a note via recall_search and wants to refine it
  * without racing a concurrent edit passes back the mtime it observed.
+ * `attachments` (backlog #21) is appended to whatever the note already has,
+ * same as buildNoteAddArgs's — never a replace.
  */
-function buildNotePatchArgs({ id, ticket, expectMtime }) {
+function buildNotePatchArgs({ id, ticket, expectMtime, attachments }) {
   const args = [`--id=${id}`];
   if (ticket) args.push(`--ticket=${ticket}`);
   if (expectMtime !== undefined) args.push(`--expect-mtime=${expectMtime}`);
+  if (Array.isArray(attachments) && attachments.length > 0) args.push(`--attach=${attachments.join(',')}`);
   return args;
 }
 

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

@@ -180,6 +180,7 @@ export const TOOLS = [
         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.' },
+        attachments: { type: 'array', items: { type: 'string' }, description: 'Local file paths to attach (screenshots, logs, etc.) — appended to whatever the note already has, never replacing existing attachments. Same 10MB/file, 50MB/call, 20-file caps as recall_add. Local vault only — recall_update never syncs to a team backend, so this never pushes.' },
       },
       required: ['id', 'body'],
     },

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

@@ -13,7 +13,7 @@ import { scanForSecrets } from './secret-scanner.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, normalizeRecallStrictness } 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';
@@ -108,6 +108,7 @@ export async function runNoteAdd(cmdArgs, {
   writeNoteFn = writeNote,
   readCliTokenFn = readCliToken,
   resolveProfileFn = resolveProfile,
+  resolveEffectiveRecallStrictnessFn = resolveEffectiveRecallStrictness,
   loadProfileRecallTeamIdFn = loadProfileRecallTeamId,
   pushNoteFn = pushNote,
   enqueueNoteFn = enqueueNote,
@@ -155,10 +156,13 @@ export async function runNoteAdd(cmdArgs, {
   }
 
   // Resolved once here (not just inside the push block below) so the
-  // word-count warning below can read this profile's recallStrictness
-  // regardless of whether a CLI token is configured for pushing.
+  // 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 strictness = normalizeRecallStrictness(profile?.recallStrictness);
+  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`);
@@ -193,7 +197,6 @@ 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) —
@@ -225,7 +228,9 @@ export async function runNoteAdd(cmdArgs, {
  * meant to be typed by hand): the loop's generator subagent produces a body,
  * SKILL.md's orchestration pipes it through this command, and the new body
  * gets exactly the same structural and secret gates a user-typed body gets —
- * there is no weaker path here for AI-authored content.
+ * there is no weaker path here for AI-authored content. `--attach` works the
+ * same as `note add`'s — files are appended to whatever the note already has,
+ * never replacing them.
  *
  * @param {string[]} cmdArgs
  * @returns {Promise<{ patched: boolean }>}
@@ -238,8 +243,11 @@ export async function runNotePatch(cmdArgs, {
   checkNoteStructureFn = checkNoteStructure,
   checkWordCountFn = checkWordCount,
   resolveProfileFn = resolveProfile,
+  readCliTokenFn = readCliToken,
+  resolveEffectiveRecallStrictnessFn = resolveEffectiveRecallStrictness,
   scanForSecretsFn = scanForSecrets,
   patchNoteBodyFn = patchNoteBody,
+  readAttachmentsFn = readAttachments,
 } = {}) {
   if (!isLicensedFn('pro', configDir)) {
     showUpgradePrompt('pro', 'ticketlens note', { stream });
@@ -248,7 +256,7 @@ export async function runNotePatch(cmdArgs, {
 
   const id = parseFlag(cmdArgs, 'id');
   if (!id) {
-    stream.write('Usage: ticketlens note patch --id="..." [--ticket=KEY]\n');
+    stream.write('Usage: ticketlens note patch --id="..." [--ticket=KEY] [--attach=path1,path2]\n');
     return { patched: false };
   }
 
@@ -267,7 +275,8 @@ export async function runNotePatch(cmdArgs, {
   }
 
   const profile = resolveProfileFn(ticketKey || null, { configDir, cwd: process.cwd() });
-  const strictness = normalizeRecallStrictness(profile?.recallStrictness);
+  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`);
@@ -282,11 +291,18 @@ export async function runNotePatch(cmdArgs, {
     stream.write(`  Warning: ${warning}\n`);
   }
 
+  const attachPaths = parseAttachPaths(cmdArgs);
+  const { saved: attachments, warnings: attachWarnings } = attachPaths.length > 0
+    ? summarizeAttachments(readAttachmentsFn(attachPaths))
+    : { saved: [], warnings: [] };
+  for (const warning of attachWarnings) stream.write(warning);
+
   const ticketKeys = ticketKey ? [ticketKey] : [];
   const expectMtimeArg = parseFlag(cmdArgs, 'expect-mtime');
   const expectedMtimeMs = expectMtimeArg !== undefined ? Number(expectMtimeArg) : undefined;
-  const { patched } = patchNoteBodyFn({ id, ticketKeys, body, expectedMtimeMs }, { configDir });
-  stream.write(patched ? `  Updated note (${id})\n` : `  Note not updated — (${id}) not found or already changed.\n`);
+  const { patched } = patchNoteBodyFn({ id, ticketKeys, body, expectedMtimeMs, attachments }, { configDir });
+  const attachSuffix = patched && attachments.length > 0 ? ` + ${attachments.length} attachment(s)` : '';
+  stream.write(patched ? `  Updated note (${id})${attachSuffix}\n` : `  Note not updated — (${id}) not found or already changed.\n`);
   return { patched };
 }
 

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';

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

@@ -90,7 +90,10 @@ function writeAttachments(noteDir, id, attachments) {
   if (attachments.length === 0) return [];
   const attachDir = attachmentsDirFor(noteDir, id);
   fs.mkdirSync(attachDir, { recursive: true });
-  const used = new Set();
+  // Seeded from what's already on disk, not just this call's batch — patchNoteBody
+  // can call this a second time against the same note id, and a same-named file
+  // from an earlier add/patch must count toward uniqueness too.
+  const used = new Set(fs.readdirSync(attachDir));
   const saved = [];
   for (const { filename, buffer } of attachments) {
     const uniqueName = uniquifyFilename(filename, used);
@@ -248,8 +251,10 @@ export function deleteNoteAnyPrefix(externalId, { configDir = DEFAULT_CONFIG_DIR
  * Overwrites an existing local note's body in place — used by the jtb skill's
  * generator/validator quality loop to swap in a better draft after `note add`
  * already saved the original. Patch-only: never creates a note, and every
- * frontmatter field except body is carried over unchanged, so this can never
- * become a covert way to retitle/retag/re-tie a note to a different ticket.
+ * frontmatter field except body and attachments is carried over unchanged, so
+ * this can never become a covert way to retitle/retag/re-tie a note to a
+ * different ticket. New attachments are appended to whatever the note already
+ * has — a patch refines a note, it never discards what's already attached.
  *
  * Guards, same failure-mode split as deleteNote: a malformed id or ticket key
  * is a caller bug (throw); a missing file, an externalId that doesn't match
@@ -257,17 +262,18 @@ export function deleteNoteAnyPrefix(externalId, { configDir = DEFAULT_CONFIG_DIR
  * (expectedMtimeMs) are all best-effort no-ops, not errors — the original
  * note is always left exactly as-is on any of these.
  *
- * @param {{ id: string, ticketKeys?: string[], body: string, expectedMtimeMs?: number }} params
+ * @param {{ id: string, ticketKeys?: string[], body: string, expectedMtimeMs?: number, attachments?: Array<{ filename: string, buffer: Buffer }> }} params
  * @param {{ configDir?: string }} [opts]
  * @returns {{ patched: boolean, path: string|null }}
  */
-export function patchNoteBody({ id, ticketKeys = [], body, expectedMtimeMs }, { configDir = DEFAULT_CONFIG_DIR } = {}) {
+export function patchNoteBody({ id, ticketKeys = [], body, expectedMtimeMs, attachments = [] }, { configDir = DEFAULT_CONFIG_DIR } = {}) {
   if (!EXTERNAL_ID_PATTERN.test(id)) {
     throw new Error(`Invalid note id: "${id}"`);
   }
 
   const prefix = resolvePrefix(ticketKeys[0]);
-  const notePath = path.join(prefixDir(configDir, prefix), id);
+  const dir = prefixDir(configDir, prefix);
+  const notePath = path.join(dir, id);
 
   if (!fs.existsSync(notePath)) {
     return { patched: false, path: null };
@@ -281,6 +287,13 @@ export function patchNoteBody({ id, ticketKeys = [], body, expectedMtimeMs }, {
     return { patched: false, path: notePath };
   }
 
+  // existing.attachments is the full list already on disk (from add and/or a
+  // prior patch) — carried forward here, or the drop bug returns: patch would
+  // silently strip the attachments: key, orphaning files that stay on disk but
+  // become permanently unlisted and unpushable.
+  const savedAttachments = writeAttachments(dir, id, attachments);
+  const mergedAttachments = [...existing.attachments, ...savedAttachments];
+
   const data = {
     title: existing.title,
     aliases: existing.aliases,
@@ -291,6 +304,7 @@ export function patchNoteBody({ id, ticketKeys = [], body, expectedMtimeMs }, {
     status: existing.status,
     sources: existing.sources,
     externalId: existing.externalId,
+    ...(mergedAttachments.length > 0 ? { attachments: mergedAttachments } : {}),
   };
 
   writeFileAtomically(notePath, serializeFrontmatter(data, body));