ticketlens 0.38.54 → 0.38.56

package/README.md

@@ -462,7 +462,7 @@ Every note is scanned before saving — anything shaped like a real secret (API
 
 **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; `compliance` additionally accepts `consensus: true` (Pro) to replace the local deterministic matcher with a multi-agent AI review, run server-side against a "consensus" role configured at Console > Admin > AI Roles (2+ providers from the team's shared pool), and always implies `--yes` under MCP since there's no TTY for the cost-confirmation prompt; `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).
+**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; `compliance` additionally accepts `consensus: true` (Pro) to replace the local deterministic matcher with a multi-agent AI review, run server-side against a "consensus" role configured at Console > Admin > AI Roles (2+ providers from the team's shared pool), and always implies `--yes` under MCP since there's no TTY for the cost-confirmation prompt; `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; accepts an optional `project` to skip the full scan and return just that one project's types (3-day cache, vs. 7-day for the full scan); 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.
 
@@ -508,7 +508,7 @@ Write directly to the ticket in its real tracker — Jira, GitHub, or Linear —
 
 `--attach=path1,path2` (comma-separated local file paths) is available on `comment` and `create` only. Images render as an inline thumbnail on Jira and Linear; GitHub has no attachment upload API, so `--attach` is unsupported there.
 
-**A bad `--project`/`--type` gets a better error, automatically.** If create fails because the project or issue type doesn't exist, TicketLens fetches your tracker's real, current project list (and, for Jira, the real issue types for that project) and shows them alongside the failure — e.g. `Known creatable projects: CNV1, CNV2.` — rather than a bare tracker error. This is reactive only: it never runs on a successful create, never auto-retries the write, and is cached locally per profile for 24h so a burst of failed attempts doesn't re-fetch every time. `ticketlens issue-types` (below) is the proactive counterpart — pre-fetches and caches the same data ahead of time, so a `create` right after it is a pure cache hit.
+**A bad `--project`/`--type` gets a better error, automatically.** If create fails because the project or issue type doesn't exist, TicketLens fetches your tracker's real, current project list (and, for Jira, the real issue types for that project) and shows them alongside the failure — e.g. `Known creatable projects: CNV1, CNV2.` — rather than a bare tracker error. This is reactive only: it never runs on a successful create, never auto-retries the write, and is cached locally per profile for 3 days (a targeted, single-project lookup — same bar `issue-types --project=KEY` uses) so a burst of failed attempts doesn't re-fetch every time. `ticketlens issue-types` (below) is the proactive counterpart — pre-fetches and caches the same data ahead of time, so a `create` right after it is a pure cache hit.
 
 All six write actions (comment/transition/assign/link/update/create) have a short local debounce (10s) against an accidental double-fire (a flaky retry, hitting enter twice), and every successful write is appended to a local, append-only audit log (`~/.ticketlens/ticket-action-log.jsonl`). A write that times out is never retried automatically — unlike Recall notes, ticket writes aren't naturally idempotent, so a timed-out attempt is surfaced to you instead of silently repeated. `duplicates` has neither, since nothing is written.
 
@@ -540,13 +540,14 @@ A one-line summary footer is also appended automatically to `ticketlens triage`
 ### Pre-fetch Issue Types
 
 ```bash
-ticketlens issue-types                   # Pre-fetch/cache the active profile's real projects + Jira issue types
+ticketlens issue-types                   # Pre-fetch/cache every project this connection sees + Jira issue types
 ticketlens issue-types --profile=acme    # Target a specific profile
+ticketlens issue-types --project=PROJ    # Only this project — skips the full scan, 3-day cache
 ticketlens issue-types --refresh         # Force a live fetch, bypassing the cache
 ticketlens issue-types --format=json     # JSON output for scripting
 ```
 
-Fetches a profile's real creatable projects and, for Jira, each project's valid issue types — the proactive counterpart to `create`'s reactive failure-message enrichment (above): a ready lookup instead of only learning them from a failed create's error. Jira only — Linear has no per-project issue-type concept and GitHub has neither, so both report a clear "not available" instead of an empty result. Free, no license gate. Shares its cache with `create`'s enrichment (`~/.ticketlens/cache/PROFILE/ticket-metadata.json`, 24h TTL), so a `create` failure right after this command is a pure cache hit, no extra network round-trip.
+Fetches a profile's real creatable projects and, for Jira, each project's valid issue types — the proactive counterpart to `create`'s reactive failure-message enrichment (above): a ready lookup instead of only learning them from a failed create's error. Jira only — Linear has no per-project issue-type concept and GitHub has neither, so both report a clear "not available" instead of an empty result. Free, no license gate. `--project=KEY` skips the full project-list scan and returns just that one project's types — a targeted, "on purpose" lookup, so it trusts its cache entry for 3 days instead of the full scan's 7. Shares its cache with `create`'s enrichment (`~/.ticketlens/cache/PROFILE/ticket-metadata.json`), so a `create` failure right after this command is a pure cache hit, no extra network round-trip.
 
 ---
 
@@ -844,8 +845,9 @@ ticketlens stats --days=14                   # Extend lookback window (Pro, max
 ticketlens stats --format=json               # JSON output for scripting
 
 # ── Issue Types ───────────────────────────────────────────────────────────────
-ticketlens issue-types                        # Pre-fetch/cache the active profile's projects + Jira issue types
+ticketlens issue-types                        # Pre-fetch/cache every project this connection sees + Jira issue types
 ticketlens issue-types --profile=acme        # Target a specific profile
+ticketlens issue-types --project=PROJ        # Only this project — skips the full scan, 3-day cache
 ticketlens issue-types --refresh             # Force a live fetch, bypassing the cache
 ticketlens issue-types --format=json         # JSON output for scripting
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.38.54",
+  "version": "0.38.56",
   "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.43.2 -->
+<!-- jtb-skill-version: 0.43.3 -->
 ---
 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.
@@ -42,7 +42,8 @@ Fetches a Jira ticket and produces a structured brief with code references, then
 /jtb stats                             # personal response-time metrics from local history
 /jtb stats --days=14                   # extend lookback window (Pro, max 30)
 /jtb stats --format=json               # JSON output for scripting
-/jtb issue-types                       # pre-fetch/cache a profile's valid Jira issue types
+/jtb issue-types                       # pre-fetch/cache every project's valid Jira issue types
+/jtb issue-types --project=PROJ        # only this project — skips the full scan, 3-day cache
 /jtb issue-types --refresh             # force a live fetch, bypassing the cache
 /jtb collisions                        # show branch collisions with teammates (Team)
 /jtb collisions --json                 # machine-readable output
@@ -160,13 +161,13 @@ Run:
 ticketlens issue-types $EXTRA_ARGS
 ```
 
-Where `$EXTRA_ARGS` are any flags passed (e.g. `--profile=acme --refresh --format=json`).
+Where `$EXTRA_ARGS` are any flags passed (e.g. `--profile=acme --project=PROJ --refresh --format=json`).
 
-Pre-fetches and caches a profile's real creatable projects and their valid Jira issue types, ahead of a `ticketlens create` attempt — a ready lookup instead of only learning them from a failed create's error message. Jira only; Linear (no per-project issue-type concept) and GitHub (neither) report a clear "not available" instead of an empty result. Free, no license gate. `--profile=NAME` (target a specific tracker profile); `--refresh` (force a live fetch even if a complete cache already exists); `--format=plain` (default, human-readable table) or `--format=json` (scripting). Shares its cache with `ticketlens create`'s own failure-message enrichment (`~/.ticketlens/cache/PROFILE/ticket-metadata.json`, 24h TTL) — a create failure right after this command is a pure cache hit.
+Pre-fetches and caches a profile's real creatable projects and their valid Jira issue types, ahead of a `ticketlens create` attempt — a ready lookup instead of only learning them from a failed create's error message. Jira only; Linear (no per-project issue-type concept) and GitHub (neither) report a clear "not available" instead of an empty result. Free, no license gate. `--profile=NAME` (target a specific tracker profile); `--project=KEY` (only this project — skips the full project scan, 3-day cache TTL since a targeted lookup is "on purpose"; without it, every project this connection can see, 7-day TTL); `--refresh` (force a live fetch even if a fresh cache entry already exists); `--format=plain` (default, human-readable table) or `--format=json` (scripting). Shares its cache with `ticketlens create`'s own failure-message enrichment (`~/.ticketlens/cache/PROFILE/ticket-metadata.json`) — a create failure right after this command is a pure cache hit.
 
 Display the script's stdout directly. No plan mode. Stop here.
 
-If this harness has TicketLens's MCP server configured (a tool named `issue_types` — often shown as `mcp__ticketlens__issue_types` — visible in your tool list), prefer it over the bash form: same Jira-only scope, same shared cache, no shell command to construct. It accepts `profile`/`refresh`/`format`.
+If this harness has TicketLens's MCP server configured (a tool named `issue_types` — often shown as `mcp__ticketlens__issue_types` — visible in your tool list), prefer it over the bash form: same Jira-only scope, same shared cache, no shell command to construct. It accepts `profile`/`project`/`refresh`/`format`.
 
 ---
 

package/skills/jtb/hooks/recall-auto-capture.mjs

@@ -33,6 +33,7 @@ import { buildCaptureExcerpt, privateTmpDir } from './recall-nudge-lib.mjs';
 import { autoCapture } from '../scripts/lib/summarizer.mjs';
 import { runNoteAdd } from '../scripts/lib/note-command.mjs';
 import { DEFAULT_CONFIG_DIR } from '../scripts/lib/config.mjs';
+import { apiBase } from '../scripts/lib/api-utils.mjs';
 
 /** Buffers stream.write() calls instead of touching a real stream — same shape mcp-server.mjs's own capturingStream() uses, this process has no real stdout/stderr worth writing to. */
 function capturingStream() {
@@ -40,9 +41,12 @@ function capturingStream() {
   return { write(s) { parts.push(s); return true; }, get text() { return parts.join(''); } };
 }
 
+// backlog #33: every outcome logs its resolved backend URL — "Unauthorized"/
+// "not logged in" reports had no way to attribute which backend was hit
+// (ngrok tunnel rotation and local-dev fallback both silently swap it).
 function logLine(message) {
   try {
-    const line = `${new Date().toISOString()} ${message}\n`;
+    const line = `${new Date().toISOString()} ${message} [api=${apiBase()}]\n`;
     appendFileSync(join(privateTmpDir(), 'auto-capture.log'), line);
   } catch { /* best-effort — losing a debug log line is not worth failing over */ }
 }
@@ -85,7 +89,7 @@ export async function runAutoCapture({
   try {
     result = await autoCaptureFn({ excerpt, ticketKey, cliToken });
   } catch (err) {
-    logLine(`error: ${err.message}`);
+    logLine(`error: ${err.message}${err.status ? ` (status=${err.status})` : ''}`);
     return { outcome: 'error', error: err.message };
   }
 

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

@@ -62,7 +62,7 @@ export function printHelp({ stream = process.stdout } = {}) {
     `    ${s.brand('ticketlens')} link ${s.dim('<SOURCE> <TARGET> [--type=... --confirm]')}  Link two tickets  ${s.dim('[Pro]')}`,
     `    ${s.brand('ticketlens')} update ${s.dim('<TICKET-KEY> [--title=... --description=... --priority=... --add-labels=... --remove-labels=...]')}  Update fields  ${s.dim('[Pro]')}`,
     `    ${s.brand('ticketlens')} create ${s.dim('--project=... [--type=...] --summary=... [--description=...] [--attach=...]')}  Create a new ticket  ${s.dim('[Pro]')}`,
-    `    ${s.brand('ticketlens')} issue-types ${s.dim('[--profile=NAME] [--refresh]')}   Pre-fetch valid Jira issue types  ${s.dim('[Jira only]')}`,
+    `    ${s.brand('ticketlens')} issue-types ${s.dim('[--profile=NAME] [--project=KEY] [--refresh]')}   Pre-fetch valid Jira issue types  ${s.dim('[Jira only]')}`,
     '',
     `    ${s.brand('ticketlens')} delete ${s.dim('<PROFILE-NAME>')}       Remove a profile`,
     `    ${s.brand('ticketlens')} activate ${s.dim('<KEY>')}              Activate a license key`,
@@ -1335,7 +1335,7 @@ export function printIssueTypesHelp({ stream = process.stdout } = {}) {
   const s = createStyler({ isTTY: stream.isTTY });
   const lines = [
     '',
-    `  ${s.bold(s.brand('ticketlens'))} ${s.bold('issue-types')} ${s.dim('[--profile=NAME] [--refresh] [--format=plain|json]')}`,
+    `  ${s.bold(s.brand('ticketlens'))} ${s.bold('issue-types')} ${s.dim('[--profile=NAME] [--project=KEY] [--refresh] [--format=plain|json]')}`,
     '',
     `  Pre-fetch and cache a profile's real creatable projects and their valid`,
     `  Jira issue types, ahead of a ${s.brand('ticketlens create')} attempt — a ready lookup`,
@@ -1343,12 +1343,14 @@ export function printIssueTypesHelp({ stream = process.stdout } = {}) {
     `  Jira only — Linear has no per-project issue-type concept and GitHub has`,
     `  neither, so both report a clear "not available" instead of an empty result.`,
     `  Shares its cache with ${s.brand('ticketlens create')}'s own failure-message enrichment`,
-    `  (${s.dim('~/.ticketlens/cache/PROFILE/ticket-metadata.json')}, 24h TTL).`,
+    `  (${s.dim('~/.ticketlens/cache/PROFILE/ticket-metadata.json')}).`,
     '',
     `  ${s.bold('OPTIONS')}`,
     '',
     `    ${s.brand('--profile')}=${s.dim('NAME')}   Use a specific tracker profile`,
-    `    ${s.brand('--refresh')}         Force a live fetch even if a complete cache exists`,
+    `    ${s.brand('--project')}=${s.dim('KEY')}     Only this project — skips the full scan, 3-day cache TTL`,
+    `                        ${s.dim('(no --project: every project this connection sees, 7-day TTL)')}`,
+    `    ${s.brand('--refresh')}         Force a live fetch even if a fresh cache entry exists`,
     `    ${s.brand('--format')}=${s.dim('plain')}    Human-readable table ${s.dim('(default)')}`,
     `    ${s.brand('--format')}=${s.dim('json')}     JSON output for scripting/piping`,
     `    ${s.brand('-h')}, ${s.brand('--help')}      Show this help`,
@@ -1357,6 +1359,7 @@ export function printIssueTypesHelp({ stream = process.stdout } = {}) {
     '',
     `    ${s.dim('$')} ticketlens issue-types`,
     `    ${s.dim('$')} ticketlens issue-types --profile=myteam --refresh`,
+    `    ${s.dim('$')} ticketlens issue-types --project=PROJ`,
     `    ${s.dim('$')} ticketlens issue-types --format=json | jq .`,
     '',
   ];

package/skills/jtb/scripts/lib/mcp-server.mjs

@@ -312,9 +312,10 @@ async function callStats(args, { configDir, runStatsFn }) {
   return callPrintWarnRun(buildStatsArgs, args, { configDir, runFn: runStatsFn }, 'stats failed');
 }
 
-function buildIssueTypesArgs({ profile, refresh, format }) {
+function buildIssueTypesArgs({ profile, project, refresh, format }) {
   const args = [];
   if (profile) args.push(`--profile=${profile}`);
+  if (project) args.push(`--project=${project}`);
   if (refresh === true) args.push('--refresh');
   if (format) args.push(`--format=${format}`);
   return args;

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

@@ -113,12 +113,13 @@ export const TOOLS = [
   },
   {
     name: 'issue_types',
-    description: 'Pre-fetch and cache a profile\'s real creatable projects and their valid Jira issue types, ahead of a `ticket_create` attempt — a ready lookup instead of only learning them from a failed create\'s error message. Jira only; Linear/GitHub report "not available" (Linear has no per-project issue-type concept, GitHub has neither). Shares its cache with ticket_create\'s own failure-message enrichment (24h TTL) — a create failure right after this call is a pure cache hit, no extra network round-trip.',
+    description: 'Pre-fetch and cache a profile\'s real creatable projects and their valid Jira issue types, ahead of a `ticket_create` attempt — a ready lookup instead of only learning them from a failed create\'s error message. Jira only; Linear/GitHub report "not available" (Linear has no per-project issue-type concept, GitHub has neither). Shares its cache with ticket_create\'s own failure-message enrichment — a create failure right after this call is a pure cache hit, no extra network round-trip. Without `project`, lists every project this connection can see (7-day cache); with `project`, skips the full scan and returns just that one project\'s issue types (3-day cache, since a targeted lookup is "on purpose" and expects fresher data).',
     inputSchema: {
       type: 'object',
       properties: {
         profile: { type: 'string', description: 'Connection profile to target, overriding folder-based inference and the default profile.' },
-        refresh: { type: 'boolean', description: 'Force a live fetch even if a complete cache already exists for this profile.' },
+        project: { type: 'string', description: 'Only fetch this project\'s issue types instead of scanning every project the connection can see. Skips the full project-list call; uses a shorter 3-day cache TTL.' },
+        refresh: { type: 'boolean', description: 'Force a live fetch even if a fresh cache entry already exists.' },
         format: { type: 'string', enum: ['plain', 'json'], description: 'Output shape: "plain" (default) is a human-readable table; "json" is structured for scripting.' },
       },
     },

package/skills/jtb/scripts/lib/run-issue-types.mjs

@@ -1,7 +1,7 @@
 import { DEFAULT_CONFIG_DIR, timeAgo } from './config.mjs';
 import { resolveConnection } from './profile-resolver.mjs';
 import { resolveAdapter } from './resolve-adapter.mjs';
-import { readMetadataCache, writeMetadataCache } from './ticket-metadata-cache.mjs';
+import { readMetadataCache, writeMetadataCache, METADATA_TTL_MS, SINGLE_PROJECT_TTL_MS, isFresh, mergeProjectIssueTypes } from './ticket-metadata-cache.mjs';
 import { createStyler } from './ansi.mjs';
 import { handleUnknownFlags } from './arg-validator.mjs';
 import { printIssueTypesHelp } from './help.mjs';
@@ -11,12 +11,23 @@ import { formatTable } from './table-formatter.mjs';
 // ticket-create-enrichment.mjs's reactive path (one project at a time, on a
 // create failure) can have projects with no recorded issue types yet. Showing
 // that as "the" answer would silently omit the rest of the profile's projects.
+// Recency is checked per-project (not just the whole file's own GC marker) —
+// a project's entry can be older than the file itself if only OTHER projects
+// were refreshed since (e.g. by an intervening --project=KEY fetch). A cache
+// written before issueTypesFetchedAt/projectsFetchedAt existed has neither
+// field, so isFresh(undefined, ...) correctly treats it as stale — one live
+// full scan repopulates both, then reuse resumes as normal.
 function isCacheComplete(cached) {
   if (!cached || cached.projects.length === 0) return false;
-  return cached.projects.every(p => (cached.issueTypesByProject[p.key] || []).length > 0);
+  if (!isFresh(cached.projectsFetchedAt, METADATA_TTL_MS)) return false;
+  return cached.projects.every(p => {
+    const types = cached.issueTypesByProject[p.key];
+    if (!types || types.length === 0) return false;
+    return isFresh(cached.issueTypesFetchedAt?.[p.key], METADATA_TTL_MS);
+  });
 }
 
-function render({ print, format, projects, issueTypesByProject, fetchedAt, cached }) {
+function render({ print, format, projects, issueTypesByProject, fetchedAt, cached, ttlLabel }) {
   if (format === 'json') {
     print(JSON.stringify({ projects, issueTypesByProject, fetchedAt, cached }, null, 2) + '\n');
     return;
@@ -38,7 +49,61 @@ function render({ print, format, projects, issueTypesByProject, fetchedAt, cache
   print(formatTable(['Project', 'Issue Types'], rows) + '\n');
   print(`\n  ${s.dim(cached
     ? `Cached ${timeAgo(fetchedAt)} — pass --refresh to force a live fetch.`
-    : 'Fetched live and cached for 24h.')}\n\n`);
+    : `Fetched live and cached for ${ttlLabel}.`)}\n\n`);
+}
+
+/**
+ * A targeted `--project=KEY` lookup — "on purpose," so it trusts a shorter
+ * SINGLE_PROJECT_TTL_MS (3d) than a full scan's 7d, and merge-writes just
+ * this one project into the shared cache instead of replacing it (same
+ * read-merge-write pattern ticket-create-enrichment.mjs already uses for
+ * its own single-project reactive path). No display name is available
+ * without the full project-list scan, so `name` is honestly null rather
+ * than guessed.
+ */
+async function runSingleProject({ print, warn, format, projectKey, forceRefresh, adapter, profileName, configDir, readMetadataCacheFn, writeMetadataCacheFn }) {
+  const cached = !forceRefresh ? readMetadataCacheFn(profileName, configDir) : null;
+  const cachedTypes = cached?.issueTypesByProject?.[projectKey];
+
+  if (cachedTypes?.length && isFresh(cached.issueTypesFetchedAt?.[projectKey], SINGLE_PROJECT_TTL_MS)) {
+    render({
+      print, format,
+      projects: [{ key: projectKey, name: null }],
+      issueTypesByProject: { [projectKey]: cachedTypes },
+      fetchedAt: cached.issueTypesFetchedAt[projectKey],
+      cached: true,
+    });
+    return { ok: true };
+  }
+
+  let types;
+  try {
+    types = await adapter.listIssueTypes(projectKey);
+  } catch (err) {
+    warn(`  Could not fetch issue types: ${err.message}\n`);
+    process.exitCode = 1;
+    return { ok: false };
+  }
+
+  const now = new Date().toISOString();
+  const { issueTypesByProject, issueTypesFetchedAt } = mergeProjectIssueTypes(cached, projectKey, types, now);
+
+  writeMetadataCacheFn(profileName, {
+    projects: cached?.projects ?? [],
+    issueTypesByProject,
+    issueTypesFetchedAt,
+    projectsFetchedAt: cached?.projectsFetchedAt ?? null,
+  }, configDir);
+
+  render({
+    print, format,
+    projects: [{ key: projectKey, name: null }],
+    issueTypesByProject: { [projectKey]: types },
+    fetchedAt: now,
+    cached: false,
+    ttlLabel: '3 days',
+  });
+  return { ok: true };
 }
 
 /**
@@ -48,6 +113,7 @@ function render({ print, format, projects, issueTypesByProject, fetchedAt, cache
  * attempt instead of only learning them from a failed create's error.
  * Writes through the same ticket-metadata-cache.mjs file/TTL that enrichment
  * reads, so a create failure right after this command is a pure cache hit.
+ * `--project=KEY` narrows to a single project — see runSingleProject above.
  *
  * @param {string[]} args
  * @returns {Promise<{ ok: boolean }>}
@@ -68,13 +134,14 @@ export async function runIssueTypes(args = [], opts = {}) {
 
   const validated = await handleUnknownFlags(
     args,
-    ['--help', '-h', '--profile=', '--refresh', '--format='],
+    ['--help', '-h', '--profile=', '--refresh', '--format=', '--project='],
     { hints: [] },
   );
   if (validated === null) { process.exitCode = 1; return { ok: false }; }
 
   const profileArg = args.find(a => a.startsWith('--profile='));
   const formatArg  = args.find(a => a.startsWith('--format='));
+  const projectArg = args.find(a => a.startsWith('--project='));
   const forceRefresh = args.includes('--refresh');
 
   const format = formatArg ? formatArg.split('=')[1] : 'plain';
@@ -84,6 +151,13 @@ export async function runIssueTypes(args = [], opts = {}) {
     return { ok: false };
   }
 
+  const projectKey = projectArg ? projectArg.split('=')[1] : undefined;
+  if (projectArg && !projectKey) {
+    warn('Error: --project requires a value, e.g. --project=PROJ\n');
+    process.exitCode = 1;
+    return { ok: false };
+  }
+
   const explicitProfile = profileArg ? profileArg.split('=')[1] : undefined;
   const cwd = opts.cwd ?? process.cwd();
   const conn = resolveConnectionFn(null, {
@@ -107,10 +181,14 @@ export async function runIssueTypes(args = [], opts = {}) {
 
   const profileName = conn.profileName ?? 'default';
 
+  if (projectKey) {
+    return runSingleProject({ print, warn, format, projectKey, forceRefresh, adapter, profileName, configDir, readMetadataCacheFn, writeMetadataCacheFn });
+  }
+
   if (!forceRefresh) {
     const cached = readMetadataCacheFn(profileName, configDir);
     if (isCacheComplete(cached)) {
-      render({ print, format, projects: cached.projects, issueTypesByProject: cached.issueTypesByProject, fetchedAt: cached.fetchedAt, cached: true });
+      render({ print, format, projects: cached.projects, issueTypesByProject: cached.issueTypesByProject, fetchedAt: cached.projectsFetchedAt, cached: true });
       return { ok: true };
     }
   }
@@ -128,7 +206,11 @@ export async function runIssueTypes(args = [], opts = {}) {
     return { ok: false };
   }
 
-  writeMetadataCacheFn(profileName, { projects, issueTypesByProject }, configDir);
-  render({ print, format, projects, issueTypesByProject, fetchedAt: new Date().toISOString(), cached: false });
+  const now = new Date().toISOString();
+  const issueTypesFetchedAt = Object.create(null);
+  for (const p of projects) issueTypesFetchedAt[p.key] = now;
+
+  writeMetadataCacheFn(profileName, { projects, issueTypesByProject, issueTypesFetchedAt, projectsFetchedAt: now }, configDir);
+  render({ print, format, projects, issueTypesByProject, fetchedAt: now, cached: false, ttlLabel: '7 days' });
   return { ok: true };
 }

package/skills/jtb/scripts/lib/ticket-create-enrichment.mjs

@@ -6,6 +6,8 @@
  * of ticket-command.mjs's routing logic.
  */
 
+import { SINGLE_PROJECT_TTL_MS, isFresh, mergeProjectIssueTypes } from './ticket-metadata-cache.mjs';
+
 /**
  * Detects whether a create failure is shaped like a project/issuetype
  * mismatch — the only case cache-refresh enrichment applies to. Jira
@@ -45,22 +47,34 @@ export async function enrichCreateFailure(err, { adapter, project, profileName,
   // hit as fully sufficient silently drops the other half of a later,
   // differently-shaped error's enrichment (caught via live-instance
   // testing, not by unit tests alone).
+  //
+  // This is a targeted, single-project fetch — "on purpose," same pattern
+  // as `issue-types --project=KEY` — so issue-types presence alone isn't
+  // enough: it must also be fresh within SINGLE_PROJECT_TTL_MS (3 days),
+  // not the longer full-scan bar.
+  const hasFreshIssueTypes = cached?.issueTypesByProject?.[project]?.length
+    && isFresh(cached?.issueTypesFetchedAt?.[project], SINGLE_PROJECT_TTL_MS);
   const needsProjects = shape.project && !cached?.projects?.length;
-  const needsIssueTypes = shape.type && adapter.type === 'jira' && project && !cached?.issueTypesByProject?.[project]?.length;
+  const needsIssueTypes = shape.type && adapter.type === 'jira' && project && !hasFreshIssueTypes;
 
   if (needsProjects || needsIssueTypes) {
     try {
       const projects = needsProjects ? await adapter.listCreatableProjects() : (cached?.projects ?? []);
-      // Object.create(null), not {} — `project` is an unvalidated CLI value
-      // reaching this key position. On a plain {}, assigning to a key like
-      // "__proto__" redirects into the object's own prototype slot instead
-      // of creating a real entry, silently losing this project's cache
-      // write. A null-prototype target has no such accessor to intercept.
-      const issueTypesByProject = Object.assign(Object.create(null), cached?.issueTypesByProject ?? {});
+      // Object.create(null), not {} — preserves any existing entries when
+      // this pass only needed `projects`, not a new issue-type fetch. See
+      // mergeProjectIssueTypes' own doc for why a null-prototype target
+      // matters once `project` (an unvalidated CLI value) reaches a key.
+      let issueTypesByProject = Object.assign(Object.create(null), cached?.issueTypesByProject ?? {});
+      let issueTypesFetchedAt = Object.assign(Object.create(null), cached?.issueTypesFetchedAt ?? {});
       if (needsIssueTypes) {
-        issueTypesByProject[project] = await adapter.listIssueTypes(project);
+        ({ issueTypesByProject, issueTypesFetchedAt } = mergeProjectIssueTypes(cached, project, await adapter.listIssueTypes(project)));
       }
-      cached = { projects, issueTypesByProject };
+      cached = {
+        projects,
+        issueTypesByProject,
+        issueTypesFetchedAt,
+        projectsFetchedAt: needsProjects ? new Date().toISOString() : (cached?.projectsFetchedAt ?? null),
+      };
       writeMetadataCacheFn(profileName, cached, configDir);
     } catch {
       return '';

package/skills/jtb/scripts/lib/ticket-metadata-cache.mjs

@@ -1,24 +1,66 @@
 /**
- * Project/issue-type metadata cache for `ticketlens create` — stores what
- * this profile has actually confirmed it can create against (real project
- * keys, real Jira issue types per project), refreshed only when a create
- * attempt fails with a project/issuetype-shaped error. Never populated on
- * the success path: that data only has value for enriching a failure
- * message, so fetching it on every create call "just in case" would waste
- * a network round-trip for the common case where the caller already got
- * project/type right.
+ * Project/issue-type metadata cache for `ticketlens create` and
+ * `ticketlens issue-types` — stores what this profile has actually
+ * confirmed it can create against (real project keys, real Jira issue
+ * types per project). Two access patterns share this file with two
+ * different freshness bars: a full scan (`issue-types` with no
+ * `--project`) trusts data for METADATA_TTL_MS (7 days); a targeted
+ * single-project lookup (`issue-types --project=KEY`, or the reactive
+ * create-failure enrichment path) is "on purpose" and trusts data for
+ * the shorter SINGLE_PROJECT_TTL_MS (3 days) instead — tracked via its
+ * own per-project `issueTypesFetchedAt[KEY]` timestamp, independent of
+ * the whole-file `fetchedAt`/`projectsFetchedAt` markers a full scan uses.
+ * Callers own the freshness decision (this module just persists whatever
+ * timestamps they pass); `fetchedAt` alone still gates this file's own
+ * read-side garbage collection (deleted once older than the ttlMs param).
  *
  * Path:   ~/.ticketlens/cache/PROFILE/ticket-metadata.json
- * Format: { fetchedAt, projects: [{key, name}], issueTypesByProject: {KEY: [{id, name}]} }
- * TTL:    24 hours (bypassed by an always-forced refresh from the caller
- *         after a project/issuetype error — see ticket-command.mjs)
+ * Format: {
+ *   fetchedAt,            // bumped on every write — GC liveness marker only
+ *   projectsFetchedAt,    // set only by a full project-list scan
+ *   projects: [{key, name}],
+ *   issueTypesByProject:  {KEY: [{id, name}]},
+ *   issueTypesFetchedAt:  {KEY: iso timestamp}  // per-project, either access pattern
+ * }
  */
 
 import fs from 'node:fs';
 import path from 'node:path';
 import { DEFAULT_CONFIG_DIR } from './config.mjs';
 
-export const METADATA_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+export const METADATA_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days — full project-list scan
+export const SINGLE_PROJECT_TTL_MS = 3 * 24 * 60 * 60 * 1000; // 3 days — targeted, "on purpose" lookup
+
+/**
+ * Shared freshness check for a single stored timestamp — used by both
+ * `issue-types --project=KEY` and the reactive create-failure enrichment
+ * path, so the two "on purpose, single project" access patterns can't
+ * silently drift onto different freshness logic over time.
+ */
+export function isFresh(isoTimestamp, ttlMs) {
+  if (!isoTimestamp) return false;
+  const age = Date.now() - new Date(isoTimestamp).getTime();
+  return !isNaN(age) && age <= ttlMs;
+}
+
+/**
+ * Merges one project's issue types into an existing (possibly null) cached
+ * map, returning a new { issueTypesByProject, issueTypesFetchedAt } pair —
+ * shared by both single-project write paths (`issue-types --project=KEY`
+ * and the reactive create-failure enrichment) so the null-prototype defense
+ * below can't independently drift or regress between them.
+ *
+ * Object.create(null), not {} — projectKey is an unvalidated CLI value
+ * reaching a key position; a plain {} lets "--project=__proto__" redirect
+ * into the object's own prototype slot instead of creating a real entry.
+ */
+export function mergeProjectIssueTypes(cached, projectKey, types, fetchedAt = new Date().toISOString()) {
+  const issueTypesByProject = Object.assign(Object.create(null), cached?.issueTypesByProject ?? {});
+  issueTypesByProject[projectKey] = types;
+  const issueTypesFetchedAt = Object.assign(Object.create(null), cached?.issueTypesFetchedAt ?? {});
+  issueTypesFetchedAt[projectKey] = fetchedAt;
+  return { issueTypesByProject, issueTypesFetchedAt };
+}
 
 /**
  * Returns the absolute path to the ticket-metadata cache file for a profile.
@@ -41,8 +83,8 @@ export function metadataCachePath(profileName, configDir = DEFAULT_CONFIG_DIR) {
  *
  * @param {string|null} profileName
  * @param {string} [configDir]
- * @param {number} [ttlMs] - override TTL in ms; defaults to METADATA_TTL_MS (24h)
- * @returns {{ projects: {key:string,name:string}[], issueTypesByProject: object, fetchedAt: string } | null}
+ * @param {number} [ttlMs] - override TTL in ms for this file's own GC deletion; defaults to METADATA_TTL_MS (7d)
+ * @returns {{ projects: {key:string,name:string}[], issueTypesByProject: object, issueTypesFetchedAt: object, projectsFetchedAt: string|null, fetchedAt: string } | null}
  */
 export function readMetadataCache(profileName, configDir = DEFAULT_CONFIG_DIR, ttlMs = METADATA_TTL_MS) {
   const filePath = metadataCachePath(profileName, configDir);
@@ -64,6 +106,8 @@ export function readMetadataCache(profileName, configDir = DEFAULT_CONFIG_DIR, t
   return {
     projects: data.projects ?? [],
     issueTypesByProject: data.issueTypesByProject ?? {},
+    issueTypesFetchedAt: data.issueTypesFetchedAt ?? {},
+    projectsFetchedAt: data.projectsFetchedAt ?? null,
     fetchedAt: data.fetchedAt,
   };
 }
@@ -71,13 +115,21 @@ export function readMetadataCache(profileName, configDir = DEFAULT_CONFIG_DIR, t
 /**
  * Writes project/issue-type metadata to the cache. Non-fatal — a write
  * failure must never break the caller (an enrichment attempt after an
- * already-failed create).
+ * already-failed create). Callers own merge-before-write for partial
+ * updates (e.g. a single-project fetch merging into an existing
+ * multi-project cache) — this function persists exactly what it's given.
  */
-export function writeMetadataCache(profileName, { projects = [], issueTypesByProject = {} } = {}, configDir = DEFAULT_CONFIG_DIR) {
+export function writeMetadataCache(profileName, { projects = [], issueTypesByProject = {}, issueTypesFetchedAt = {}, projectsFetchedAt = null } = {}, configDir = DEFAULT_CONFIG_DIR) {
   const filePath = metadataCachePath(profileName, configDir);
   try {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, JSON.stringify({ fetchedAt: new Date().toISOString(), projects, issueTypesByProject }));
+    fs.writeFileSync(filePath, JSON.stringify({
+      fetchedAt: new Date().toISOString(),
+      projectsFetchedAt,
+      projects,
+      issueTypesByProject,
+      issueTypesFetchedAt,
+    }));
   } catch {
     // Non-fatal
   }