ticketlens 0.6.0 → 0.8.0

package/README.md

@@ -133,6 +133,9 @@ ticketlens triage --stale=3                    # Aging threshold: 3 days (defaul
 ticketlens triage --status="Code Review,QA"    # Override statuses to scan
 ticketlens triage --assignee="Jane Dev"        # Another dev's tickets [Team]
 ticketlens triage --sprint="Sprint 12"         # Filter by sprint [Team]
+ticketlens triage --project=MYPROJ             # Scope to a Jira project key [Team]
+ticketlens triage --label=Bug,P1               # Filter by label(s) [Team]
+ticketlens triage --priority=High              # Filter by priority level [Team]
 ticketlens triage --export=csv                 # Export results to CSV [Team]
 ticketlens triage --export=json                # Export results to JSON [Team]
 ticketlens triage --push                       # Push snapshot to Console queue [Team]
@@ -352,6 +355,29 @@ Requires a Pro license. No network call — reads local snapshots only.
 
 ---
 
+### Response-Time Stats
+
+```bash
+ticketlens stats                         # Personal metrics from local triage history
+ticketlens stats --profile=acme          # Metrics for a specific profile
+ticketlens stats --days=14               # Extend lookback window [Pro, max 30]
+ticketlens stats --format=json           # JSON output for scripting
+ticketlens stats --format=json | jq '.avgResponseHours'
+```
+
+Shows avg/median response time, clear rate (resolved within 24h), triage run count, and week-over-week trend — all computed from local `~/.ticketlens/triage-history/` snapshots. No network call.
+
+- **Free**: last 7 days (fixed)
+- **Pro**: `--days=N` up to 30 days
+
+A one-line summary footer is also appended automatically to `ticketlens triage` output once you have 2 or more triage runs:
+
+```
+── This week: avg 3.2h response · 80% cleared within 24h (5 runs) ──
+```
+
+---
+
 ### Custom Attention Rules
 
 Add an `attentionRules` array to any profile in `~/.ticketlens/profiles.json` to override how `ticketlens triage` scores specific tickets:
@@ -519,6 +545,10 @@ ticketlens triage --static                   # Static table output (no interacti
 ticketlens triage --plain                    # Plain markdown — pipe to LLM or file
 ticketlens triage --assignee="Jane Dev"      # View another dev's tickets [Team]
 ticketlens triage --sprint="Sprint 12"       # Filter by sprint name [Team]
+ticketlens triage --project=MYPROJ           # Scope to a Jira project key [Team]
+ticketlens triage --label=Bug,P1             # Filter by label(s) [Team]
+ticketlens triage --priority=High            # Filter by priority level [Team]
+ticketlens triage --project=MYPROJ --label=Bug --priority=High  # Combined [Team]
 ticketlens triage --assignee="Jane Dev" --sprint="Sprint 12"  # Combined [Team]
 ticketlens triage --export=csv               # Export to CSV [Team]
 ticketlens triage --export=json              # Export to JSON [Team]
@@ -582,6 +612,12 @@ ticketlens schedule --local                   # Local-only cron/LaunchAgent —
 # ── History ───────────────────────────────────────────────────────────────────
 ticketlens history <TICKET-KEY>               # Show urgency timeline for a ticket [Pro]
 
+# ── Stats ──────────────────────────────────────────────────────────────────────
+ticketlens stats                              # Response-time metrics from local history
+ticketlens stats --profile=acme              # Metrics for a specific profile
+ticketlens stats --days=14                   # Extend lookback window (Pro, max 30)
+ticketlens stats --format=json               # JSON output for scripting
+
 # ── Compliance ────────────────────────────────────────────────────────────────
 ticketlens compliance <TICKET-KEY>            # Check ticket requirements against local diff [Pro/Free 3/mo]
 ticketlens ledger                             # View local compliance audit ledger [Pro]
@@ -701,6 +737,9 @@ Pro also unlocks configurable brief cache TTL per profile — set `cacheTtl` to
 ```bash
 ticketlens triage --assignee="Jane Dev"        # View another dev's tickets
 ticketlens triage --sprint="Sprint 12"         # Filter by sprint name
+ticketlens triage --project=MYPROJ             # Scope to a Jira project key
+ticketlens triage --label=Bug,P1               # Filter by label(s)
+ticketlens triage --priority=High              # Filter by priority level
 ticketlens triage --export=csv                 # Export triage to CSV for standups and reports
 ticketlens triage --export=json                # Machine-readable export for dashboards
 ticketlens triage --push                       # Push snapshot to the Console queue

package/bin/ticketlens.mjs

@@ -24,8 +24,9 @@ import {
   printProfilesHelp, printScheduleHelp,
   printInitHelp, printSwitchHelp, printConfigHelp,
   printReviewHelp, printStandupHelp, printUpdateSkillHelp,
-  printCollisionsHelp,
+  printCollisionsHelp, printStatsHelp,
 } from '../skills/jtb/scripts/lib/help.mjs';
+import { runStats } from '../skills/jtb/scripts/lib/run-stats.mjs';
 import { createStyler } from '../skills/jtb/scripts/lib/ansi.mjs';
 import { readCliToken, saveCliToken, deleteCliToken } from '../skills/jtb/scripts/lib/cli-auth.mjs';
 import { browserLogin } from '../skills/jtb/scripts/lib/browser-login.mjs';
@@ -103,6 +104,15 @@ switch (command) {
     break;
   }
 
+  case 'stats': {
+    if (cmdArgs.includes('--help') || cmdArgs.includes('-h')) { printStatsHelp(); break; }
+    runStats(cmdArgs).catch(err => {
+      process.stderr.write(`Error: ${err.message}\n`);
+      process.exitCode = 1;
+    });
+    break;
+  }
+
   case 'init':
     if (cmdArgs.includes('--help') || cmdArgs.includes('-h')) { printInitHelp(); break; }
     runInit().catch(err => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "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.6.0 -->
+<!-- jtb-skill-version: 0.8.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.
@@ -29,9 +29,15 @@ Fetches a Jira ticket and produces a structured brief with code references, then
 /jtb triage --profile=acme             # explicit profile override
 /jtb triage --all                      # triage all configured profiles at once, merged (Pro)
 /jtb triage --save=~/triage.txt        # save ANSI-stripped output to file (Pro)
+/jtb triage --project=MYPROJ           # scope to a Jira project key (Team)
+/jtb triage --label=Bug,P1             # filter by label(s) (Team)
+/jtb triage --priority=High            # filter by priority level (Team)
 /jtb triage --push                     # push snapshot + git branches to Console (Team)
 /jtb triage --share                    # generate 24h share URL (Team)
 /jtb history PROD-1234                 # show urgency timeline for a ticket (Pro)
+/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 collisions                        # show branch collisions with teammates (Team)
 /jtb collisions --json                 # machine-readable output
 ```

package/skills/jtb/scripts/fetch-my-tickets.mjs

@@ -65,20 +65,15 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
     printTriageHelp();
     return;
   }
-  // Normalize --project= alias once at entry so all recursive calls only see --profile=
-  const projectArg = args.find(a => a.startsWith('--project='));
-  if (projectArg) {
-    process.stderr.write(`Hint: --project recognized as alias for --profile=${projectArg.split('=')[1]}\n\n`);
-    args = args.map(a => a.startsWith('--project=') ? `--profile=${a.split('=')[1]}` : a);
-  }
-
   const profileArg = args.find(a => a.startsWith('--profile='));
   const profileName = profileArg ? profileArg.split('=')[1] : undefined;
 
   const validatedArgs = await handleUnknownFlags(
     args,
-    ['--help', '-h', '--static', '--plain', '--styled', '--profile=', '--stale=', '--status=', '--assignee=', '--sprint=', '--export=', '--digest', '--push', '--share', '--all', '--save='],
-    { hints: ['--depth=', '--no-attachments', '--no-cache'] } // fetch-only flags — shown as hints, not applied
+    ['--help', '-h', '--static', '--plain', '--styled', '--profile=', '--stale=', '--status=',
+     '--assignee=', '--sprint=', '--export=', '--digest', '--push', '--share', '--all', '--save=',
+     '--project=', '--label=', '--priority='],
+    { hints: ['--depth=', '--no-attachments', '--no-cache'] }
   );
   if (validatedArgs === null) { process.exitCode = 1; return; }
   args = validatedArgs;
@@ -89,9 +84,12 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
   const staleArg = args.find(a => a.startsWith('--stale='));
   const staleDays = staleArg ? parseInt(staleArg.split('=')[1], 10) : 5;
 
-  const statusArg = args.find(a => a.startsWith('--status='));
+  const statusArg   = args.find(a => a.startsWith('--status='));
   const assigneeArg = args.find(a => a.startsWith('--assignee='));
-  const sprintArg = args.find(a => a.startsWith('--sprint='));
+  const sprintArg   = args.find(a => a.startsWith('--sprint='));
+  const projectArg  = args.find(a => a.startsWith('--project='));
+  const labelArg    = args.find(a => a.startsWith('--label='));
+  const priorityArg = args.find(a => a.startsWith('--priority='));
   const exportArg = args.find(a => a.startsWith('--export='))?.split('=')[1] ?? null;
   const digestFlag = args.includes('--digest');
   const pushFlag = args.includes('--push');
@@ -125,6 +123,16 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
     } catch { /* doesn't exist yet — ok */ }
   }
 
+  // --project / --label / --priority: Team gate
+  if (projectArg || labelArg || priorityArg) {
+    if (!licensedFn('team', configDir)) {
+      const flag = projectArg ? '--project' : labelArg ? '--label' : '--priority';
+      upgradeFn('team', flag);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
   // --all: triage all configured profiles in parallel with live status block
   if (allFlag) {
     if (!licensedFn('pro', configDir)) {
@@ -270,10 +278,16 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
     : conn.triageStatuses || DEFAULT_STATUSES;
 
   // Build JQL before any I/O — pure computation, no dependency on currentUser
-  const statusList    = statuses.map(s => `"${escapeJql(s)}"`).join(',');
+  const statusList     = statuses.map(s => `"${escapeJql(s)}"`).join(',');
   const assigneeClause = assigneeName ? `assignee = "${escapeJql(assigneeName)}"` : `assignee = currentUser()`;
   const sprintClause   = sprintName   ? ` AND sprint = "${escapeJql(sprintName)}"` : '';
-  const jql = `${assigneeClause} AND status IN (${statusList})${sprintClause} ORDER BY updated DESC`;
+  const projectClause  = projectArg   ? ` AND project = "${escapeJql(projectArg.split('=')[1])}"` : '';
+  const labelValues    = labelArg ? labelArg.split('=')[1].split(',').map(l => l.trim()).filter(Boolean) : [];
+  const labelClause    = labelValues.length > 1
+    ? ` AND labels IN (${labelValues.map(l => `"${escapeJql(l)}"`).join(',')})`
+    : labelValues.length === 1 ? ` AND labels = "${escapeJql(labelValues[0])}"` : '';
+  const priorityClause = priorityArg  ? ` AND priority = "${escapeJql(priorityArg.split('=')[1])}"` : '';
+  const jql = `${assigneeClause} AND status IN (${statusList})${sprintClause}${projectClause}${labelClause}${priorityClause} ORDER BY updated DESC`;
 
   const session = createSession(conn);
   session.spin(`Connecting to ${session.label}…`);
@@ -421,7 +435,7 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
         await import('./lib/triage-history.mjs');
       const yesterday = loadYesterdaySnapshot({ profile: profileName ?? 'default', configDir });
       if (yesterday) {
-        const deltas = diffSnapshots(sorted, yesterday);
+        const deltas = diffSnapshots(sorted, yesterday.tickets);
         delta = buildDeltaSection(deltas) || null;
       }
     } catch { /* non-fatal — digest still sends */ }
@@ -515,6 +529,49 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
 
   const printFn = opts.print ?? ((s) => process.stdout.write(s));
   printFn(summary + '\n');
+
+  // Inline stats footer — shown when ≥2 triage runs exist (non-fatal)
+  try {
+    const metricsInjector = opts.metricsInjector;
+    let metrics;
+    if (metricsInjector) {
+      metrics = metricsInjector();
+    } else {
+      const { computeResponseMetrics } = await import('./lib/triage-history.mjs');
+      metrics = computeResponseMetrics(profileName ?? 'default', { days: 7, configDir });
+    }
+    // Only show footer when there's a meaningful metric to display
+    const hasAvg = metrics && metrics.avgResponseHours !== null;
+    const hasClearRate = metrics && metrics.clearRate !== null;
+    if (metrics && metrics.triageRunCount >= 2 && (hasAvg || hasClearRate)) {
+      const usePlain = args.includes('--plain') || !process.stdout.isTTY;
+      const runs = metrics.triageRunCount;
+
+      let part;
+      if (hasAvg && hasClearRate) {
+        part = `avg ${metrics.avgResponseHours.toFixed(1)}h response · ${Math.round(metrics.clearRate * 100)}% cleared within 24h (${runs} runs)`;
+      } else if (hasAvg) {
+        part = `avg ${metrics.avgResponseHours.toFixed(1)}h response (${runs} runs)`;
+      } else {
+        part = `${Math.round(metrics.clearRate * 100)}% cleared within 24h (${runs} runs)`;
+      }
+
+      if (usePlain) {
+        printFn(`── This week: ${part} ──\n`);
+      } else {
+        const { dim, bold: boldFn, cyan } = await import('./lib/ansi.mjs');
+        let styledPart;
+        if (hasAvg && hasClearRate) {
+          styledPart = `avg ${boldFn(cyan(metrics.avgResponseHours.toFixed(1) + 'h'))} response · ${boldFn(Math.round(metrics.clearRate * 100) + '%')} cleared within 24h (${runs} runs)`;
+        } else if (hasAvg) {
+          styledPart = `avg ${boldFn(cyan(metrics.avgResponseHours.toFixed(1) + 'h'))} response (${runs} runs)`;
+        } else {
+          styledPart = `${boldFn(Math.round(metrics.clearRate * 100) + '%')} cleared within 24h (${runs} runs)`;
+        }
+        printFn(`${dim('──')} This week: ${styledPart} ${dim('──')}\n`);
+      }
+    }
+  } catch { /* non-fatal */ }
 }
 
 // Run if invoked directly

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

@@ -114,6 +114,10 @@ export function parseCommand(args) {
     return { command: 'history', args: args.slice(1) };
   }
 
+  if (first === 'stats') {
+    return { command: 'stats', args: args.slice(1) };
+  }
+
   // Anything that looks like a ticket key or any non-flag arg → fetch
   return { command: 'fetch', args };
 }

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

@@ -43,6 +43,7 @@ export function printHelp({ stream = process.stdout } = {}) {
     `    ${s.brand('ticketlens')} standup ${s.dim('[--since=N]')}        Standup summary from git log  ${s.dim('(last 24h by default)')}`,
     `    ${s.brand('ticketlens')} compliance ${s.dim('<TICKET-KEY>')}    Check requirements coverage  ${s.dim('[Pro/Free 3/mo]')}`,
     `    ${s.brand('ticketlens')} history ${s.dim('<TICKET-KEY>')}       Urgency timeline for a ticket  ${s.dim('[Pro]')}`,
+    `    ${s.brand('ticketlens')} stats ${s.dim('[options]')}            Personal response-time metrics from local history`,
     '',
     `    ${s.brand('ticketlens')} delete ${s.dim('<PROFILE-NAME>')}     Remove a profile`,
     `    ${s.brand('ticketlens')} activate ${s.dim('<KEY>')}           Activate a license key`,
@@ -77,6 +78,9 @@ export function printHelp({ stream = process.stdout } = {}) {
     `    ${s.brand('--status')}=${s.dim('X,Y')}       Override statuses to scan`,
     `    ${s.brand('--assignee')}=${s.dim('NAME')}    Triage another dev's tickets  ${s.dim('[Team]')}`,
     `    ${s.brand('--sprint')}=${s.dim('NAME')}      Filter by sprint name  ${s.dim('[Team]')}`,
+    `    ${s.brand('--project')}=${s.dim('PROJ')}     Filter by Jira project key  ${s.dim('[Team]')}`,
+    `    ${s.brand('--label')}=${s.dim('X,Y')}        Filter by label(s)  ${s.dim('[Team]')}`,
+    `    ${s.brand('--priority')}=${s.dim('LEVEL')}   Filter by priority  ${s.dim('(e.g. High, Blocker) [Team]')}`,
     `    ${s.brand('--export')}=${s.dim('FORMAT')}   Export results to file  ${s.dim('(csv|json) [Team]')}`,
     `    ${s.brand('--push')}             Push snapshot to Console queue  ${s.dim('[Team]')}`,
     `    ${s.brand('--share')}            Generate a 24h share URL  ${s.dim('(no login required) [Team]')}`,
@@ -549,6 +553,9 @@ export function printTriageHelp({ stream = process.stdout } = {}) {
     `    ${s.brand('--status')}=${s.dim('X,Y')}       Override statuses to scan`,
     `    ${s.brand('--assignee')}=${s.dim('NAME')}    Triage another dev's tickets  ${s.dim('[Team]')}`,
     `    ${s.brand('--sprint')}=${s.dim('NAME')}      Filter by sprint name  ${s.dim('[Team]')}`,
+    `    ${s.brand('--project')}=${s.dim('PROJ')}     Filter by Jira project key  ${s.dim('[Team]')}`,
+    `    ${s.brand('--label')}=${s.dim('X,Y')}        Filter by label(s)  ${s.dim('[Team]')}`,
+    `    ${s.brand('--priority')}=${s.dim('LEVEL')}   Filter by priority  ${s.dim('(e.g. High, Blocker) [Team]')}`,
     `    ${s.brand('--export')}=${s.dim('FORMAT')}    Export results to file  ${s.dim('(csv|json) [Team]')}`,
     `    ${s.brand('--push')}             Push snapshot to Console queue  ${s.dim('[Team]')}`,
     `    ${s.brand('--share')}            Generate a 24h share URL  ${s.dim('(no login required) [Team]')}`,
@@ -565,6 +572,8 @@ export function printTriageHelp({ stream = process.stdout } = {}) {
     `    ${s.dim('$')} ticketlens triage --profile=acme`,
     `    ${s.dim('$')} ticketlens triage --stale=3 --status="Code Review,QA Testing"`,
     `    ${s.dim('$')} ticketlens triage --assignee="Jane Dev" --sprint="Sprint 12"`,
+    `    ${s.dim('$')} ticketlens triage --project=MYPROJ --priority=High`,
+    `    ${s.dim('$')} ticketlens triage --label=Bug,P1`,
     `    ${s.dim('$')} ticketlens triage --static`,
     '',
     `  ${s.bold('INTERACTIVE MODE')}`,
@@ -680,6 +689,36 @@ export function printCollisionsHelp({ stream = process.stdout } = {}) {
   stream.write(lines.join('\n') + '\n');
 }
 
+export function printStatsHelp({ stream = process.stdout } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  const lines = [
+    '',
+    `  ${s.bold(s.brand('ticketlens'))} ${s.bold('stats')} ${s.dim('[--days=N] [--format=plain|json] [--profile=NAME]')}`,
+    '',
+    `  Show response-time and triage-cadence metrics from your local triage history.`,
+    `  Reads daily snapshots captured by ${s.brand('ticketlens triage --push')} or the CLI.`,
+    '',
+    `  ${s.bold('OPTIONS')}`,
+    '',
+    // visible widths: "--days=N"=8, "--format=plain"=14, "--format=json"=13,
+    // "--profile=NAME"=14, "-h, --help"=10  →  target col = 19
+    `    ${s.brand('--days')}=${s.dim('N')}           Lookback window in days  ${s.dim('(default: 7, Free max: 7, Pro max: 30)')}`,
+    `    ${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('--profile')}=${s.dim('NAME')}     Use a specific tracker profile`,
+    `    ${s.brand('-h')}, ${s.brand('--help')}         Show this help`,
+    '',
+    `  ${s.bold('EXAMPLES')}`,
+    '',
+    `    ${s.dim('$')} ticketlens stats`,
+    `    ${s.dim('$')} ticketlens stats --days=14             ${s.dim('# Pro only')}`,
+    `    ${s.dim('$')} ticketlens stats --format=json | jq .`,
+    `    ${s.dim('$')} ticketlens stats --profile=myteam`,
+    '',
+  ];
+  stream.write(lines.join('\n') + '\n');
+}
+
 export function printStandupHelp({ stream = process.stdout } = {}) {
   const s = createStyler({ isTTY: stream.isTTY });
   const lines = [

package/skills/jtb/scripts/lib/run-stats.mjs

@@ -0,0 +1,122 @@
+import { computeResponseMetrics, DEFAULT_CONFIG_DIR } from './triage-history.mjs';
+import { loadProfiles } from './profile-resolver.mjs';
+import { isLicensed as defaultIsLicensed } from './license.mjs';
+import { createStyler } from './ansi.mjs';
+import { handleUnknownFlags } from './arg-validator.mjs';
+import { printStatsHelp } from './help.mjs';
+
+const FREE_DAYS_CAP = 7;
+const MAX_DAYS = 30;
+
+export async function runStats(args = [], opts = {}) {
+  const print     = opts.print            ?? ((s) => process.stdout.write(s));
+  const warn      = opts.warn             ?? ((s) => process.stderr.write(s));
+  const configDir = opts.configDir        ?? DEFAULT_CONFIG_DIR;
+  const isLic     = opts.isLicensed       ?? defaultIsLicensed;
+  const calcMetrics = opts.metricsCalculator ?? computeResponseMetrics;
+
+  if (args.includes('--help') || args.includes('-h')) {
+    printStatsHelp();
+    return;
+  }
+
+  const validated = await handleUnknownFlags(
+    args,
+    ['--help', '-h', '--profile=', '--days=', '--format='],
+    { hints: [] },
+  );
+  if (validated === null) { process.exitCode = 1; return; }
+
+  const profileArg = args.find(a => a.startsWith('--profile='));
+  const daysArg    = args.find(a => a.startsWith('--days='));
+  const formatArg  = args.find(a => a.startsWith('--format='));
+
+  const format = formatArg ? formatArg.split('=')[1] : 'plain';
+  if (format !== 'plain' && format !== 'json') {
+    warn(`Error: --format must be plain or json, got: ${format}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const rawDays = daysArg ? daysArg.split('=')[1] : '7';
+  const parsedDays = parseInt(rawDays, 10);
+  if (isNaN(parsedDays) || parsedDays < 1 || parsedDays > MAX_DAYS) {
+    warn(`Error: --days must be between 1 and ${MAX_DAYS}, got: ${rawDays}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // Free tier: silently cap at 7 days
+  const isPro = isLic('pro', configDir);
+  const days  = (!isPro && parsedDays > FREE_DAYS_CAP) ? FREE_DAYS_CAP : parsedDays;
+
+  // Resolve profile name
+  let profile = profileArg ? profileArg.split('=')[1] : null;
+  if (!profile) {
+    const config = loadProfiles(configDir);
+    profile = config?.default ?? 'default';
+  }
+
+  let metrics;
+  try {
+    metrics = calcMetrics(profile, { days, configDir });
+  } catch (err) {
+    warn(`Error: Could not compute stats for profile "${profile}": ${err.message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (format === 'json') {
+    print(JSON.stringify({ profile, ...metrics }, null, 2) + '\n');
+    return;
+  }
+
+  const isTTY = process.stdout.isTTY;
+  const s = createStyler({ isTTY });
+
+  if (metrics.triageRunCount === 0) {
+    print(`\n  ${s.dim('No triage history found for profile')} ${s.bold(profile)}.\n`);
+    print(`  ${s.dim('Run')} ${s.cyan('ticketlens triage')} ${s.dim('at least twice to generate stats.')}\n\n`);
+    return;
+  }
+
+  const fmtH   = (h) => h != null ? `${h.toFixed(1)}h` : '—';
+  const fmtPct = (r) => r != null ? `${Math.round(r * 100)}%` : '—';
+  const fmtTrend = (t) => {
+    if (t == null) return '';
+    const abs = Math.abs(t).toFixed(1);
+    return t > 0
+      ? s.dim(`  ↑ +${abs}h vs prior week`)
+      : s.dim(`  ↓ -${abs}h vs prior week`);
+  };
+
+  const W = 52;
+  const bar = s.dim('─'.repeat(W));
+  const dayLabel = `last ${days} day${days === 1 ? '' : 's'}`;
+
+  print('\n');
+  print(`${bar}\n`);
+  print(`  ${s.bold('Response Metrics')} ${s.dim(`(${dayLabel})`)}\n`);
+  print(`${bar}\n`);
+  print(`  Avg response time    ${s.bold(s.cyan(fmtH(metrics.avgResponseHours)))}${fmtTrend(metrics.trendHours)}\n`);
+  print(`  Median response time ${s.bold(fmtH(metrics.medianResponseHours))}\n`);
+  print(`  Clear rate           ${s.bold(fmtPct(metrics.clearRate))}  ${s.dim('(resolved within 24h)')}\n`);
+  print(`  Triage runs          ${s.bold(String(metrics.triageRunCount))} ${s.dim(`of ${days} days`)}\n`);
+
+  if (metrics.currentUrgency) {
+    const u = metrics.currentUrgency;
+    print(`${bar}\n`);
+    print(`  ${s.bold('Right now')}\n`);
+    print(`${bar}\n`);
+    if (u.needsResponse > 0) print(`  ${s.red('needs-response')}  ${s.bold(String(u.needsResponse))}\n`);
+    if (u.aging > 0)         print(`  ${s.yellow('aging')}           ${s.bold(String(u.aging))}\n`);
+    print(`  ${s.green('clear')}           ${s.bold(String(u.clear))}\n`);
+  }
+
+  if (!isPro) {
+    print(`${bar}\n`);
+    print(`  ${s.dim('💡 Pro unlocks --days up to 30 days · $9/mo →')} ${s.cyan('ticketlens.dev')}\n`);
+  }
+
+  print('\n');
+}

package/skills/jtb/scripts/lib/triage-history.mjs

@@ -8,7 +8,7 @@ import * as defaultFs from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-const DEFAULT_CONFIG_DIR = join(homedir(), '.ticketlens');
+export const DEFAULT_CONFIG_DIR = join(homedir(), '.ticketlens');
 
 const URGENCY_ORDER = { 'needs-response': 0, 'aging': 1, 'clear': 2 };
 
@@ -16,6 +16,17 @@ const URGENCY_ORDER = { 'needs-response': 0, 'aging': 1, 'clear': 2 };
 // Internal helpers
 // ---------------------------------------------------------------------------
 
+function median(arr) {
+  if (!arr.length) return null;
+  const sorted = [...arr].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
 function validateProfile(profile) {
   if (!profile || /[/\\]/.test(profile) || profile === '..' || profile.includes('..')) {
     throw new Error('Invalid profile name');
@@ -59,7 +70,8 @@ export function saveTriageSnapshot(tickets, {
   const dir = join(configDir, 'triage-history', dateStr);
   fsModule.mkdirSync(dir, { recursive: true });
   const filePath = snapshotPath(configDir, dateStr, profile);
-  fsModule.writeFileSync(filePath, JSON.stringify(tickets, null, 2), 'utf8');
+  const envelope = { captured_at: now.toISOString(), tickets };
+  fsModule.writeFileSync(filePath, JSON.stringify(envelope, null, 2), 'utf8');
 }
 
 /**
@@ -70,7 +82,7 @@ export function saveTriageSnapshot(tickets, {
  * @param {string} [opts.configDir]
  * @param {object} [opts.fsModule]
  * @param {Date}   [opts.now]
- * @returns {object[]|null}
+ * @returns {{ captured_at: string|null, tickets: object[] }|null}
  */
 export function loadYesterdaySnapshot({
   profile,
@@ -85,7 +97,9 @@ export function loadYesterdaySnapshot({
   const filePath = snapshotPath(configDir, dateStr, profile);
   try {
     const raw = fsModule.readFileSync(filePath, 'utf8');
-    return JSON.parse(raw);
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) return { captured_at: null, tickets: parsed };
+    return parsed;
   } catch {
     return null;
   }
@@ -201,11 +215,12 @@ export function queryTicketHistory(ticketKey, {
       const profile = file.slice(0, -5); // strip .json
       let tickets;
       try {
-        tickets = JSON.parse(fsModule.readFileSync(join(dayDir, file), 'utf8'));
+        const raw = JSON.parse(fsModule.readFileSync(join(dayDir, file), 'utf8'));
+        tickets = Array.isArray(raw) ? raw : (raw.tickets ?? []);
       } catch {
         continue;
       }
-      const found = Array.isArray(tickets) && tickets.find(t => t.ticketKey === ticketKey);
+      const found = tickets.find(t => t.ticketKey === ticketKey);
       if (found) {
         entries.push({
           date,
@@ -230,3 +245,134 @@ export function queryTicketHistory(ticketKey, {
 
   return entries;
 }
+
+/**
+ * Load a snapshot file for an arbitrary date string. Returns { captured_at, tickets } or null.
+ *
+ * @param {string} dateStr - YYYY-MM-DD
+ * @param {string} profile
+ * @param {string} configDir
+ * @param {object} fsModule
+ * @returns {{ captured_at: string|null, tickets: object[] }|null}
+ */
+function loadSnapshotForDate(dateStr, profile, configDir, fsModule) {
+  const filePath = snapshotPath(configDir, dateStr, profile);
+  try {
+    const parsed = JSON.parse(fsModule.readFileSync(filePath, 'utf8'));
+    if (Array.isArray(parsed)) return { captured_at: null, tickets: parsed };
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Compute response-time and triage-cadence metrics from local triage history.
+ *
+ * A "response transition" is detected when a ticket appears as `needs-response`
+ * in snapshot D and `clear` in snapshot D+1. Response time = captured_at of the
+ * clear snapshot minus lastComment.created of the needs-response snapshot.
+ *
+ * @param {string} profile
+ * @param {object} [opts]
+ * @param {number} [opts.days=7]            Lookback window in calendar days
+ * @param {string} [opts.configDir]
+ * @param {object} [opts.fsModule]
+ * @param {Date}   [opts.now]
+ * @returns {{
+ *   avgResponseHours: number|null,
+ *   medianResponseHours: number|null,
+ *   clearRate: number|null,
+ *   triageRunCount: number,
+ *   currentUrgency: { needsResponse: number, aging: number, clear: number }|null,
+ *   windowDays: number,
+ *   trendHours: number|null,
+ * }}
+ */
+export function computeResponseMetrics(profile, {
+  days = 7,
+  configDir = DEFAULT_CONFIG_DIR,
+  fsModule = defaultFs,
+  now = new Date(),
+} = {}) {
+  validateProfile(profile);
+
+  function windowSnapshots(offsetStart, count) {
+    const snaps = [];
+    for (let i = offsetStart + count - 1; i >= offsetStart; i--) {
+      const d = new Date(now);
+      d.setDate(d.getDate() - i);
+      const dateStr = toDateString(d);
+      const snap = loadSnapshotForDate(dateStr, profile, configDir, fsModule);
+      if (snap) snaps.push({ dateStr, ...snap });
+    }
+    return snaps; // chronological order (oldest first)
+  }
+
+  function computeFromSnaps(snaps) {
+    const durations = [];
+    let transitions = 0;
+    let fastTransitions = 0;
+
+    for (let i = 0; i + 1 < snaps.length; i++) {
+      const dayA = snaps[i];
+      const dayB = snaps[i + 1];
+      const mapA = new Map(dayA.tickets.map(t => [t.ticketKey, t]));
+
+      for (const tb of dayB.tickets) {
+        if (tb.urgency !== 'clear') continue;
+        const ta = mapA.get(tb.ticketKey);
+        if (!ta || ta.urgency !== 'needs-response') continue;
+
+        transitions++;
+        const commentCreated = ta.lastComment?.created;
+        const clearedAt = dayB.captured_at;
+        if (!commentCreated || !clearedAt) continue;
+
+        const ms = new Date(clearedAt).getTime() - new Date(commentCreated).getTime();
+        if (isNaN(ms) || ms < 0) continue;
+        const hours = ms / 3_600_000;
+        durations.push(hours);
+        if (hours <= 24) fastTransitions++;
+      }
+    }
+
+    return {
+      avgResponseHours: durations.length ? durations.reduce((a, b) => a + b, 0) / durations.length : null,
+      medianResponseHours: median(durations),
+      clearRate: durations.length > 0 ? fastTransitions / durations.length : null,
+      triageRunCount: snaps.length,
+    };
+  }
+
+  const currentSnaps = windowSnapshots(0, days);
+  const current = computeFromSnaps(currentSnaps);
+
+  // Current urgency from the most recent snapshot
+  const latest = currentSnaps[currentSnaps.length - 1] ?? null;
+  const currentUrgency = latest
+    ? {
+        needsResponse: latest.tickets.filter(t => t.urgency === 'needs-response').length,
+        aging:         latest.tickets.filter(t => t.urgency === 'aging').length,
+        clear:         latest.tickets.filter(t => t.urgency === 'clear').length,
+      }
+    : null;
+
+  // Trend: compare current window avg vs prior window avg
+  const priorSnaps = windowSnapshots(days, days);
+  const prior = computeFromSnaps(priorSnaps);
+  const trendHours =
+    current.avgResponseHours !== null && prior.avgResponseHours !== null
+      ? current.avgResponseHours - prior.avgResponseHours
+      : null;
+
+  return {
+    avgResponseHours: current.avgResponseHours,
+    medianResponseHours: current.medianResponseHours,
+    clearRate: current.clearRate,
+    triageRunCount: current.triageRunCount,
+    currentUrgency,
+    windowDays: days,
+    trendHours,
+  };
+}