ticketlens 0.43.4 → 0.43.5

package/README.md

@@ -469,7 +469,7 @@ Every note is scanned before saving — anything shaped like a real secret (API
 
 **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. `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.
+**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 and 50 MB/call caps as ticket attachments, with a per-call file cap of 10 on Free and 50 on Pro, Team, and Enterprise (also applied to `fetch` attachment downloads). `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.
 
@@ -1122,6 +1122,7 @@ npm test
 See [ROADMAP.md](ROADMAP.md) for the full plan.
 
 Recently shipped:
+- **Tiered attachment cap** — per-call attachment count is now 10 on Free and 50 on Pro, Team and Enterprise (was a flat 20), for uploads, `fetch` downloads and Recall sync. Excess files are reported, not silently dropped
 - **`ticketlens pr --open`** — opens a real GitHub PR compare page prefilled with the same description `pr` already prints, instead of just printing it. GitHub only, no stored write-credential. Pro tier
 - **`review`/`compliance` fixes** — branch diff now uses merge-base semantics, no longer picks up unrelated unmerged-main files; AC parser now recognizes Jira wiki `Requirements`/`How to test` headers, not just literal "Acceptance Criteria"
 - **`ticketlens update --priority`** — a bad priority name now tells you the project's real, current valid options instead of a bare tracker error

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.43.4",
+  "version": "0.43.5",
   "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.48.0 -->
+<!-- jtb-skill-version: 0.49.0 -->
 ---
 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.
@@ -376,7 +376,7 @@ echo "Retry client swallowed 429s silently; added backoff and a warning log on t
 
 **Choosing tags:** derive them 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`. A tag like `jtb` or `ticketlens` tells a future search nothing that the ticket/project context doesn't already say; a tag like `retry-backoff` is what actually surfaces this note when someone else hits the same problem. A tag that just restates the title in different words, or one you can't trace to a specific sentence in the body, gives that same zero signal — if you can't point to the exact phrase that justifies it, drop it. Same rule whether you're constructing the bash command above or calling `recall_add` directly — see its tool description for the same guidance.
 
-**Attaching local files.** `note add --attach=path1,path2` (Pro) saves a screenshot or file alongside the note — same 10 MB/file, 50 MB/call, 20-file caps as `ticket_create`/`ticket_comment`'s `--attach` for the local save. If this account is entitled and the note syncs to a team (Team Recall sync active), the attachment syncs with it — visible and downloadable from Console > Admin > Recall, not just text-only. The sync path has a lower 12 MB/call cap than the local save (bounded by the backend's request-size limit, not the CLI). 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 pushed within the cap. Attachments with plain-text content (checked by actually decoding the bytes, not by filename extension — renaming a text file to `.png` doesn't skip this) go through the same secret scan as the note body before syncing; a rejected scan blocks the whole push the same way. The `recall_add` MCP tool has a matching `attachments` array parameter — prefer it over the bash form when available, same rule as the rest of this section.
+**Attaching local files.** `note add --attach=path1,path2` (Pro) saves a screenshot or file alongside the note — same 10 MB/file and 50 MB/call caps as `ticket_create`/`ticket_comment`'s `--attach` for the local save. File-count cap per call: 10 on Free, 50 on Pro, Team, and Enterprise (same for `fetch` attachment downloads; excess files are reported, not silently dropped). If this account is entitled and the note syncs to a team (Team Recall sync active), the attachment syncs with it — visible and downloadable from Console > Admin > Recall, not just text-only. The sync path has a lower 12 MB/call cap than the local save (bounded by the backend's request-size limit, not the CLI). 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 pushed within the cap. Attachments with plain-text content (checked by actually decoding the bytes, not by filename extension — renaming a text file to `.png` doesn't skip this) go through the same secret scan as the note body before syncing; a rejected scan blocks the whole push the same way. The `recall_add` MCP tool has a matching `attachments` array parameter — prefer it over the bash form when available, same rule as the rest of this section.
 
 **Attaching a browser screenshot.** No separate capture path exists — `--attach` already takes any local file path, and a browser-automation tool's screenshot action (e.g. Chrome DevTools MCP's `take_screenshot`, Playwright's `browser_take_screenshot`) writes to a path you choose when you pass it a `filePath`/output-path argument. Save there, then attach it like any other file:
 ```bash

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

@@ -23,6 +23,7 @@ import { readTextAttachments } from './lib/handoff-assembler.mjs';
 import { handleUnknownFlags } from './lib/arg-validator.mjs';
 import { TICKET_KEY_PATTERN, normalizeTicketKey } from './lib/cli.mjs';
 import { downloadAttachments } from './lib/attachment-downloader.mjs';
+import { attachmentCapFor, attachmentLimitNotice } from './lib/attachment-caps.mjs';
 import { readBriefCache, writeBriefCache, readSummaryCache, writeSummaryCache, briefCacheAge, BRIEF_TTL_MS } from './lib/brief-cache.mjs';
 import { recordTokensSaved } from './lib/activity-counter.mjs';
 import { readCliToken } from './lib/cli-auth.mjs';
@@ -1372,7 +1373,9 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
       printErrFn(`Downloading ${downloadable.length} ${noun}…\n`);
       // attachment-downloader is Jira-specific — it needs raw auth headers from buildJiraEnv
       const jiraEnv = buildJiraEnv(conn);
+      const maxAttachments = attachmentCapFor(configDir);
       ticket.localAttachments = await downloadAttachments(ticket, {
+        maxAttachments,
         env: jiraEnv,
         fetcher,
         noCache: args.includes('--no-cache'),
@@ -1385,6 +1388,8 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
       if (downloaded > 0) parts.push(`${downloaded} downloaded`);
       if (cached > 0) parts.push(`${cached} cached`);
       if (parts.length > 0) printErrFn(`  ✓ ${parts.join(', ')}\n`);
+      const overCap = ticket.localAttachments.filter(r => r.skipReason === 'limit').length;
+      if (overCap > 0) printErrFn(`  ${attachmentLimitNotice(overCap, maxAttachments, { verb: 'not downloaded', scope: 'ticket' })}\n`);
       printErrFn('\n');
     }
   }

package/skills/jtb/scripts/lib/adapters/jira-adapter.mjs

@@ -263,7 +263,7 @@ export function createJiraAdapter(conn, { fetcher = globalThis.fetch } = {}) {
      * Both are image-only; non-image files get neither.
      */
     async attachFiles(key, filePaths, opts = {}) {
-      const { files, droppedCount } = readAttachments(filePaths);
+      const { files, droppedCount, cap } = readAttachments(filePaths, opts.maxAttachments);
       const uploaded = [];
       const errors = [];
       for (const f of files) {
@@ -291,7 +291,7 @@ export function createJiraAdapter(conn, { fetcher = globalThis.fetch } = {}) {
           errors.push({ path: f.path, message: err.message });
         }
       }
-      return { uploaded, errors, droppedCount };
+      return { uploaded, errors, droppedCount, cap };
     },
   };
 }

package/skills/jtb/scripts/lib/adapters/linear-adapter.mjs

@@ -538,7 +538,7 @@ export function createLinearAdapter(conn, { fetcher = globalThis.fetch } = {}) {
     async attachFiles(key, filePaths, opts = {}) {
       const signal = AbortSignal.timeout(opts.timeoutMs ?? 30_000);
       const { lookup = defaultLookupFor(fetcher), allowPrivateIp = false } = opts;
-      const { files, droppedCount } = readAttachments(filePaths);
+      const { files, droppedCount, cap } = readAttachments(filePaths, opts.maxAttachments);
       const uploaded = [];
       const errors = [];
       for (const f of files) {
@@ -592,7 +592,7 @@ export function createLinearAdapter(conn, { fetcher = globalThis.fetch } = {}) {
           errors.push({ path: f.path, message: err.message });
         }
       }
-      return { uploaded, errors, droppedCount };
+      return { uploaded, errors, droppedCount, cap };
     },
   };
 }

package/skills/jtb/scripts/lib/attachment-caps.mjs

@@ -0,0 +1,22 @@
+/**
+ * Per-call attachment count caps, by tier. Byte caps (10 MB/file, 50 MB/call)
+ * are unchanged and live next to the code that enforces them.
+ * Mirrors ticketlens-api's RecallAttachmentStorage::maxFilesFor().
+ */
+
+import { isLicensed } from './license.mjs';
+import { DEFAULT_CONFIG_DIR } from './config.mjs';
+
+export const FREE_MAX_ATTACHMENTS = 10;
+export const PAID_MAX_ATTACHMENTS = 50;
+
+export function attachmentCapFor(configDir = DEFAULT_CONFIG_DIR, isLicensedFn = isLicensed) {
+  return isLicensedFn('pro', configDir) ? PAID_MAX_ATTACHMENTS : FREE_MAX_ATTACHMENTS;
+}
+
+export function attachmentLimitNotice(count, cap, { verb = 'dropped', scope = 'call' } = {}) {
+  const base = `${count} attachment(s) ${verb} — exceeds the ${cap}-file limit per ${scope}.`;
+  return cap < PAID_MAX_ATTACHMENTS
+    ? `${base} Upgrade to Pro for up to ${PAID_MAX_ATTACHMENTS}.`
+    : base;
+}

package/skills/jtb/scripts/lib/attachment-downloader.mjs

@@ -8,7 +8,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { buildAuthHeader, isSafeRedirectUrl, validateResolvedHost, defaultLookupFor } from './jira-client.mjs';
 import { DEFAULT_CONFIG_DIR } from './config.mjs';
-const MAX_ATTACHMENTS = 20;
+import { attachmentCapFor } from './attachment-caps.mjs';
 const MAX_FILE_BYTES = 10 * 1024 * 1024; // 10 MB
 const MAX_REDIRECT_HOPS = 2;
 
@@ -57,6 +57,7 @@ async function followValidatedRedirects(initialUrl, fetcher, lookup, headers, al
  * @param {Function} opts.fetcher fetch-compatible function (default: globalThis.fetch)
  * @param {string} opts.configDir Base config dir (default: ~/.ticketlens)
  * @param {boolean} opts.noCache  Force re-download even if cached (default: false)
+ * @param {number} opts.maxAttachments  File-count cap (default: the tier cap for configDir)
  * @param {Function} opts.onProgress  Optional callback(msg: string) for progress lines
  * @param {boolean} opts.allowPrivateIp  Skip the private-IP DNS check on the initial hop only (default: false)
  *
@@ -71,6 +72,7 @@ export async function downloadAttachments(ticket, opts = {}) {
     noCache = false,
     onProgress = null,
     allowPrivateIp = false,
+    maxAttachments = attachmentCapFor(configDir),
   } = opts;
 
   const attachments = (ticket.attachments ?? []).filter(a => a.content);
@@ -82,8 +84,8 @@ export async function downloadAttachments(ticket, opts = {}) {
   const jiraOrigin = env.JIRA_BASE_URL ? new URL(env.JIRA_BASE_URL).origin : null;
 
   // Attachments beyond the limit are bulk-skipped
-  const capped = attachments.slice(0, MAX_ATTACHMENTS);
-  const limited = attachments.slice(MAX_ATTACHMENTS).map(a => makeResult(a, null, 'limit', null));
+  const capped = attachments.slice(0, maxAttachments);
+  const limited = attachments.slice(maxAttachments).map(a => makeResult(a, null, 'limit', null));
 
   // Pre-classify: resolve immediate results, collect pending downloads
   const results = new Array(capped.length);

package/skills/jtb/scripts/lib/attachment-uploader.mjs

@@ -14,8 +14,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { sanitizeFilename } from './attachment-downloader.mjs';
+import { attachmentCapFor } from './attachment-caps.mjs';
 
-export const MAX_ATTACHMENTS = 20; // mirrors attachment-downloader.mjs's download-side cap
 export const MAX_FILE_BYTES = 10 * 1024 * 1024; // 10 MB — same
 export const MAX_TOTAL_BYTES = 50 * 1024 * 1024; // 50 MB aggregate per call — bounds worst-case memory use across a whole batch
 
@@ -67,7 +67,7 @@ export function readAttachmentFile(filePath) {
 
 /**
  * Reads a batch of paths, best-effort — one bad path never blocks the rest.
- * Paths beyond MAX_ATTACHMENTS are dropped and counted, not silently read.
+ * Paths beyond the tier's file cap are dropped and counted, not silently read.
  * A cheap pre-stat tracks the running total so a file that would push the
  * batch over MAX_TOTAL_BYTES is rejected without ever being buffered — same
  * "reject before read" principle as the per-file size cap. The pre-stat's
@@ -75,10 +75,11 @@ export function readAttachmentFile(filePath) {
  * specific error (not-found/not-a-file/etc.) for those paths.
  *
  * @param {string[]} paths
- * @returns {{ files: Array<{ok: boolean} & (ReturnType<typeof readAttachmentFile>)>, droppedCount: number }}
+ * @param {number} [maxAttachments] file-count cap; defaults to the caller's tier cap
+ * @returns {{ files: Array<{ok: boolean} & (ReturnType<typeof readAttachmentFile>)>, droppedCount: number, cap: number }}
  */
-export function readAttachments(paths) {
-  const capped = paths.slice(0, MAX_ATTACHMENTS);
+export function readAttachments(paths, maxAttachments = attachmentCapFor()) {
+  const capped = paths.slice(0, maxAttachments);
   const files = [];
   let totalBytes = 0;
   for (const p of capped) {
@@ -92,5 +93,5 @@ export function readAttachments(paths) {
     if (!result.error) totalBytes += result.size;
     files.push({ ok: !result.error, ...result });
   }
-  return { files, droppedCount: paths.length - capped.length };
+  return { files, droppedCount: paths.length - capped.length, cap: maxAttachments };
 }

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

@@ -14,7 +14,7 @@ import {
 // Mixed into the HMAC key so that knowing the license key alone is not sufficient
 // to forge a valid signature — an attacker also needs this constant from the source.
 export const LICENSE_HMAC_SALT = 'tl-lic-v1';
-export const LICENSE_TIERS = { free: 0, pro: 1, team: 2 };
+export const LICENSE_TIERS = { free: 0, pro: 1, team: 2, enterprise: 3 };
 const LICENSE_FILE = 'license.json';
 const REVALIDATION_DAYS = 7;   // attempt background revalidation after this many days
 export const GRACE_DAYS = 30;   // treat license as invalid if not revalidated within this window

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

@@ -168,7 +168,7 @@ export const TOOLS = [
         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 — 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.' },
+        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 and 50MB/call caps as ticket_comment/ticket_create for the local save; file count is capped at 10 on Free, 50 on Pro/Team/Enterprise. 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'],
     },
@@ -183,7 +183,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.' },
+        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 and 50MB/call caps as recall_add; file count is capped at 10 on Free, 50 on Pro/Team/Enterprise. 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

@@ -18,7 +18,8 @@ import { pushNote } from './recall-sync.mjs';
 import { enqueueNote, isRetryableFailure, maybeAutoFlush } from './recall-queue.mjs';
 import { incrementDraftKept, incrementDraftDeleted } from './activity-counter.mjs';
 import { extractText } from './attachment-text.mjs';
-import { readAttachments, MAX_ATTACHMENTS } from './attachment-uploader.mjs';
+import { readAttachments } from './attachment-uploader.mjs';
+import { attachmentCapFor, attachmentLimitNotice, PAID_MAX_ATTACHMENTS } from './attachment-caps.mjs';
 import { TICKET_KEY_PATTERN, normalizeTicketKey } from './cli.mjs';
 import { createStyler } from './ansi.mjs';
 import { confirmDestructive } from './confirm.mjs';
@@ -43,14 +44,14 @@ function parseAttachPaths(cmdArgs) {
  * best-effort philosophy as ticket_create/comment's --attach: one bad path
  * never blocks the note from being saved.
  */
-function summarizeAttachments({ files, droppedCount }) {
+function summarizeAttachments({ files, droppedCount, cap = PAID_MAX_ATTACHMENTS }) {
   const saved = [];
   const warnings = [];
   for (const f of files) {
     if (f.ok) saved.push({ filename: f.filename, buffer: f.buffer });
     else warnings.push(`  Skipped attachment ${f.path}: ${ATTACHMENT_ERROR_MESSAGES[f.error] ?? f.error}\n`);
   }
-  if (droppedCount > 0) warnings.push(`  ${droppedCount} attachment(s) dropped — exceeds the ${MAX_ATTACHMENTS}-file limit per call.\n`);
+  if (droppedCount > 0) warnings.push(`  ${attachmentLimitNotice(droppedCount, cap)}\n`);
   return { saved, warnings };
 }
 
@@ -185,7 +186,7 @@ export async function runNoteAdd(cmdArgs, {
 
   const attachPaths = parseAttachPaths(cmdArgs);
   const { saved: attachments, warnings: attachWarnings } = attachPaths.length > 0
-    ? summarizeAttachments(readAttachmentsFn(attachPaths))
+    ? summarizeAttachments(readAttachmentsFn(attachPaths, attachmentCapFor(configDir, isLicensedFn)))
     : { saved: [], warnings: [] };
   for (const warning of attachWarnings) stream.write(warning);
 
@@ -303,7 +304,7 @@ export async function runNotePatch(cmdArgs, {
 
   const attachPaths = parseAttachPaths(cmdArgs);
   const { saved: attachments, warnings: attachWarnings } = attachPaths.length > 0
-    ? summarizeAttachments(readAttachmentsFn(attachPaths))
+    ? summarizeAttachments(readAttachmentsFn(attachPaths, attachmentCapFor(configDir, isLicensedFn)))
     : { saved: [], warnings: [] };
   for (const warning of attachWarnings) stream.write(warning);
 

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

@@ -21,7 +21,7 @@ import { detectProjectOrTypeError, enrichCreateFailure } from './ticket-create-e
 import { enrichUpdateFailure } from './ticket-update-enrichment.mjs';
 import { TICKET_KEY_PATTERN, normalizeTicketKey } from './cli.mjs';
 import { scoreCandidates } from './duplicate-scorer.mjs';
-import { MAX_ATTACHMENTS } from './attachment-uploader.mjs';
+import { attachmentCapFor, attachmentLimitNotice, PAID_MAX_ATTACHMENTS } from './attachment-caps.mjs';
 import { createStyler } from './ansi.mjs';
 
 export function parseFlag(cmdArgs, name) {
@@ -90,7 +90,7 @@ function formatAttachSummary(attachResult, s) {
   const lines = [];
   for (const u of attachResult.uploaded) lines.push(`  ${s.green('✔')} Attached ${s.bold(u.filename)}${u.url ? ` (${u.url})` : ''}\n`);
   for (const e of attachResult.errors) lines.push(`  Failed to attach ${e.path}: ${e.message}\n`);
-  if (attachResult.droppedCount > 0) lines.push(`  ${attachResult.droppedCount} attachment(s) dropped — exceeds the ${MAX_ATTACHMENTS}-file limit per call.\n`);
+  if (attachResult.droppedCount > 0) lines.push(`  ${attachmentLimitNotice(attachResult.droppedCount, attachResult.cap ?? PAID_MAX_ATTACHMENTS)}\n`);
   return lines.join('');
 }
 
@@ -345,7 +345,7 @@ export async function runTicketComment(cmdArgs, {
   let attachResult = null;
   try {
     if (attachPaths.length && !refuseGithubAttachments(adapter, attachPaths, stream)) {
-      attachResult = await adapter.attachFiles(ticketKey, attachPaths);
+      attachResult = await adapter.attachFiles(ticketKey, attachPaths, { maxAttachments: attachmentCapFor(configDir, isLicensedFn) });
     }
     const inlineSnippets = (attachResult?.uploaded ?? []).filter(a => a.inlineMarkup).map(a => a.inlineMarkup).join('\n\n');
     const finalBody = inlineSnippets ? `${body}\n\n${inlineSnippets}` : body;
@@ -1135,7 +1135,7 @@ export async function runTicketCreate(cmdArgs, {
   let attachResult = null;
   if (attachPaths.length && !attachRefused) {
     try {
-      attachResult = await adapter.attachFiles(result.key, attachPaths);
+      attachResult = await adapter.attachFiles(result.key, attachPaths, { maxAttachments: attachmentCapFor(configDir, isLicensedFn) });
 
       // Linear has no separate attachment list on an issue — unlike Jira's
       // classic attachment (real regardless of description text), an