ticketlens 0.1.13 → 0.1.15

package/README.md

@@ -35,6 +35,7 @@ Zero npm dependencies. Node.js built-ins only.
 - **Scriptable** — standard CLI output: pipe to cron, git hooks, CI/CD, or any LLM tool
 - **Multi-profile** — connect multiple Jira instances simultaneously; auto-route by ticket prefix or project path
 - **Attachments included** — images, PDFs, and text files downloaded locally; Claude Code reads them as context
+- **Confluence pages** — linked Confluence pages fetched and included in the brief automatically (Jira only)
 
 ---
 
@@ -42,7 +43,7 @@ Zero npm dependencies. Node.js built-ins only.
 
 ```bash
 npm install -g ticketlens
-ticketlens init          # Guided setup: Jira URL, auth type, connection test
+ticketlens init          # Guided setup: Jira, GitHub Issues, or Linear — connection test included
 ticketlens CNV1-2        # Fetch a ticket brief
 ticketlens triage        # Scan your assigned tickets
 ```
@@ -70,13 +71,13 @@ npx ticketlens CNV1-2
 
 | Command | Description |
 |---------|-------------|
-| `ticketlens init` | Guided wizard — Jira URL, auth, live connection test, optional settings |
+| `ticketlens init` | Guided wizard — Jira, GitHub Issues, or Linear — live connection test, optional settings |
 | `ticketlens switch` | Arrow-key panel to switch between configured profiles |
-| `ticketlens config [--profile=NAME]` | Edit any field on an existing profile |
+| `ticketlens config [--profile=NAME]` | Edit any field on an existing profile — always re-validates the connection |
 | `ticketlens profiles` | List all configured profiles (alias: `ticketlens ls`) |
 | `ticketlens delete <NAME>` | Remove a profile and its credentials (prompts `y/N` in TTY; use `--yes` in scripts/CI) |
 
-`init` collects: profile name, Jira URL (bare hostnames accepted — HTTPS probed first), auth type (auto-detected from URL), credentials (masked), and optional ticket prefixes, project paths, and triage statuses. On connection failure, a retry menu lets you fix credentials, URL, or skip — all inputs pre-populated.
+`init` collects: profile name, tracker type (Jira / GitHub Issues / Linear), URL or workspace, credentials (masked), and optional ticket prefixes, project paths, and triage statuses. On connection failure, a retry menu lets you fix credentials, URL, or skip — all inputs pre-populated. `config` is tracker-aware and always re-validates the connection after edits.
 
 `config` uses merge semantics: new ticket prefixes and triage statuses are added to existing lists, never replaced. Partial matching resolves `QA` to `QA Testing` if that's the status in your Jira.
 
@@ -93,7 +94,7 @@ ticketlens CNV1-2 --depth=2        # + linked-of-linked (full graph)
 ticketlens CNV1-2 --plain          # Plain markdown — pipe-safe, LLM-ready
 ticketlens CNV1-2 --profile=acme   # Force a specific profile
 ticketlens CNV1-2 --no-cache       # Bypass cache, re-fetch from Jira
-ticketlens CNV1-2 --no-attachments # Skip attachment download
+ticketlens CNV1-2 --no-attachments # Skip attachment download and Confluence page fetching
 ticketlens CNV1-2 --check          # Append local VCS diff + Claude Code review instructions
 ticketlens CNV1-2 --compliance     # Check ticket requirements against local diff [Pro/Free 3/mo]
 ticketlens CNV1-2 --summarize      # AI summary via your own API key (BYOK) [Pro]
@@ -102,7 +103,7 @@ ticketlens CNV1-2 --summarize --cloud  # AI summary routed through TicketLens AP
 
 | `--depth` | Scope |
 |-----------|-------|
-| `0` | Target ticket: description, comments, attachments |
+| `0` | Target ticket: description, comments, attachments, Confluence pages |
 | `1` | + linked tickets: descriptions and comments _(default)_ |
 | `2` | + linked-of-linked: key and summary only |
 
@@ -116,6 +117,8 @@ After the first fetch, ticket data is cached to `~/.ticketlens/cache/PROFILE/TIC
 
 Attachments download to `~/.ticketlens/cache/TICKET-KEY/` (10 MB per-file cap). Claude Code reads images multimodally, extracts PDF text, and reads plain text files as context.
 
+Confluence pages linked to the ticket via Jira Remote Links are fetched automatically and included as plain text in the brief (Jira profiles only, same-origin). Use `--no-attachments` to skip both attachments and Confluence pages.
+
 ---
 
 ### Triage
@@ -455,11 +458,13 @@ npm test
 See [ROADMAP.md](ROADMAP.md) for the full plan.
 
 Recently shipped:
-- Console queue dashboard — live at `/console/queue` for Team tier; push snapshots with `ticketlens triage --push`
+- **Confluence pages** — linked Confluence pages fetched automatically and included in the brief; origin-validated, non-fatal, capped at 10 pages
+- **Linear support** — `ticketlens init` → Linear; connects via GraphQL API key, fetches tickets, triage, and statuses
+- **GitHub Issues support** — `ticketlens init` → GitHub Issues; PAT-based, same normalized ticket shape
+- **Tracker-aware config** — `ticketlens config` shows the right labels and skips irrelevant prompts per tracker type; always re-validates the connection
 
 Coming up:
-- Slack/Teams alerts for triage changes (Team)
-- GitHub Issues and Linear support
+- "TicketLens for PRs" — PR context assembly with linked tickets and compliance (F46)
 
 ---
 

package/bin/ticketlens.mjs

@@ -23,6 +23,7 @@ import {
   printActivateHelp, printLicenseHelp, printDeleteHelp,
   printProfilesHelp, printScheduleHelp,
   printInitHelp, printSwitchHelp, printConfigHelp,
+  printReviewHelp,
 } from '../skills/jtb/scripts/lib/help.mjs';
 import { createStyler } from '../skills/jtb/scripts/lib/ansi.mjs';
 import { readCliToken, saveCliToken, deleteCliToken } from '../skills/jtb/scripts/lib/cli-auth.mjs';
@@ -262,6 +263,14 @@ switch (command) {
     });
     break;
 
+  case 'review':
+    if (cmdArgs.includes('--help') || cmdArgs.includes('-h')) { printReviewHelp(); break; }
+    runFetch(['review', ...cmdArgs]).catch(err => {
+      process.stderr.write(`Error: ${err.message}\n`);
+      process.exitCode = 1;
+    });
+    break;
+
   case 'ledger':
     runFetch(['ledger', ...cmdArgs]).catch(err => {
       process.stderr.write(`Error: ${err.message}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "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/scripts/fetch-ticket.mjs

@@ -28,6 +28,8 @@ import { createStyler } from './lib/ansi.mjs';
 import { isLicensed, showUpgradePrompt, readLicense } from './lib/license.mjs';
 import { detectVcs } from './lib/vcs-detector.mjs';
 import { runComplianceCheck } from './lib/compliance-checker.mjs';
+import { fetchRemoteLinks, buildAuthHeader } from './lib/jira-client.mjs';
+import { fetchConfluencePage } from './lib/confluence-client.mjs';
 
 /**
  * Get the local diff using spawn with explicit arg arrays (never shell interpolation).
@@ -340,6 +342,87 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
     return;
   }
 
+  if (args[0] === 'review') {
+    const { assemblePrReview, extractTicketKeys } = await import('./lib/pr-review-assembler.mjs');
+    const { analyzeDiff } = await import('./lib/diff-analyzer.mjs');
+    const { extractRequirements } = await import('./lib/requirement-extractor.mjs');
+
+    const resolvedConfigDir = configDir ?? (await import('./lib/config.mjs')).DEFAULT_CONFIG_DIR;
+    const execFn = opts.execFn ?? spawnSync;
+    const cwd = process.cwd();
+
+    // Resolve base branch: --base=BRANCH or auto-detect main/master/develop
+    const baseArg = args.find(a => a.startsWith('--base='));
+    let baseBranch = baseArg ? baseArg.split('=')[1] : null;
+    if (!baseBranch) {
+      for (const candidate of ['main', 'master', 'develop']) {
+        const r = execFn('git', ['rev-parse', '--verify', candidate], { encoding: 'utf8', cwd, timeout: 5_000 });
+        if (r.status === 0) { baseBranch = candidate; break; }
+      }
+      baseBranch = baseBranch ?? 'main';
+    }
+
+    // Current branch name
+    const headResult = execFn('git', ['branch', '--show-current'], { encoding: 'utf8', cwd, timeout: 5_000 });
+    const headBranch = headResult.status === 0 ? (headResult.stdout.trim() || null) : null;
+
+    // Commits in range
+    const logResult = execFn('git', ['log', '--oneline', `${baseBranch}..HEAD`], { encoding: 'utf8', cwd, timeout: 10_000 });
+    const commitMessages = logResult.status === 0 ? (logResult.stdout ?? '') : '';
+
+    // Diff between base and HEAD
+    const diffResult = execFn('git', ['diff', `${baseBranch}..HEAD`], { encoding: 'utf8', cwd, timeout: 30_000 });
+    const diff = diffResult.status === 0 ? (diffResult.stdout || null) : null;
+
+    // Extract ticket keys from branch name + commit messages
+    const allText = [headBranch ?? '', commitMessages].join('\n');
+    const ticketKeys = extractTicketKeys(allText);
+
+    // Fetch tickets (best-effort — gracefully degrade if no credentials)
+    const profileArgR = args.find(a => a.startsWith('--profile='));
+    const profileNameR = profileArgR ? profileArgR.split('=')[1] : undefined;
+    const tickets = [];
+
+    if (ticketKeys.length > 0) {
+      const connR = resolveConnection(ticketKeys[0], {
+        env,
+        configDir: resolvedConfigDir,
+        profileName: profileNameR,
+        cwd,
+        onWarning: () => {},
+        onProfileNotFound: () => {},
+      });
+      const hasAuthR = connR.pat || (connR.email && connR.apiToken);
+      if (connR.baseUrl && hasAuthR) {
+        const adapterR = resolveAdapter(connR, { fetcher });
+        for (const key of ticketKeys) {
+          try {
+            tickets.push(await adapterR.fetchTicket(key, { depth: 0 }));
+          } catch { /* non-fatal — skip ticket */ }
+        }
+      } else {
+        process.stderr.write(
+          `Note: Found tickets [${ticketKeys.join(', ')}] but no profile configured. Run 'ticketlens init' to set up.\n`
+        );
+      }
+    }
+
+    const isLic = opts.isLicensedFn ?? ((tier) => isLicensed(tier, resolvedConfigDir));
+    const assembleFn = opts.assemblePrReviewFn ?? assemblePrReview;
+
+    const md = await assembleFn({
+      diff,
+      tickets,
+      baseBranch,
+      headBranch,
+      isLicensedFn: isLic,
+      analyzeDiffFn: analyzeDiff,
+      extractRequirementsFn: extractRequirements,
+    });
+    printFn(md + '\n');
+    return;
+  }
+
   const ticketKey = args.find(a => !a.startsWith('--'));
   if (!ticketKey) {
     printFetchHelp({ stream: process.stderr });
@@ -566,6 +649,29 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
   session.connected();
   process.stderr.write('\n');
 
+  // ── Confluence page fetching ───────────────────────────────────────────────
+  // Fetch pages referenced via Jira Remote Links (Confluence-only, non-blocking).
+  // Runs before cache write so cached briefs include the pages.
+  ticket.confluencePages = [];
+  if (adapter.type === 'jira' && !args.includes('--no-attachments')) {
+    try {
+      const jiraEnv = buildJiraEnv(conn);
+      const authHeader = buildAuthHeader(jiraEnv);
+      const apiVersion = conn.auth === 'cloud' ? 3 : 2;
+      const jiraOrigin = new URL(jiraEnv.JIRA_BASE_URL).origin;
+      const links = await fetchRemoteLinks(ticketKey, { env: jiraEnv, fetcher, apiVersion });
+      const MAX_CONFLUENCE_PAGES = 10;
+      const safeLinks = links
+        .filter(l => { try { return new URL(l.url).origin === jiraOrigin; } catch { return false; } })
+        .slice(0, MAX_CONFLUENCE_PAGES);
+      if (safeLinks.length > 0) {
+        const pages = await Promise.all(safeLinks.map(l => fetchConfluencePage(l.url, authHeader, { fetcher })));
+        ticket.confluencePages = pages.filter(Boolean);
+      }
+    } catch { /* non-fatal — a broken remote links endpoint must not fail the brief */ }
+  }
+  // ──────────────────────────────────────────────────────────────────────────
+
   // Save to brief cache for future requests
   if (!noCache) {
     writeBriefCache(ticketKey, conn.profileName, depth, ticket, configDir);

package/skills/jtb/scripts/lib/brief-assembler.mjs

@@ -43,6 +43,15 @@ export function assembleBrief(ticket, codeRefs = null) {
     sections.push(`## Linked Tickets\n\n${linkedSections.join('\n\n---\n\n')}`);
   }
 
+  if (ticket.confluencePages?.length > 0) {
+    const pageLines = ticket.confluencePages.map(p => {
+      const parts = [`### ${p.title ?? p.url}`];
+      if (p.text) parts.push(p.text);
+      return parts.join('\n\n');
+    });
+    sections.push(`## Confluence Pages\n\n${pageLines.join('\n\n---\n\n')}`);
+  }
+
   if (codeRefs) {
     const categories = [
       ['File Paths', codeRefs.filePaths],

package/skills/jtb/scripts/lib/confluence-client.mjs

@@ -0,0 +1,101 @@
+/**
+ * Confluence REST API client.
+ * Fetches page content for Confluence pages referenced in Jira remote links.
+ */
+
+/**
+ * Extracts the numeric page ID from a Confluence page URL.
+ * Supports Cloud (/wiki/spaces/{key}/pages/{id}) and Server (?pageId={id}).
+ * Returns null when the ID cannot be determined.
+ * @param {string} url
+ * @returns {string|null}
+ */
+export function extractConfluencePageId(url) {
+  if (!url) return null;
+
+  const qpMatch = url.match(/[?&]pageId=(\d+)/);
+  if (qpMatch) return qpMatch[1];
+
+  const pathMatch = url.match(/\/wiki\/spaces\/[^/]+\/pages\/(\d+)(?:\/|$)/);
+  if (pathMatch) return pathMatch[1];
+
+  return null;
+}
+
+/**
+ * Converts a Confluence view-body HTML string to plain text.
+ * Uses simple regex-based transformation — no external dependencies.
+ * @param {string} html
+ * @returns {string}
+ */
+export function htmlToText(html) {
+  if (!html) return '';
+  return html
+    .replace(/<\/?(p|div|h[1-6]|li|tr|td|th|blockquote|pre)[^>]*>/gi, '\n')
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<[^>]+>/g, '')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#160;|&nbsp;/g, ' ')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+/**
+ * Determines the Confluence REST API base path from a page URL.
+ * Cloud: {origin}/wiki/rest/api/content/{pageId}
+ * Server/DC without /wiki/: {origin}{/prefix}/rest/api/content/{pageId}
+ * @param {string} pageUrl
+ * @param {string} pageId
+ * @returns {string}
+ */
+function buildApiUrl(pageUrl, pageId) {
+  try {
+    const parsed = new URL(pageUrl);
+    if (parsed.pathname.includes('/wiki/')) {
+      return `${parsed.origin}/wiki/rest/api/content/${pageId}?expand=body.view`;
+    }
+    const confluencePrefix = parsed.pathname.match(/^(\/confluence)\//);
+    const prefix = confluencePrefix ? confluencePrefix[1] : '';
+    return `${parsed.origin}${prefix}/rest/api/content/${pageId}?expand=body.view`;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Fetches a Confluence page and returns its plain-text body.
+ * Returns null on any error (non-OK response, network failure, unparseable URL).
+ * @param {string} url - The Confluence page URL from the Jira remote link
+ * @param {object} authHeader - Authorization header object, e.g. { Authorization: 'Basic ...' }
+ * @param {{ fetcher?: Function, timeoutMs?: number }} [opts]
+ * @returns {Promise<{url: string, title: string, text: string}|null>}
+ */
+export async function fetchConfluencePage(url, authHeader, opts = {}) {
+  const { fetcher = globalThis.fetch, timeoutMs = 10_000 } = opts;
+
+  const pageId = extractConfluencePageId(url);
+  if (!pageId) return null;
+
+  const apiUrl = buildApiUrl(url, pageId);
+  if (!apiUrl) return null;
+
+  const fetchOpts = { headers: { ...authHeader, 'Content-Type': 'application/json' } };
+  if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
+
+  try {
+    const response = await fetcher(apiUrl, fetchOpts);
+    if (!response.ok) return null;
+
+    const data = await response.json();
+    return {
+      url,
+      title: data.title ?? null,
+      text: htmlToText(data.body?.view?.value ?? ''),
+    };
+  } catch {
+    return null;
+  }
+}

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

@@ -38,6 +38,7 @@ export function printHelp({ stream = process.stdout } = {}) {
     `    ${s.brand('ticketlens')} ${s.dim('<TICKET-KEY>')} ${s.dim('[options]')}   Fetch a ticket brief`,
     `    ${s.brand('ticketlens')} get ${s.dim('<TICKET-KEY>')}         Same as above ${s.dim('(explicit alias)')}`,
     `    ${s.brand('ticketlens')} triage ${s.dim('[options]')}         Scan your assigned tickets`,
+    `    ${s.brand('ticketlens')} review ${s.dim('[--base=BRANCH]')}    Code-review context brief from current branch`,
     `    ${s.brand('ticketlens')} compliance ${s.dim('<TICKET-KEY>')}    Check requirements coverage  ${s.dim('[Pro/Free 3/mo]')}`,
     '',
     `    ${s.brand('ticketlens')} delete ${s.dim('<PROFILE-NAME>')}     Remove a profile`,
@@ -539,3 +540,37 @@ export function printTriageHelp({ stream = process.stdout } = {}) {
   ];
   stream.write(lines.join('\n') + '\n');
 }
+
+export function printReviewHelp({ stream = process.stdout } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  const lines = [
+    '',
+    `  ${s.bold(s.brand('ticketlens'))} ${s.bold('review')} ${s.dim('[--base=BRANCH] [--profile=NAME]')}`,
+    '',
+    `  Assemble a code-review context brief from your current branch.`,
+    `  Extracts linked ticket keys from the branch name and commit messages,`,
+    `  fetches each ticket, and outputs a markdown brief for AI-assisted review.`,
+    '',
+    `  Requirements coverage analysis against the diff is available on ${s.dim('[Pro]')}.`,
+    '',
+    `  ${s.bold('OPTIONS')}`,
+    '',
+    `    ${s.brand('--base')}=${s.dim('BRANCH')}    Compare against this branch ${s.dim('(default: auto-detect main/master/develop)')}`,
+    `    ${s.brand('--profile')}=${s.dim('NAME')}  Use a specific tracker profile for ticket fetching`,
+    `    ${s.brand('-h')}, ${s.brand('--help')}       Show this help`,
+    '',
+    `  ${s.bold('EXAMPLES')}`,
+    '',
+    `    ${s.dim('$')} ticketlens review`,
+    `    ${s.dim('$')} ticketlens review --base=main`,
+    `    ${s.dim('$')} ticketlens review --base=main --profile=myteam`,
+    `    ${s.dim('$')} ticketlens review --base=main | pbcopy ${s.dim('# copy brief to clipboard')}`,
+    '',
+    `  ${s.bold('OUTPUT SECTIONS')}`,
+    '',
+    `    Branch, Changed files, Ticket context`,
+    `    Requirements coverage ${s.dim('[Pro]')}, Review focus ${s.dim('[Pro]')}`,
+    '',
+  ];
+  stream.write(lines.join('\n') + '\n');
+}

package/skills/jtb/scripts/lib/jira-client.mjs

@@ -131,6 +131,23 @@ export async function searchTickets(jql, opts = {}) {
   return (raw.issues ?? []).map(normalizeTicket);
 }
 
+export async function fetchRemoteLinks(ticketKey, opts = {}) {
+  const { env = process.env, fetcher = globalThis.fetch, apiVersion = 2, timeoutMs = 10_000 } = opts;
+  const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
+  const url = `${baseUrl}/rest/api/${apiVersion}/issue/${encodeURIComponent(ticketKey)}/remotelink`;
+
+  const fetchOpts = { headers: { ...buildAuthHeader(env), 'Content-Type': 'application/json' } };
+  if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
+
+  const response = await fetcher(url, fetchOpts);
+  if (!response.ok) return [];
+
+  const raw = await response.json();
+  return (raw ?? [])
+    .filter(link => link.application?.type === 'com.atlassian.confluence')
+    .map(link => ({ url: link.object.url, title: link.object.title ?? null }));
+}
+
 export async function fetchTicket(ticketKey, opts = {}) {
   const { env = process.env, fetcher = globalThis.fetch, depth = 1, apiVersion = 2, timeoutMs = 10_000, _visited = new Set(), _currentDepth = 0 } = opts;
   const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');

package/skills/jtb/scripts/lib/pr-review-assembler.mjs

@@ -0,0 +1,164 @@
+/**
+ * PR Review Context Assembler
+ * Given a git diff + pre-fetched tickets, produces a markdown brief
+ * suitable for AI-assisted code review.
+ */
+
+import { analyzeDiff } from './diff-analyzer.mjs';
+import { extractRequirements } from './requirement-extractor.mjs';
+
+const TICKET_KEY_RE = /\b([A-Z][A-Z0-9]+-\d+)\b/g;
+
+/**
+ * Extract all unique ticket keys from a string (branch name, commit messages, etc.).
+ * Returns a sorted, deduplicated array.
+ *
+ * @param {string} text
+ * @returns {string[]}
+ */
+export function extractTicketKeys(text) {
+  if (!text || typeof text !== 'string') return [];
+  const found = new Set(text.match(TICKET_KEY_RE) ?? []);
+  return [...found].sort();
+}
+
+/**
+ * Build the "### Changed files" section from a unified diff string.
+ * Parses "+++ b/<path>" headers.
+ *
+ * @param {string|null} diff
+ * @returns {string} markdown section or empty string
+ */
+function buildChangedFilesSection(diff) {
+  if (!diff) return '';
+  const files = [];
+  for (const line of diff.split('\n')) {
+    if (line.startsWith('+++ b/')) {
+      const path = line.slice(6).trim();
+      if (path && path !== '/dev/null') files.push(path);
+    }
+  }
+  if (files.length === 0) return '';
+  const lines = ['', `### Changed files (${files.length})`];
+  for (const f of files) lines.push(`- ${f}`);
+  return lines.join('\n');
+}
+
+/**
+ * Build the coverage + review-focus sections for all tickets (Pro-gated).
+ * Returns empty string when no requirements exist across all tickets.
+ *
+ * @param {object[]} tickets
+ * @param {string} diff
+ * @param {Function} extractRequirementsFn
+ * @param {Function} analyzeDiffFn
+ * @returns {string}
+ */
+function buildCoverageSections(tickets, diff, extractRequirementsFn, analyzeDiffFn) {
+  const coverageEntries = [];
+  const focusEntries = [];
+
+  for (const ticket of tickets) {
+    const reqs = extractRequirementsFn(ticket.description ?? '');
+    if (reqs.length === 0) continue;
+
+    const { results, coveragePercent } = analyzeDiffFn(reqs, diff);
+    coverageEntries.push({ ticket, results, coveragePercent });
+
+    const uncovered = results
+      .filter(r => r.status === 'NOT_FOUND')
+      .map(r => r.requirement);
+    if (uncovered.length > 0) focusEntries.push({ ticket, uncovered });
+  }
+
+  if (coverageEntries.length === 0) return '';
+
+  const lines = ['', '### Requirements coverage'];
+  for (const { ticket, results, coveragePercent } of coverageEntries) {
+    lines.push('', `#### ${ticket.key} (${coveragePercent}%)`);
+    for (const r of results) {
+      if (r.status === 'NOT_FOUND') {
+        lines.push(`- ✖ ${r.requirement}`);
+      } else {
+        const loc = r.evidence ? ` — ${r.evidence}` : '';
+        const mark = r.status === 'FOUND' ? '✔' : '~';
+        lines.push(`- ${mark} ${r.requirement}${loc}`);
+      }
+    }
+  }
+
+  if (focusEntries.length > 0) {
+    lines.push('', '### Review focus');
+    for (const { ticket, uncovered } of focusEntries) {
+      lines.push('', `#### ${ticket.key} — uncovered requirements`);
+      for (const req of uncovered) lines.push(`- ${req}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Assemble a markdown PR code-review context brief.
+ *
+ * @param {object} opts
+ * @param {string|null}  [opts.diff]               - git diff string
+ * @param {object[]}     [opts.tickets]             - pre-fetched ticket objects
+ * @param {string}       [opts.baseBranch]          - e.g. 'main'
+ * @param {string|null}  [opts.headBranch]          - current branch name
+ * @param {Function}     [opts.isLicensedFn]        - fn(tier) → bool
+ * @param {Function}     [opts.analyzeDiffFn]       - injectable (tests)
+ * @param {Function}     [opts.extractRequirementsFn] - injectable (tests)
+ * @returns {Promise<string>}
+ */
+export async function assemblePrReview({
+  diff = null,
+  tickets = [],
+  baseBranch = 'main',
+  headBranch = null,
+  isLicensedFn = () => false,
+  analyzeDiffFn = analyzeDiff,
+  extractRequirementsFn = extractRequirements,
+} = {}) {
+  const lines = ['## PR Review Context'];
+
+  // Branch
+  lines.push('', '### Branch');
+  if (headBranch) {
+    lines.push(`\`${headBranch}\` → \`${baseBranch}\``);
+  } else {
+    lines.push(`→ \`${baseBranch}\``);
+  }
+
+  // Changed files (from diff)
+  const filesSection = buildChangedFilesSection(diff);
+  if (filesSection) lines.push(filesSection);
+
+  if (tickets.length === 0) {
+    lines.push('', '_No linked tickets found in branch name or commits._');
+  } else {
+    // Ticket context
+    lines.push('', '### Ticket context');
+    for (const ticket of tickets) {
+      const reqs = extractRequirementsFn(ticket.description ?? '');
+      lines.push('', `#### ${ticket.key}: ${ticket.summary ?? ''}`);
+      if (reqs.length === 0) {
+        lines.push('_No requirements found._');
+      } else {
+        for (const req of reqs) lines.push(`- ${req}`);
+      }
+    }
+
+    // Requirements coverage (Pro-gated, requires diff)
+    if (isLicensedFn('pro') && diff) {
+      const coverageOut = buildCoverageSections(tickets, diff, extractRequirementsFn, analyzeDiffFn);
+      if (coverageOut) lines.push(coverageOut);
+    } else if (!isLicensedFn('pro')) {
+      lines.push('', '_Requirements coverage analysis requires a Pro license — `ticketlens activate <KEY>`_');
+    }
+  }
+
+  lines.push('', '---', `_Generated by TicketLens · \`ticketlens review --base=${baseBranch}\`_`);
+
+  return lines.join('\n');
+}

package/skills/jtb/scripts/lib/styled-assembler.mjs

@@ -131,6 +131,16 @@ export function styleBrief(ticket, codeRefs = null, opts = {}) {
     sections.push(`${s.bold(s.brand('Linked Tickets'))}\n${s.dim('─'.repeat(divWidth()))}\n${linkedSections.join(`\n\n${s.dim('─'.repeat(halfDivWidth()))}\n`)}`);
   }
 
+  // Confluence pages
+  if (ticket.confluencePages?.length > 0) {
+    const pageLines = ticket.confluencePages.map(p => {
+      const parts = [s.brand(p.title ?? p.url)];
+      if (p.text) parts.push(p.text);
+      return parts.join('\n\n');
+    });
+    sections.push(`${s.bold(s.brand('Confluence Pages'))}\n${s.dim('─'.repeat(divWidth()))}\n${pageLines.join(`\n\n${s.dim('─'.repeat(halfDivWidth()))}\n`)}`);
+  }
+
   // Code references
   if (codeRefs) {
     const categories = [