ticketlens 0.5.0 → 0.6.0

package/README.md

@@ -137,6 +137,8 @@ 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]
 ticketlens triage --share                      # Generate 24h share URL (no login for recipient) [Team]
+ticketlens triage --all                        # Triage all profiles at once, merged output [Pro]
+ticketlens triage --save=~/triage.txt          # Save ANSI-stripped output to file [Pro]
 ticketlens triage --digest                     # POST scored results to digest endpoint [Pro]
 ticketlens triage --plain                      # Plain markdown — pipe to file or LLM
 ticketlens triage --static                     # Static table, no interactive mode
@@ -331,12 +333,48 @@ Cache locations:
 ticketlens schedule               # Interactive wizard — set digest time, timezone, profile [Pro]
 ticketlens schedule --stop        # Cancel the scheduled digest
 ticketlens schedule --status      # Show current schedule
+ticketlens schedule --local       # Local-only cron (no Console auth) — saves triage to file [Pro]
 ```
 
 Stores the schedule as a cron entry. Delivers your triage digest at the configured time without an open terminal. Requires a Pro license.
 
 ---
 
+### History
+
+```bash
+ticketlens history <TICKET-KEY>   # Show urgency timeline for a ticket [Pro]
+```
+
+Reads from your local `~/.ticketlens/triage-history/` snapshots (written automatically on each `ticketlens triage` run) and renders a day-by-day urgency timeline for the requested ticket. Entries where urgency changed direction are flagged as "bounced" — useful for spotting tickets that keep reverting between Code Review and In Progress.
+
+Requires a Pro license. No network call — reads local snapshots only.
+
+---
+
+### Custom Attention Rules
+
+Add an `attentionRules` array to any profile in `~/.ticketlens/profiles.json` to override how `ticketlens triage` scores specific tickets:
+
+```json
+{
+  "profiles": {
+    "work": {
+      "baseUrl": "https://jira.example.com",
+      "attentionRules": [
+        { "match": { "priority": "Highest" }, "action": "force-urgent", "reason": "P1 always urgent" },
+        { "match": { "label": "backlog" },    "action": "ignore",       "reason": "skip backlog" },
+        { "match": { "status": "Parked" },    "action": "ignore",       "reason": "parked tickets" }
+      ]
+    }
+  }
+}
+```
+
+Rules are evaluated in order — first match wins. Supported `match` keys: `priority`, `label`, `status`, `keyPrefix`. Supported `action` values: `force-urgent` (bumps to needs-response) and `ignore` (excludes from output). Requires a Pro license.
+
+---
+
 ### Login
 
 ```bash
@@ -486,6 +524,8 @@ ticketlens triage --export=csv               # Export to CSV [Team]
 ticketlens triage --export=json              # Export to JSON [Team]
 ticketlens triage --push                     # Push snapshot to Console queue [Team]
 ticketlens triage --share                    # Generate 24h share URL (no login for recipient) [Team]
+ticketlens triage --all                      # Triage all profiles at once, merged output [Pro]
+ticketlens triage --save=~/triage.txt        # Save ANSI-stripped output to file [Pro]
 ticketlens triage --digest                   # POST results to digest endpoint [Pro]
 ticketlens triage --profile=acme --stale=3 --static          # Combine flags
 
@@ -537,6 +577,10 @@ ticketlens cache clear --older-than=30d --yes            # Skip confirmation (CI
 ticketlens schedule                           # Interactive wizard — set time, timezone, profile [Pro]
 ticketlens schedule --stop                    # Cancel the scheduled digest [Pro]
 ticketlens schedule --status                  # Show current schedule [Pro]
+ticketlens schedule --local                   # Local-only cron/LaunchAgent — no Console auth needed [Pro]
+
+# ── History ───────────────────────────────────────────────────────────────────
+ticketlens history <TICKET-KEY>               # Show urgency timeline for a ticket [Pro]
 
 # ── Compliance ────────────────────────────────────────────────────────────────
 ticketlens compliance <TICKET-KEY>            # Check ticket requirements against local diff [Pro/Free 3/mo]

package/bin/ticketlens.mjs

@@ -31,12 +31,27 @@ import { readCliToken, saveCliToken, deleteCliToken } from '../skills/jtb/script
 import { browserLogin } from '../skills/jtb/scripts/lib/browser-login.mjs';
 import { syncProfiles, getApiBase, getConsoleBase } from '../skills/jtb/scripts/lib/sync.mjs';
 import { promptSecret, promptText } from '../skills/jtb/scripts/lib/prompt-helpers.mjs';
+import { checkForUpdate, getUpdateHint } from '../skills/jtb/scripts/lib/update-check.mjs';
 
 const args = process.argv.slice(2);
 const { command, args: cmdArgs } = parseCommand(args);
 
 // Fire-and-forget: silently refresh license.json at startup if >7 days since last validation
 revalidateIfStale();
+// Fire-and-forget: refresh the cached latest npm version once per 24h
+checkForUpdate();
+
+// Show a one-line update hint on stderr after the command exits (never blocks stdout)
+process.on('exit', () => {
+  try {
+    const latest = getUpdateHint();
+    if (!latest) return;
+    const s = createStyler({ isTTY: process.stderr.isTTY });
+    process.stderr.write(`\n${s.brand('◆')} Update available ${s.dim('→')} ${s.bold(s.cyan(latest))}  ${s.dim('npm install -g ticketlens')}\n`);
+  } catch {
+    // never let the update hint crash the process
+  }
+});
 
 switch (command) {
   case 'fetch':
@@ -63,6 +78,31 @@ switch (command) {
     break;
   }
 
+  case 'history': {
+    if (!isLicensed('pro')) { showUpgradePrompt('pro', 'ticketlens history'); break; }
+    const ticketKey = cmdArgs[0];
+    if (!ticketKey || ticketKey.startsWith('-')) {
+      process.stderr.write('Usage: ticketlens history TICKET-KEY\n');
+      process.exitCode = 1;
+      break;
+    }
+    const { queryTicketHistory } = await import('../skills/jtb/scripts/lib/triage-history.mjs');
+    const entries = queryTicketHistory(ticketKey);
+    if (entries.length === 0) {
+      process.stdout.write(`No triage history found for ${ticketKey}.\n`);
+      break;
+    }
+    const hs = createStyler({ isTTY: process.stdout.isTTY });
+    process.stdout.write(`\nHistory for ${hs.bold(ticketKey)} (${entries.length} entries)\n\n`);
+    for (const e of entries) {
+      const bounce = e.bounced ? hs.yellow(' ⟳ bounced') : '';
+      const urg = e.urgency === 'needs-response' ? hs.red(e.urgency) : e.urgency === 'aging' ? hs.yellow(e.urgency) : hs.green(e.urgency);
+      process.stdout.write(`  ${hs.dim(e.date)}  [${e.profile}]  ${urg}${bounce}  ${hs.dim(e.reason)}\n`);
+    }
+    process.stdout.write('\n');
+    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.5.0",
+  "version": "0.6.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.4.2 -->
+<!-- jtb-skill-version: 0.6.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.
@@ -27,8 +27,11 @@ Fetches a Jira ticket and produces a structured brief with code references, then
 /jtb triage --stale=3                  # custom aging threshold (days)
 /jtb triage --status=CR,QA             # only check specific statuses
 /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 --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 collisions                        # show branch collisions with teammates (Team)
 /jtb collisions --json                 # machine-readable output
 ```

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

@@ -10,6 +10,8 @@ import { assembleTriageSummary } from './lib/brief-assembler.mjs';
 import { styleTriageSummary } from './lib/styled-assembler.mjs';
 import { resolveConnection, loadProfiles, saveProfile } from './lib/profile-resolver.mjs';
 import { resolveAdapter } from './lib/resolve-adapter.mjs';
+import { writeFileSync, mkdirSync, statSync } from 'node:fs';
+import { resolve as resolvePath, dirname } from 'node:path';
 import { createSpinner } from './lib/spinner.mjs';
 import { createSession } from './lib/banner.mjs';
 import { classifyError } from './lib/error-classifier.mjs';
@@ -20,6 +22,7 @@ import { handleUnknownFlags } from './lib/arg-validator.mjs';
 import { isLicensed, showUpgradePrompt, revalidateIfStale } from './lib/license.mjs';
 import { readCliToken } from './lib/cli-auth.mjs';
 import { apiBase } from './lib/api-utils.mjs';
+import { stripAnsi, bold, cyan, dim, red, green } from './lib/ansi.mjs';
 
 const DEFAULT_STATUSES = ['In Progress', 'Code Review', 'QA'];
 
@@ -74,7 +77,7 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
 
   const validatedArgs = await handleUnknownFlags(
     args,
-    ['--help', '-h', '--static', '--plain', '--styled', '--profile=', '--stale=', '--status=', '--assignee=', '--sprint=', '--export=', '--digest', '--push', '--share'],
+    ['--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
   );
   if (validatedArgs === null) { process.exitCode = 1; return; }
@@ -93,6 +96,8 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
   const digestFlag = args.includes('--digest');
   const pushFlag = args.includes('--push');
   const shareFlag = args.includes('--share');
+  const allFlag = args.includes('--all');
+  const saveArg = args.find(a => a.startsWith('--save='))?.split('=').slice(1).join('=') ?? null;
 
   if (exportArg && exportArg !== 'csv' && exportArg !== 'json') {
     process.stderr.write(`Error: --export must be csv or json, got: ${exportArg}\n`);
@@ -103,6 +108,111 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
   const licensedFn = opts.isLicensed ?? isLicensed;
   const upgradeFn = opts.showUpgradePrompt ?? showUpgradePrompt;
 
+  // --save=FILE: Pro gate + validate path is not a directory
+  if (saveArg) {
+    if (!licensedFn('pro', configDir)) {
+      upgradeFn('pro', '--save');
+      process.exitCode = 1;
+      return;
+    }
+    const resolvedSave = resolvePath(saveArg);
+    try {
+      if (statSync(resolvedSave).isDirectory()) {
+        process.stderr.write(`Error: --save path must be a file, not a directory: ${resolvedSave}\n`);
+        process.exitCode = 1;
+        return;
+      }
+    } catch { /* doesn't exist yet — ok */ }
+  }
+
+  // --all: triage all configured profiles in parallel with live status block
+  if (allFlag) {
+    if (!licensedFn('pro', configDir)) {
+      upgradeFn('pro', '--all');
+      process.exitCode = 1;
+      return;
+    }
+    const profilesConfig = loadProfiles(configDir);
+    const profileNames = profilesConfig?.profiles ? Object.keys(profilesConfig.profiles) : [];
+    if (profileNames.length === 0) {
+      process.stderr.write('Error: No profiles configured. Run `ticketlens init` first.\n');
+      process.exitCode = 1;
+      return;
+    }
+
+    const usePlain = args.includes('--plain');
+    const printFn = opts.print ?? ((s) => process.stdout.write(s));
+    const argsBase = args.filter(a => a !== '--all' && !a.startsWith('--profile='));
+    // --static disables interactive mode in sub-runs (isTTY is still true but we're capturing output)
+    const modeFlags = usePlain ? ['--plain'] : ['--styled', '--static'];
+    const isTTY = process.stderr.isTTY;
+    const SPIN = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    const COL = Math.max(...profileNames.map(n => n.length)) + 2;
+
+    // Per-profile state
+    const entries = profileNames.map(name => ({ name, state: 'pending', output: [], summary: '' }));
+
+    const statusLine = (e, frame = 0) => {
+      const nameCol = e.name.padEnd(COL);
+      if (e.state === 'pending') return `  ${SPIN[frame % SPIN.length]} ${nameCol}${dim('fetching...')}`;
+      if (e.state === 'done')    return `  ${green('✔')} ${nameCol}${dim(e.summary)}`;
+      return                            `  ${red('✗')} ${nameCol}${dim('could not connect')}`;
+    };
+
+    // Suppress all sub-run stderr so banners/spinners don't corrupt the status block.
+    // Status updates bypass suppression via `toStatus` which holds the original reference.
+    const toStatus = isTTY ? process.stderr.write.bind(process.stderr) : null;
+    if (isTTY) {
+      process.stderr.write = () => true;  // silence sub-runs
+      toStatus('\x1b[?25l');
+      for (const e of entries) toStatus(statusLine(e) + '\n');
+    }
+
+    let frame = 0;
+    const timer = isTTY ? setInterval(() => {
+      frame++;
+      toStatus(`\x1b[${entries.length}A`);
+      for (const e of entries) toStatus(`\r\x1b[K${statusLine(e, frame)}\n`);
+    }, 80) : null;
+
+    await Promise.allSettled(entries.map((e, idx) =>
+      run([...argsBase, `--profile=${e.name}`, ...modeFlags],
+          { ...opts, env, fetcher, configDir, print: s => e.output.push(s) })
+        .then(() => {
+          const combined = e.output.join('');
+          const m = combined.match(/(\d+) found/);
+          entries[idx].state   = e.output.length === 0 ? 'error' : 'done';
+          entries[idx].summary = m ? `${m[1]} ticket${m[1] === '1' ? '' : 's'}` : 'done';
+        })
+        .catch(() => { entries[idx].state = 'error'; })
+    ));
+
+    if (isTTY) {
+      clearInterval(timer);
+      toStatus(`\x1b[${entries.length}A`);
+      for (const e of entries) toStatus(`\r\x1b[K${statusLine(e)}\n`);
+      toStatus('\x1b[?25h\n');
+      process.stderr.write = toStatus;  // restore
+    }
+
+    // Render results in profile order
+    for (const e of entries) {
+      printFn(usePlain
+        ? `\n── ${e.name} ──\n`
+        : `\n${dim('──')} ${bold(cyan(e.name))} ${dim('──')}\n`);
+
+      if (e.output.length === 0) {
+        const hint = `ticketlens triage --profile=${e.name}`;
+        printFn(usePlain
+          ? `  [could not connect — run: ${hint}]\n`
+          : `  ${red('✗')} ${dim('Could not connect — run')} ${cyan(hint)} ${dim('for details')}\n`);
+      } else {
+        printFn(e.output.join(''));
+      }
+    }
+    return;
+  }
+
   // Team-tier gate: --assignee and --sprint require a Team license
   if ((assigneeArg || sprintArg) && !licensedFn('team', configDir)) {
     upgradeFn('team', assigneeArg ? '--assignee' : '--sprint');
@@ -283,11 +393,17 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
     process.stderr.write(`Viewing ${assigneeName}'s tickets\n\n`);
   }
 
-  const scored = tickets.map(t => scoreAttention(t, effectiveUser, { staleDays }));
-  const actionable = scored.filter(s => s.urgency !== 'clear');
+  const scored = tickets.map(t => scoreAttention(t, effectiveUser, { staleDays, customRules: conn.attentionRules }));
+  const actionable = scored.filter(s => s.urgency !== 'clear' && s.urgency !== 'ignore');
   const sorted = sortByUrgency(actionable);
   const rawTicketMap = new Map(tickets.map(t => [t.key, t]));
 
+  // Always save a daily snapshot for history tracking (non-fatal)
+  try {
+    const { saveTriageSnapshot } = await import('./lib/triage-history.mjs');
+    saveTriageSnapshot(scored, { profile: profileName ?? 'default', configDir });
+  } catch { /* non-fatal */ }
+
   // --digest: POST scored results to the digest backend endpoint
   if (digestFlag) {
     if (!licensedFn('pro', configDir)) {
@@ -298,12 +414,11 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
     const deliverer = opts.digestDeliverer ?? defaultDigestDeliverer;
     const digestCliToken = opts.cliToken ?? readCliToken(configDir) ?? null;
 
-    // Triage history delta (non-fatal — wrapped in try/catch)
+    // Triage history delta (non-fatal — snapshot already saved above)
     let delta = null;
     try {
-      const { saveTriageSnapshot, loadYesterdaySnapshot, diffSnapshots, buildDeltaSection } =
+      const { loadYesterdaySnapshot, diffSnapshots, buildDeltaSection } =
         await import('./lib/triage-history.mjs');
-      saveTriageSnapshot(sorted, { profile: profileName ?? 'default', configDir });
       const yesterday = loadYesterdaySnapshot({ profile: profileName ?? 'default', configDir });
       if (yesterday) {
         const deltas = diffSnapshots(sorted, yesterday);
@@ -314,11 +429,14 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
     await deliverer({
       profile: profileName ?? 'default',
       staleDays,
-      summary: {
-        total: sorted.length,
-        needsResponse: sorted.filter(t => t.urgency === 'needs-response').length,
-        aging: sorted.filter(t => t.urgency === 'aging').length,
-      },
+      summary: (() => {
+        let needsResponse = 0, aging = 0;
+        for (const t of sorted) {
+          if (t.urgency === 'needs-response') needsResponse++;
+          else if (t.urgency === 'aging') aging++;
+        }
+        return { total: sorted.length, needsResponse, aging };
+      })(),
       tickets: sorted,
       delta,
     }, { cliToken: digestCliToken });
@@ -372,7 +490,7 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
   }
 
   // Interactive mode: TTY + not --plain + not --static
-  const wantInteractive = process.stdout.isTTY && !args.includes('--plain') && !args.includes('--static');
+  const wantInteractive = process.stdout.isTTY && !args.includes('--plain') && !args.includes('--static') && !saveArg;
   if (wantInteractive && process.stdin.setRawMode) {
     const result = await runInteractiveList(sorted, { baseUrl: conn.baseUrl, staleDays, styled: true });
     if (result === 'switch') {
@@ -386,7 +504,17 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
   const summary = useStyled
     ? styleTriageSummary(sorted, { styled: true, staleDays, baseUrl: conn.baseUrl })
     : assembleTriageSummary(sorted, { staleDays, baseUrl: conn.baseUrl });
-  process.stdout.write(summary + '\n');
+
+  // --save=FILE: write ANSI-stripped output to file
+  if (saveArg) {
+    const resolvedSave = resolvePath(saveArg);
+    mkdirSync(dirname(resolvedSave), { recursive: true });
+    const plain = stripAnsi(summary);
+    writeFileSync(resolvedSave, plain + '\n', 'utf8');
+  }
+
+  const printFn = opts.print ?? ((s) => process.stdout.write(s));
+  printFn(summary + '\n');
 }
 
 // Run if invoked directly

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

@@ -85,3 +85,6 @@ export const brightYellow = defaultStyler.brightYellow;
 export const brightCyan   = defaultStyler.brightCyan;
 export const brand        = defaultStyler.brand;
 export const isStyled     = () => defaultStyler.enabled;
+
+export const ANSI_RE = /\[[0-9;]*m/g;
+export function stripAnsi(s) { return s.replace(ANSI_RE, ''); }

package/skills/jtb/scripts/lib/attention-scorer.mjs

@@ -75,8 +75,42 @@ export function findLastEffectiveComment(comments, currentUser) {
   return { comment: null, fromCurrentUser: false };
 }
 
+/**
+ * Apply a single custom rule against a ticket.
+ * Returns 'force-urgent' | 'ignore' | null.
+ * A rule must have a valid `match` object and a known `action` to fire.
+ */
+function applyCustomRule(ticket, rule) {
+  if (!rule || typeof rule.match !== 'object' || !rule.match) return null;
+  if (rule.action !== 'force-urgent' && rule.action !== 'ignore') return null;
+
+  const { priority, label, status, keyPrefix } = rule.match;
+  if (priority !== undefined && ticket.priority !== priority) return null;
+  if (status !== undefined && ticket.status !== status) return null;
+  if (label !== undefined) {
+    const labels = Array.isArray(ticket.labels) ? ticket.labels : [];
+    if (!labels.includes(label)) return null;
+  }
+  if (keyPrefix !== undefined && !String(ticket.key).startsWith(keyPrefix)) return null;
+
+  return rule.action;
+}
+
 export function scoreAttention(ticket, currentUser, opts = {}) {
-  const { staleDays = 5, now = new Date() } = opts;
+  const { staleDays = 5, now = new Date(), customRules } = opts;
+
+  // Custom rules evaluated first — first match wins
+  if (Array.isArray(customRules)) {
+    for (const rule of customRules) {
+      const action = applyCustomRule(ticket, rule);
+      if (action === 'ignore') {
+        return { ticketKey: ticket.key, summary: ticket.summary, status: ticket.status, urgency: 'ignore', reason: rule.reason ?? 'Ignored by custom rule', lastComment: null };
+      }
+      if (action === 'force-urgent') {
+        return { ticketKey: ticket.key, summary: ticket.summary, status: ticket.status, urgency: 'needs-response', reason: rule.reason ?? 'Flagged by custom rule', lastComment: null };
+      }
+    }
+  }
 
   const { comment: lastComment, fromCurrentUser } = findLastEffectiveComment(
     ticket.comments || [], currentUser
@@ -145,8 +179,8 @@ export function sortByUrgency(scores) {
     const orderDiff = URGENCY_ORDER[a.urgency] - URGENCY_ORDER[b.urgency];
     if (orderDiff !== 0) return orderDiff;
     // Within same urgency, sort by most recent activity (lastComment date or ticket updated)
-    const dateA = a.lastComment?.created ? new Date(a.lastComment.created) : new Date(0);
-    const dateB = b.lastComment?.created ? new Date(b.lastComment.created) : new Date(0);
+    const dateA = a.lastComment?.created ? new Date(a.lastComment.created).getTime() : 0;
+    const dateB = b.lastComment?.created ? new Date(b.lastComment.created).getTime() : 0;
     return dateB - dateA; // most recent first
   });
 }

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

@@ -110,6 +110,10 @@ export function parseCommand(args) {
     return { command: 'collisions', args: args.slice(1) };
   }
 
+  if (first === 'history') {
+    return { command: 'history', 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

@@ -42,6 +42,7 @@ export function printHelp({ stream = process.stdout } = {}) {
     `    ${s.brand('ticketlens')} review ${s.dim('[--branch=BRANCH]')}   Code-review context brief from current branch`,
     `    ${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')} delete ${s.dim('<PROFILE-NAME>')}     Remove a profile`,
     `    ${s.brand('ticketlens')} activate ${s.dim('<KEY>')}           Activate a license key`,
@@ -79,6 +80,8 @@ export function printHelp({ stream = process.stdout } = {}) {
     `    ${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]')}`,
+    `    ${s.brand('--all')}              Triage all configured profiles at once  ${s.dim('[Pro]')}`,
+    `    ${s.brand('--save')}=${s.dim('FILE')}        Save ANSI-stripped output to file  ${s.dim('[Pro]')}`,
     `    ${s.brand('--digest')}           POST scored results to digest endpoint  ${s.dim('[Pro]')}`,
     `    ${s.brand('--static')}           Static table output ${s.dim('(skip interactive mode)')}`,
     `    ${s.brand('--plain')}            Plain markdown output ${s.dim('(for piping / LLM)')}`,
@@ -549,6 +552,8 @@ export function printTriageHelp({ stream = process.stdout } = {}) {
     `    ${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]')}`,
+    `    ${s.brand('--all')}              Triage all configured profiles at once  ${s.dim('[Pro]')}`,
+    `    ${s.brand('--save')}=${s.dim('FILE')}        Save ANSI-stripped output to file  ${s.dim('[Pro]')}`,
     `    ${s.brand('--digest')}           POST scored results to digest endpoint  ${s.dim('[Pro]')}`,
     `    ${s.brand('--static')}           Static table output ${s.dim('(skip interactive mode)')}`,
     `    ${s.brand('--plain')}            Plain markdown output`,

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

@@ -231,6 +231,7 @@ export function resolveConnection(ticketKey, opts = {}) {
       pat: profileCreds.pat || null,
       triageStatuses: profile.triageStatuses || null,
       ticketPrefixes: profile.ticketPrefixes || null,
+      attentionRules: profile.attentionRules ?? null,
       source: 'profile',
       profileName: profile.name,
     };

package/skills/jtb/scripts/lib/schedule-wizard.mjs

@@ -7,13 +7,37 @@ import { apiBase, warnIfInsecure } from './api-utils.mjs';
 
 const SCHEDULE_PATH = '/v1/schedule';
 
+// Safe path: printable ASCII, no shell metacharacters or XML special chars.
+// Allows: letters, digits, /, ., _, -, ~, space (none of which are shell-special in this context).
+const SAFE_PATH_RE = /^[A-Za-z0-9/._~-]+$/;
+
+function xmlEscape(s) {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
+}
+
+function validateOutputFile(outputFile) {
+  if (!outputFile || !SAFE_PATH_RE.test(outputFile)) {
+    throw new Error(`Invalid output file path: must contain only letters, digits, /, ., _, -, ~ (no spaces or shell metacharacters)`);
+  }
+}
+
+function validateTime(hour, minute) {
+  if (!Number.isInteger(hour) || !Number.isInteger(minute) ||
+      hour < 0 || hour > 23 || minute < 0 || minute > 59) {
+    throw new Error(`Invalid time: hour must be 0–23, minute must be 0–59`);
+  }
+}
+
+function parseHHMM(time) {
+  const [hourStr, minuteStr] = time.split(':');
+  return { hour: parseInt(hourStr, 10), minute: parseInt(minuteStr, 10) };
+}
+
 /**
  * Build a macOS LaunchAgent plist string.
  */
 export function buildPlist({ hour, minute, ticketlensBin }) {
-  if (!Number.isInteger(hour) || !Number.isInteger(minute)) {
-    throw new Error('hour and minute must be integers');
-  }
+  validateTime(hour, minute);
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -68,9 +92,7 @@ export async function runScheduleWizard({
     return { ok: false };
   }
   const { time, email, timezone } = answers;
-  const [hourStr, minuteStr] = time.split(':');
-  const hour = parseInt(hourStr, 10);
-  const minute = parseInt(minuteStr, 10);
+  const { hour, minute } = parseHHMM(time);
 
   try {
     const res = await fetcher(`${apiBase()}${SCHEDULE_PATH}`, {
@@ -146,7 +168,8 @@ export async function runScheduleStop({
     try { unlinkSync(plistPath); } catch { /* already removed */ }
   } else {
     const existing = spawnSync('crontab', ['-l'], { encoding: 'utf8' }).stdout ?? '';
-    const updated = existing.replace(/.*ticketlens triage --digest.*\n?/g, '');
+    // Remove both cloud-digest and local-save ticketlens cron lines
+    const updated = existing.replace(/.*ticketlens triage --(digest|'--save=).*\n?/g, '');
     const tmp = `/tmp/ticketlens-crontab-${Date.now()}`;
     writeFileSync(tmp, updated, 'utf8');
     spawnSync('crontab', [tmp], { encoding: 'utf8' });
@@ -189,10 +212,93 @@ export async function runScheduleStatus({
   print('\n');
 }
 
+/**
+ * Build a local-only cron/plist entry that runs triage --save=FILE.
+ * No cloud auth required — purely local scheduling.
+ */
+export function buildLocalPlist({ hour, minute, ticketlensBin, outputFile }) {
+  const safeFile = xmlEscape(outputFile);
+  const safeBin = xmlEscape(ticketlensBin);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>io.ticketlens.triage-local</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${safeBin}</string>
+    <string>triage</string>
+    <string>--save=${safeFile}</string>
+  </array>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Hour</key>
+    <integer>${hour}</integer>
+    <key>Minute</key>
+    <integer>${minute}</integer>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${safeFile}</string>
+  <key>StandardErrorPath</key>
+  <string>${safeFile}.err</string>
+</dict>
+</plist>`;
+}
+
+export function buildLocalCronLine({ hour, minute, ticketlensBin, outputFile }) {
+  // Single-quote the --save argument to prevent shell word-splitting.
+  // SAFE_PATH_RE already guarantees no single-quote chars in outputFile.
+  return `${minute} ${hour} * * * ${ticketlensBin} triage '--save=${outputFile}' >> '${outputFile}.err' 2>&1`;
+}
+
+/**
+ * Set up a local-only scheduled triage (no Console auth, no cloud push).
+ * Writes a cron/LaunchAgent entry that runs `ticketlens triage --save=FILE`.
+ */
+export async function runScheduleLocal({
+  answers,
+  platform = osPlatform(),
+  writeLocalJob = defaultWriteLocalJob,
+  print = s => process.stdout.write(s),
+  // fetcher is accepted but intentionally ignored — no network calls
+}) {
+  const { time, outputFile } = answers ?? {};
+  if (!time || !outputFile) {
+    print(`  ${red('✗')} Local schedule requires a time and output file.\n`);
+    return { ok: false };
+  }
+  const { hour, minute } = parseHHMM(time);
+  try {
+    validateTime(hour, minute);
+    validateOutputFile(outputFile);
+  } catch (err) {
+    print(`  ${red('✗')} ${err.message}\n`);
+    return { ok: false };
+  }
+
+  const ticketlensBin = resolveTicketlensBin();
+  const content = platform === 'darwin'
+    ? buildLocalPlist({ hour, minute, ticketlensBin, outputFile })
+    : buildLocalCronLine({ hour, minute, ticketlensBin, outputFile });
+
+  writeLocalJob(content, platform);
+
+  print(`\n  ${green('✔')} ${bold('Local triage scheduled')}\n`);
+  print(`  ${dim('Time:   ')} ${cyan(time)} daily\n`);
+  print(`  ${dim('Output: ')} ${cyan(outputFile)}\n\n`);
+
+  return { ok: true, time, outputFile };
+}
+
+let _ticketlensBin;
 function resolveTicketlensBin() {
+  if (_ticketlensBin) return _ticketlensBin;
   const which = spawnSync('which', ['ticketlens'], { encoding: 'utf8' });
-  if (which.status === 0 && which.stdout.trim()) return which.stdout.trim();
-  return `${homedir()}/.npm/bin/ticketlens`;
+  _ticketlensBin = (which.status === 0 && which.stdout.trim())
+    ? which.stdout.trim()
+    : `${homedir()}/.npm/bin/ticketlens`;
+  return _ticketlensBin;
 }
 
 function defaultWriteLocalJob(content, platform) {
@@ -204,7 +310,8 @@ function defaultWriteLocalJob(content, platform) {
     spawnSync('launchctl', ['load', plistPath], { encoding: 'utf8' });
   } else {
     const existing = spawnSync('crontab', ['-l'], { encoding: 'utf8' }).stdout ?? '';
-    const updated = existing.replace(/.*ticketlens triage --digest.*/g, '').trimEnd() + '\n' + content + '\n';
+    // Remove both cloud-digest and local-save ticketlens cron lines before re-adding
+    const updated = existing.replace(/.*ticketlens triage --(digest|'--save=).*\n?/g, '').trimEnd() + '\n' + content + '\n';
     const tmp = `/tmp/ticketlens-crontab-${Date.now()}`;
     writeFileSync(tmp, updated, 'utf8');
     spawnSync('crontab', [tmp], { encoding: 'utf8' });

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

@@ -162,3 +162,71 @@ export function buildDeltaSection(deltas) {
 
   return lines.join('\n') + '\n';
 }
+
+/**
+ * Query the full history for a single ticket key across all dated snapshots.
+ *
+ * Reads ~/.ticketlens/triage-history/YYYY-MM-DD/*.json, finds entries matching
+ * the given ticketKey, and returns a chronologically sorted timeline.
+ * Entries with urgency oscillating in the same direction on consecutive days
+ * are flagged with `bounced: true`.
+ *
+ * @param {string} ticketKey
+ * @param {object} [opts]
+ * @param {string} [opts.configDir]
+ * @param {object} [opts.fsModule]
+ * @returns {{ date: string, profile: string, urgency: string, status: string, reason: string, bounced: boolean }[]}
+ */
+export function queryTicketHistory(ticketKey, {
+  configDir = DEFAULT_CONFIG_DIR,
+  fsModule = defaultFs,
+} = {}) {
+  const histDir = join(configDir, 'triage-history');
+  if (!fsModule.existsSync(histDir)) return [];
+
+  const dates = fsModule.readdirSync(histDir)
+    .filter(d => /^\d{4}-\d{2}-\d{2}$/.test(d))
+    .sort(); // lexicographic = chronological for YYYY-MM-DD
+
+  const entries = [];
+  for (const date of dates) {
+    const dayDir = join(histDir, date);
+    let profileFiles;
+    try {
+      profileFiles = fsModule.readdirSync(dayDir).filter(f => f.endsWith('.json'));
+    } catch {
+      continue;
+    }
+    for (const file of profileFiles) {
+      const profile = file.slice(0, -5); // strip .json
+      let tickets;
+      try {
+        tickets = JSON.parse(fsModule.readFileSync(join(dayDir, file), 'utf8'));
+      } catch {
+        continue;
+      }
+      const found = Array.isArray(tickets) && tickets.find(t => t.ticketKey === ticketKey);
+      if (found) {
+        entries.push({
+          date,
+          profile,
+          urgency: found.urgency ?? 'unknown',
+          status: found.status ?? '',
+          reason: found.reason ?? '',
+          bounced: false,
+        });
+      }
+    }
+  }
+
+  // Detect bounces: flag entries where urgency changed direction on consecutive days
+  for (let i = 1; i < entries.length; i++) {
+    const prev = entries[i - 1];
+    const cur = entries[i];
+    if (cur.urgency !== prev.urgency && cur.profile === prev.profile) {
+      cur.bounced = true;
+    }
+  }
+
+  return entries;
+}

package/skills/jtb/scripts/lib/update-check.mjs

@@ -0,0 +1,102 @@
+/**
+ * Background npm update check.
+ * Caches the latest published version in ~/.ticketlens/update-check.json with a 24h TTL.
+ * Never blocks the CLI — all failures are silently swallowed.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { DEFAULT_CONFIG_DIR, getVersion } from './config.mjs';
+
+export const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const REGISTRY_URL = 'https://registry.npmjs.org/ticketlens/latest';
+const CHECK_FILE = 'update-check.json';
+
+/** Path to the update-check cache file. */
+function checkFilePath(configDir) {
+  return join(configDir, CHECK_FILE);
+}
+
+/**
+ * Returns the cached latestVersion string if the cache is present and within TTL,
+ * or null otherwise.
+ */
+const SEMVER_RE = /^\d+\.\d+\.\d+$/;
+
+export function readUpdateCheck(configDir = DEFAULT_CONFIG_DIR) {
+  try {
+    const data = JSON.parse(readFileSync(checkFilePath(configDir), 'utf8'));
+    if (!data?.checkedAt || typeof data.latestVersion !== 'string') return null;
+    if (!SEMVER_RE.test(data.latestVersion)) return null;
+    if (Date.now() - new Date(data.checkedAt).getTime() > UPDATE_CHECK_TTL_MS) return null;
+    return data.latestVersion;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Writes { checkedAt, latestVersion } to the cache file. Non-fatal.
+ */
+export function writeUpdateCheck(configDir = DEFAULT_CONFIG_DIR, latestVersion) {
+  try {
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(
+      checkFilePath(configDir),
+      JSON.stringify({ checkedAt: new Date().toISOString(), latestVersion }),
+      { mode: 0o644 },
+    );
+  } catch {
+    // non-fatal
+  }
+}
+
+/**
+ * Returns true when latest is strictly greater than current.
+ * Strips leading 'v' from both before comparing.
+ */
+export function isNewer(latest, current) {
+  const parse = v => v.replace(/^v/, '').split('.').map(Number);
+  const [la, lb, lc] = parse(latest);
+  const [ca, cb, cc] = parse(current);
+  if (la !== ca) return la > ca;
+  if (lb !== cb) return lb > cb;
+  return lc > cc;
+}
+
+/**
+ * Fetches the latest version from the npm registry.
+ * Returns the version string, or null on any failure.
+ */
+export async function fetchLatestVersion({ fetcher = globalThis.fetch } = {}) {
+  try {
+    const res = await fetcher(REGISTRY_URL, { signal: AbortSignal.timeout(10_000) });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data?.version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Fire-and-forget: checks if the cache is expired and, if so, fetches the latest
+ * version from npm and writes it to the cache. Errors are silently swallowed.
+ * Call at CLI startup; never await.
+ */
+export function checkForUpdate({ configDir = DEFAULT_CONFIG_DIR, fetcher = globalThis.fetch } = {}) {
+  if (readUpdateCheck(configDir) !== null) return Promise.resolve();
+  return fetchLatestVersion({ fetcher })
+    .then(v => { if (v) writeUpdateCheck(configDir, v); })
+    .catch(() => {});
+}
+
+/**
+ * Returns the cached latestVersion string if it is newer than the current installed
+ * version, or null if no update is available or the cache is absent/expired.
+ */
+export function getUpdateHint({ configDir = DEFAULT_CONFIG_DIR, currentVersion = getVersion() } = {}) {
+  const latest = readUpdateCheck(configDir);
+  if (!latest) return null;
+  return isNewer(latest, currentVersion) ? latest : null;
+}