ticketlens 0.38.47 → 0.38.48

package/README.md

@@ -294,10 +294,14 @@ Flag validation provides actionable hints:
 ticketlens compliance <TICKET-KEY>                # Check ticket requirements against local diff [Pro/Free 3/mo]
 ticketlens compliance <TICKET-KEY> --profile=acme # Specify a profile
 ticketlens compliance <TICKET-KEY> --plain        # Plain markdown output
+ticketlens compliance <TICKET-KEY> --consensus    # Multi-agent AI review instead of the local matcher [Pro]
+ticketlens compliance <TICKET-KEY> --consensus -y # Same, skipping the cost-confirmation prompt
 ```
 
 Runs the same compliance check as `ticketlens CNV1-2 --compliance` but as a dedicated subcommand — useful when you want to check compliance without fetching the full ticket brief. Free accounts get 3 checks per month; Pro is unlimited.
 
+`--consensus` (Pro) replaces the local deterministic matcher with independent reviews from every AI provider configured in `~/.ticketlens/credentials.json` (2+ of `anthropicApiKey`/`openaiApiKey`/`groqApiKey` required), reconciled by majority vote after a disagreement-triggered refinement round. This is the only compliance path that sends your diff off-machine — directly to each configured AI provider, never to TicketLens's own servers. The diff is scanned for secrets before anything is sent; a detected secret blocks the run with no network call made. Prompts for confirmation before spending API credits unless `-y`/`--yes` is passed.
+
 ---
 
 ### Compliance Ledger
@@ -456,7 +460,7 @@ Every note is scanned before saving — anything shaped like a real secret (API
 
 **Removing a note:** `ticketlens note delete --id="..." [--ticket=KEY]` removes a note from your local vault. Local only — if it was already pushed to a team, teammates who pulled it keep their copy; deleting it there too is a manager action from the Console (Admin > Recall).
 
-**Any MCP-capable AI harness:** `ticketlens mcp` starts a stdio [MCP](https://modelcontextprotocol.io) server exposing `fetch`, `triage`, `compliance`, `review`, `standup`, `pr`, `stats`, `issue_types`, `history`, `collisions`, `ledger`, `doctor`, `recall_add`, `recall_update`, `recall_delete`, `recall_search`, `ticket_comment`, `ticket_transition`, `ticket_assign`, `ticket_duplicates`, `ticket_link`, `ticket_update`, and `ticket_create` as native tools — every CLI action now has an MCP tool, so any MCP-compatible AI assistant, not just Claude Code, can call them directly instead of constructing a shell command. It's a thin adapter over the exact same code as the CLI commands above — same license gate per tool, same secret scan/local vault/tracker writes, same team sync — nothing is reimplemented. `fetch`, `doctor`, and `standup` are Free; `triage`'s base scan is Free with some options gated Pro/Team, same as the CLI (`ticketlens triage --help`); `compliance` and `pr` are Free, sharing a 3-checks/month cap on their requirements-coverage section, Pro unlimited; `review` is Free for branch/files/ticket context, with its coverage/focus section requiring Pro as a plain license check — it does not draw from that same monthly counter; `stats` is Free with a 7-day lookback cap, Pro extends it to 30 days, same split as the CLI (`ticketlens stats --help`); `issue_types` is Free and Jira-only — pre-fetches and caches a profile's real creatable projects and issue types ahead of a `ticket_create` attempt, sharing its cache with that tool's own reactive enrichment; Linear/GitHub profiles get a clear "not available" instead of an empty result; `history` reads local triage history only (zero network) and requires Pro; `collisions` requires `ticketlens login` (Console access) plus a Team license; `ledger` exports the local, signed compliance audit trail (zero network) and requires Pro; every other tool needs Pro. `recall_update` overwrites an existing Recall note's body — internal plumbing for the note quality loop, not typically called directly; its `attachments` array appends new files to whatever the note already has, same as `recall_add`'s, never replacing existing ones. `recall_delete` is destructive and local-vault-only — requires `confirm: true` alongside `id` to actually execute; there is no interactive y/N prompt under MCP (no real terminal to prompt against), so omitting it always fails rather than silently blocking. Point your harness's MCP config at it: `{ "command": "ticketlens", "args": ["mcp"] }` — or run `ticketlens mcp install` in a project to write that entry into its `.mcp.json` for you (creates the file if it doesn't exist, merges in if it does — never touches any other entry already there; `--dry-run` to preview first).
+**Any MCP-capable AI harness:** `ticketlens mcp` starts a stdio [MCP](https://modelcontextprotocol.io) server exposing `fetch`, `triage`, `compliance`, `review`, `standup`, `pr`, `stats`, `issue_types`, `history`, `collisions`, `ledger`, `doctor`, `recall_add`, `recall_update`, `recall_delete`, `recall_search`, `ticket_comment`, `ticket_transition`, `ticket_assign`, `ticket_duplicates`, `ticket_link`, `ticket_update`, and `ticket_create` as native tools — every CLI action now has an MCP tool, so any MCP-compatible AI assistant, not just Claude Code, can call them directly instead of constructing a shell command. It's a thin adapter over the exact same code as the CLI commands above — same license gate per tool, same secret scan/local vault/tracker writes, same team sync — nothing is reimplemented. `fetch`, `doctor`, and `standup` are Free; `triage`'s base scan is Free with some options gated Pro/Team, same as the CLI (`ticketlens triage --help`); `compliance` and `pr` are Free, sharing a 3-checks/month cap on their requirements-coverage section, Pro unlimited; `compliance` additionally accepts `consensus: true` (Pro) to replace the local deterministic matcher with a multi-agent AI review — sends the diff directly to each of your configured AI providers (never to TicketLens's own servers), requires 2+ of anthropic/openai/groq keys configured, and always implies `--yes` under MCP since there's no TTY for the cost-confirmation prompt; `review` is Free for branch/files/ticket context, with its coverage/focus section requiring Pro as a plain license check — it does not draw from that same monthly counter; `stats` is Free with a 7-day lookback cap, Pro extends it to 30 days, same split as the CLI (`ticketlens stats --help`); `issue_types` is Free and Jira-only — pre-fetches and caches a profile's real creatable projects and issue types ahead of a `ticket_create` attempt, sharing its cache with that tool's own reactive enrichment; Linear/GitHub profiles get a clear "not available" instead of an empty result; `history` reads local triage history only (zero network) and requires Pro; `collisions` requires `ticketlens login` (Console access) plus a Team license; `ledger` exports the local, signed compliance audit trail (zero network) and requires Pro; every other tool needs Pro. `recall_update` overwrites an existing Recall note's body — internal plumbing for the note quality loop, not typically called directly; its `attachments` array appends new files to whatever the note already has, same as `recall_add`'s, never replacing existing ones. `recall_delete` is destructive and local-vault-only — requires `confirm: true` alongside `id` to actually execute; there is no interactive y/N prompt under MCP (no real terminal to prompt against), so omitting it always fails rather than silently blocking. Point your harness's MCP config at it: `{ "command": "ticketlens", "args": ["mcp"] }` — or run `ticketlens mcp install` in a project to write that entry into its `.mcp.json` for you (creates the file if it doesn't exist, merges in if it does — never touches any other entry already there; `--dry-run` to preview first).
 
 `note add`'s save confirmation and `recall`'s search results are styled by default in a terminal; add `--plain` to either for bare, pipe-safe output. `recall` always shows each note's file ID (e.g. `[1784135399545-fe01c4.md]`) so you can open it directly (`cat ~/.ticketlens/recall/<PREFIX>/<id>`), or pass `--full` to print the full body content inline instead. Each result shows a relative time (`2h ago`, `3d ago`) rather than a bare date — the full-precision timestamp is always in the note file's own frontmatter.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.38.47",
+  "version": "0.38.48",
   "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.42.6 -->
+<!-- jtb-skill-version: 0.42.7 -->
 ---
 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.
@@ -529,12 +529,20 @@ Use this evaluation order:
 3. **Manual checklist** — list each requirement for the developer to verify manually
 
 ### Privacy
-`--compliance` never sends data anywhere. The diff stays local. All analysis is performed by Claude Code within your session context.
+`--compliance` never sends data anywhere. The diff stays local. All analysis is performed by Claude Code within your session context. (The standalone command's `--consensus` opt-in below is the one exception — see that section.)
 
 ### Standalone command
 The same tier-gated check also runs as its own command — `ticketlens compliance PROJ-123` — independent of a full ticket fetch. This is what `ticketlens install-hooks` wires into a pre-push git hook (`ticketlens compliance "$KEY" || exit 1`, gated on a configurable coverage threshold). It shares the same `FREE_LIMIT`/Pro gate and the same compliance ledger as the `--compliance` flag above.
 
-If this harness has TicketLens's MCP server configured (a tool named `compliance` — often shown as `mcp__ticketlens__compliance` — visible in your tool list), prefer it over the bash form: same tier gate (Free: 3 checks/month, Pro: unlimited), same report — just no shell command to construct or stdout to parse. It accepts `ticket`/`profile`, matching the standalone command's arguments above.
+If this harness has TicketLens's MCP server configured (a tool named `compliance` — often shown as `mcp__ticketlens__compliance` — visible in your tool list), prefer it over the bash form: same tier gate (Free: 3 checks/month, Pro: unlimited), same report — just no shell command to construct or stdout to parse. It accepts `ticket`/`profile`/`consensus`, matching the standalone command's arguments below.
+
+### --consensus: Multi-Agent AI Review (standalone command only, Pro)
+`ticketlens compliance PROJ-123 --consensus` replaces the local deterministic keyword-diff matcher with a multi-agent AI review, for a higher-confidence check on requirements that plain keyword matching tends to misjudge (paraphrased requirements, negative conditions, cross-file logic).
+
+- **This is the one path in TicketLens that sends your diff off-machine** — directly to each AI provider you've configured (never to TicketLens's own servers). Requires **2+** of `anthropicApiKey`/`openaiApiKey`/`groqApiKey` set in `~/.ticketlens/credentials.json` (the same local BYOK file `ticketlens summarize` uses — set up via `ticketlens init` or manually). Before anything is sent, the diff runs through the same secret scanner Recall notes use (`secret-scanner.mjs`) — a detected secret blocks the run entirely, before any network call.
+- Each configured provider independently reviews every requirement; where agents disagree, a second refinement round shows each agent its peers' (anonymized) verdicts and lets it reconsider; final verdicts are reconciled by majority vote, ties broken toward the stricter verdict. The report always shows the full per-agent breakdown, including any round-1→round-2 change.
+- Prompts for confirmation before making any API calls (real cost against your own provider keys) unless `-y`/`--yes` is passed. Over MCP, `consensus: true` always implies yes (no TTY to prompt).
+- `Phase 2` (not yet built): GLM/Kimi/DeepSeek/Qwen/Devstral/Gemini/Gemma providers. `Phase 1.5` (not yet built): scored iterative refinement with a stronger-model arbiter judging consensus acceptability, instead of plain majority vote.
 
 ### Ledger export
 `ticketlens ledger [--format=json|csv]` exports the same local, signed compliance ledger these checks write to — entirely local, no network call. `[Pro]`. If this harness has TicketLens's MCP server configured (a tool named `ledger` — often shown as `mcp__ticketlens__ledger` — visible in your tool list), prefer it over the bash form: same tier gate, same export, just no shell command to construct or stdout to parse. It accepts `format` (`json`/`csv`, defaults to `json`).

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

@@ -33,6 +33,7 @@ import { apiBase } from './lib/api-utils.mjs';
 import { isLicensed, showUpgradePrompt, readLicense } from './lib/license.mjs';
 import { detectVcs } from './lib/vcs-detector.mjs';
 import { runComplianceCheck } from './lib/compliance-checker.mjs';
+import { runConsensusCheck } from './lib/consensus-checker.mjs';
 import { fetchRemoteLinks, buildAuthHeader } from './lib/jira-client.mjs';
 import { fetchConfluencePage } from './lib/confluence-client.mjs';
 
@@ -683,13 +684,18 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
     const codeRefsC = extractCodeReferences(allTextC);
     const briefC = assembleBrief(ticketC, codeRefsC);
 
-    const complianceRunner = opts.runComplianceCheck ?? runComplianceCheck;
+    const useConsensus = args.includes('--consensus');
+    const forceYes = args.includes('--yes') || args.includes('-y');
+    const complianceRunner = useConsensus
+      ? (opts.runConsensusCheck ?? runConsensusCheck)
+      : (opts.runComplianceCheck ?? runComplianceCheck);
     const complianceResult = await complianceRunner({
       brief: briefC,
       description: ticketC.description,
       ticketKey: ticketKeyArg,
       configDir: resolvedConfigDir,
       stream: errStream,
+      ...(useConsensus ? { forceYes } : {}),
     });
 
     if (complianceResult === null) {

package/skills/jtb/scripts/lib/api-utils.mjs

@@ -3,7 +3,7 @@
  * Centralised here to avoid triplicating the regex and warning logic.
  */
 
-export const DEFAULT_API_BASE = 'http://api.ticketlens.test';
+export const DEFAULT_API_BASE = 'https://api.ticketlens.app';
 export const DEFAULT_SITE_BASE = 'https://ticketlens.app';
 
 // Matches localhost, 127.0.0.1, and any hostname ending in .test or .local,

package/skills/jtb/scripts/lib/compliance-checker.mjs

@@ -19,7 +19,7 @@ export function statusColor(status, s) {
 // Shared with matchColor in ticket-command.mjs (duplicates' match-confidence
 // tiers) — same 70/50 thresholds, same green/yellow/dim vocabulary, applied
 // here to overall requirement coverage instead of a single match score.
-function coverageColor(pct, s) {
+export function coverageColor(pct, s) {
   if (pct >= 70) return s.green;
   if (pct >= 50) return s.yellow;
   return s.dim;

package/skills/jtb/scripts/lib/consensus-checker.mjs

@@ -0,0 +1,271 @@
+import { isLicensed, showUpgradePrompt } from './license.mjs';
+import { extractRequirements } from './requirement-extractor.mjs';
+import { findLinkedCommits } from './commit-linker.mjs';
+import { loadCredentials } from './profile-resolver.mjs';
+import { summarize } from './summarizer.mjs';
+import { DEFAULT_CONFIG_DIR } from './config.mjs';
+import { createStyler } from './ansi.mjs';
+import { STATUS_ICON, statusColor, coverageColor } from './compliance-checker.mjs';
+import { scanForSecrets } from './secret-scanner.mjs';
+
+const PROVIDER_ORDER = ['anthropic', 'openai', 'groq'];
+const PROVIDER_KEY_FIELD = { anthropic: 'anthropicApiKey', openai: 'openaiApiKey', groq: 'groqApiKey' };
+// Lower = stricter (less coverage claimed). Drives tie-break in reconcileRequirement.
+const STRICTNESS = { NOT_FOUND: 0, PARTIAL: 1, FOUND: 2 };
+const MAX_TOKENS = 512;
+// Each "requirement text | STATUS" response line runs ~20-40 tokens — scale the
+// floor up for tickets with many acceptance criteria so the model's per-requirement
+// list doesn't get cut off mid-response (a truncated response silently reads as
+// NOT_FOUND for every unparsed requirement via parseVerdicts, not as an error).
+const TOKENS_PER_REQUIREMENT = 40;
+
+export function getConfiguredProviders(credentials) {
+  if (!credentials) return [];
+  return PROVIDER_ORDER.filter(p => !!credentials[PROVIDER_KEY_FIELD[p]]);
+}
+
+/** Ports ComplianceController::parseAnalysis's line-matching convention to JS. */
+export function parseVerdicts(requirements, rawAnalysis) {
+  const lines = (rawAnalysis ?? '').split('\n');
+  return requirements.map(req => {
+    const needle = req.slice(0, 20).toLowerCase();
+    let status = 'NOT_FOUND';
+    for (const line of lines) {
+      if (!line.toLowerCase().includes(needle)) continue;
+      const upper = line.toUpperCase();
+      if (upper.includes('PARTIAL')) status = 'PARTIAL';
+      else if (upper.includes('FOUND') && !upper.includes('NOT_FOUND')) status = 'FOUND';
+      break;
+    }
+    return status;
+  });
+}
+
+/** Majority vote across agents' final verdicts for one requirement; ties go to the stricter verdict. */
+export function reconcileRequirement(verdicts) {
+  const counts = new Map();
+  for (const v of verdicts) counts.set(v, (counts.get(v) ?? 0) + 1);
+  const maxCount = Math.max(...counts.values());
+  const topStatuses = [...counts.entries()].filter(([, c]) => c === maxCount).map(([status]) => status);
+  if (topStatuses.length === 1) return topStatuses[0];
+  return topStatuses.reduce((strictest, s) => (STRICTNESS[s] < STRICTNESS[strictest] ? s : strictest));
+}
+
+function buildRound1Prompt(diff, requirements) {
+  return 'You are a compliance checker. Given this code diff, evaluate whether each requirement listed is addressed.\n\n'
+    + `Diff:\n${diff || '(no diff available)'}\n\n`
+    + 'Requirements to check:\n'
+    + requirements.map(r => `- ${r}`).join('\n')
+    + "\n\nFor each requirement, respond with: FOUND, PARTIAL, or NOT_FOUND. One per line, format: '<requirement> | <status>'.";
+}
+
+function buildRound2Prompt(diff, disagreedItems, selfProvider, successful1) {
+  const peers = successful1.filter(r => r.provider !== selfProvider);
+  const lines = [
+    'You previously reviewed a code diff against a set of requirements. Other independent',
+    'reviewers disagreed with you on some items below. Reconsider only these, in light of',
+    "their assessments, and respond again in the same format.",
+    '',
+    `Diff:\n${diff || '(no diff available)'}`,
+    '',
+  ];
+  for (const { requirement, index } of disagreedItems) {
+    lines.push(`Requirement: ${requirement}`);
+    peers.forEach((peer, i) => lines.push(`  Reviewer ${i + 1} said: ${peer.verdicts[index]}`));
+    lines.push('');
+  }
+  lines.push("For each requirement above, respond with: FOUND, PARTIAL, or NOT_FOUND. One per line, format: '<requirement> | <status>'.");
+  return lines.join('\n');
+}
+
+/** Interactive y/N cost-confirmation gate — same non-interactive fallback shape as confirmDestructive. */
+async function confirmCost(providerCount, { stream = process.stderr, stdin = process.stdin } = {}) {
+  if (!stdin.isTTY || !stdin.setRawMode) {
+    stream.write('  Non-interactive mode: pass --yes/-y to run --consensus without a prompt.\n');
+    return false;
+  }
+  stream.write(`  --consensus will make ${providerCount} AI API call(s) using your configured keys. Continue?  y/N  `);
+  return new Promise(resolve => {
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.once('data', buf => {
+      stdin.setRawMode(false);
+      stdin.pause();
+      const confirmed = buf.toString().toLowerCase() === 'y';
+      stream.write(confirmed ? 'y\n' : 'N\n');
+      resolve(confirmed);
+    });
+  });
+}
+
+function formatNoCriteriaReport(ticketKey, s) {
+  return [
+    '',
+    `  Consensus Compliance Check — ${s.brand(s.bold(ticketKey))}`,
+    `  ${s.dim('─'.repeat(50))}`,
+    '',
+    '  No acceptance criteria found in ticket description.',
+    '  Add a "Acceptance Criteria" section or Given/When/Then statements.',
+    '',
+  ].join('\n');
+}
+
+function formatConsensusReport({ ticketKey, results, coveragePercent, finalVerdictsByAgent, disagreedCount, s }) {
+  const lines = [
+    '',
+    `  Consensus Compliance Check — ${s.brand(s.bold(ticketKey))}`,
+    `  ${s.dim('─'.repeat(50))}`,
+    `  ${s.dim(`${finalVerdictsByAgent.length} agents: ${finalVerdictsByAgent.map(a => a.provider).join(', ')}`)}`,
+    '',
+  ];
+
+  for (const { requirement, status } of results) {
+    const icon = statusColor(status, s)(STATUS_ICON[status] ?? '?');
+    lines.push(`  ${icon} ${requirement}`);
+  }
+
+  lines.push('');
+  const found = results.filter(r => r.status === 'FOUND').length;
+  lines.push(`  Coverage: ${coverageColor(coveragePercent, s)(`${coveragePercent}%`)}  (${found}/${results.length} requirements found)`);
+  if (disagreedCount > 0) {
+    lines.push(`  ${s.dim(`${disagreedCount} requirement(s) needed a refinement round (agents initially disagreed).`)}`);
+  }
+  lines.push('');
+  lines.push(`  ${s.bold('Per-agent breakdown:')}`);
+  for (const { provider, verdicts, round1Verdicts } of finalVerdictsByAgent) {
+    const parts = verdicts.map((v, i) => (round1Verdicts[i] !== v ? `${round1Verdicts[i]}→${v}` : v));
+    lines.push(`  ${s.dim(provider)}: ${parts.join(', ')}`);
+  }
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+export async function runConsensusCheck({
+  brief,
+  description = null,
+  ticketKey,
+  configDir = DEFAULT_CONFIG_DIR,
+  stream = process.stderr,
+  outStream = process.stdout,
+  forceYes = false,
+  stdin = process.stdin,
+  isLicensedFn = isLicensed,
+  showUpgradeFn = showUpgradePrompt,
+  extractRequirementsFn = extractRequirements,
+  findLinkedCommitsFn = findLinkedCommits,
+  loadCredentialsFn = loadCredentials,
+  summarizeFn = summarize,
+  confirmCostFn = confirmCost,
+  scanForSecretsFn = scanForSecrets,
+}) {
+  if (!isLicensedFn('pro', configDir)) {
+    showUpgradeFn('pro', '--consensus', { stream });
+    return null;
+  }
+
+  const requirements = extractRequirementsFn(description ?? brief);
+  const s = createStyler({ isTTY: outStream.isTTY });
+
+  if (requirements.length === 0) {
+    return { report: formatNoCriteriaReport(ticketKey, s), results: [], coveragePercent: 0, noCriteria: true };
+  }
+
+  const { diff } = findLinkedCommitsFn(ticketKey, { cwd: process.cwd() });
+
+  // --consensus is the only compliance path that sends the diff off-machine (to each
+  // configured AI vendor directly) — scan it before anything else touches the network,
+  // the same gate note-command.mjs applies to Recall note bodies before they leave the vault.
+  const scan = scanForSecretsFn({ body: diff ?? '' });
+  if (scan.rejected) {
+    stream.write(`  ✖ --consensus blocked — the diff looks like it contains a secret: ${scan.reasons.join(' ')}\n`);
+    return null;
+  }
+  for (const warning of scan.warnings) {
+    stream.write(`  Warning: ${warning}\n`);
+  }
+
+  const credentials = loadCredentialsFn(configDir);
+  const providers = getConfiguredProviders(credentials);
+  if (providers.length < 2) {
+    stream.write(
+      '  ✖ --consensus needs at least 2 configured AI providers. Configure with: ' +
+      'ticketlens cloud-keys add <provider> <key>, or add anthropicApiKey/openaiApiKey/groqApiKey ' +
+      'to ~/.ticketlens/credentials.json.\n'
+    );
+    return null;
+  }
+
+  if (!forceYes) {
+    const proceed = await confirmCostFn(providers.length, { stream, stdin });
+    if (!proceed) {
+      stream.write('  Aborted — no API calls made.\n');
+      return null;
+    }
+  }
+
+  const round1Prompt = buildRound1Prompt(diff, requirements);
+  const round1MaxTokens = Math.max(MAX_TOKENS, requirements.length * TOKENS_PER_REQUIREMENT);
+
+  const round1 = await Promise.all(providers.map(async provider => {
+    try {
+      const raw = await summarizeFn({ mode: 'byok', credentials, provider, prompt: round1Prompt, brief: '', maxTokens: round1MaxTokens });
+      return { provider, verdicts: parseVerdicts(requirements, raw), error: null };
+    } catch (err) {
+      return { provider, verdicts: null, error: err.message };
+    }
+  }));
+
+  const successful1 = round1.filter(r => !r.error);
+  if (successful1.length < 2) {
+    stream.write(`  ✖ Only ${successful1.length} provider(s) responded successfully — need at least 2 for consensus.\n`);
+    for (const r of round1) if (r.error) stream.write(`    ${r.provider}: ${r.error}\n`);
+    return null;
+  }
+
+  const disagreedIndexes = requirements
+    .map((_, i) => i)
+    .filter(i => new Set(successful1.map(r => r.verdicts[i])).size > 1);
+
+  let round2 = [];
+  if (disagreedIndexes.length > 0) {
+    const disagreedItems = disagreedIndexes.map(i => ({ requirement: requirements[i], index: i }));
+    const round2MaxTokens = Math.max(MAX_TOKENS, disagreedItems.length * TOKENS_PER_REQUIREMENT);
+    round2 = await Promise.all(successful1.map(async ({ provider }) => {
+      const prompt = buildRound2Prompt(diff, disagreedItems, provider, successful1);
+      try {
+        const raw = await summarizeFn({ mode: 'byok', credentials, provider, prompt, brief: '', maxTokens: round2MaxTokens });
+        const refined = parseVerdicts(disagreedItems.map(d => d.requirement), raw);
+        return { provider, refined: Object.fromEntries(disagreedItems.map((d, idx) => [d.index, refined[idx]])) };
+      } catch (err) {
+        stream.write(`  ⚠ ${provider}: refinement round failed (${err.message}) — keeping its round-1 verdict.\n`);
+        return { provider, refined: {} }; // degrade — keep the round-1 verdict for this agent
+      }
+    }));
+  }
+
+  const finalVerdictsByAgent = successful1.map(r1 => {
+    const r2 = round2.find(r => r.provider === r1.provider);
+    return {
+      provider: r1.provider,
+      round1Verdicts: r1.verdicts,
+      verdicts: requirements.map((_, i) => r2?.refined[i] ?? r1.verdicts[i]),
+    };
+  });
+
+  const results = requirements.map((requirement, i) => ({
+    requirement,
+    status: reconcileRequirement(finalVerdictsByAgent.map(a => a.verdicts[i])),
+    evidence: null,
+  }));
+
+  const found = results.filter(r => r.status === 'FOUND').length;
+  const partial = results.filter(r => r.status === 'PARTIAL').length;
+  const coveragePercent = Math.round(((found + partial * 0.5) / results.length) * 100);
+
+  const report = formatConsensusReport({
+    ticketKey, results, coveragePercent, finalVerdictsByAgent, disagreedCount: disagreedIndexes.length, s,
+  });
+
+  return { report, results, coveragePercent, noCriteria: false };
+}

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

@@ -658,6 +658,9 @@ export function printMcpHelp({ stream = process.stdout } = {}) {
     `  ${s.cyan('fetch')}, ${s.cyan('doctor')}, and ${s.cyan('standup')} are Free; ${s.cyan('triage')} is Free with some Pro/Team-gated`,
     `  options (see ${s.cyan('ticketlens triage --help')}); ${s.cyan('compliance')} and ${s.cyan('pr')} are Free, sharing a`,
     `  3-checks/month cap on their requirements-coverage section, Pro unlimited;`,
+    `  ${s.cyan('compliance')}'s \`consensus: true\` (Pro) sends the diff directly to your configured`,
+    `  AI providers instead — never to TicketLens's own servers — and always implies`,
+    `  \`--yes\` under MCP, since there is no TTY for the cost-confirmation prompt;`,
     `  ${s.cyan('review')} is Free for branch/files/ticket context — its coverage/focus section`,
     `  requires Pro as a plain license check, not a draw on that same counter;`,
     `  ${s.cyan('stats')} is Free with a 7-day lookback, Pro extends it to 30 days, same split`,
@@ -1089,7 +1092,7 @@ export function printComplianceHelp({ stream = process.stdout } = {}) {
   const s = createStyler({ isTTY: stream.isTTY });
   const lines = [
     '',
-    `  ${s.bold(s.brand('ticketlens'))} ${s.bold('compliance')} ${s.dim('<TICKET-KEY> [--profile=NAME]')}  ${s.dim('[Pro/Free 3/mo]')}`,
+    `  ${s.bold(s.brand('ticketlens'))} ${s.bold('compliance')} ${s.dim('<TICKET-KEY> [--profile=NAME] [--consensus [-y]]')}  ${s.dim('[Pro/Free 3/mo]')}`,
     '',
     `  Check your current branch's diff against the ticket's requirements.`,
     `  Extracts candidate requirements from the ticket description and diffs`,
@@ -1102,12 +1105,22 @@ export function printComplianceHelp({ stream = process.stdout } = {}) {
     `  ${s.bold('OPTIONS')}`,
     '',
     `    ${s.brand('--profile')}=${s.dim('NAME')}  Use a specific Jira profile`,
+    `    ${s.brand('--consensus')}      Replace the local matcher with a multi-agent AI review ${s.dim('[Pro]')}`,
+    `    ${s.dim('               ')}    — routes the same requirements-vs-diff check through every`,
+    `    ${s.dim('               ')}    AI provider configured in ~/.ticketlens/credentials.json`,
+    `    ${s.dim('               ')}    (2+ of anthropicApiKey/openaiApiKey/groqApiKey required),`,
+    `    ${s.dim('               ')}    reconciles disagreements with a refinement round, then a`,
+    `    ${s.dim('               ')}    majority vote. Calls each provider directly — never TicketLens's`,
+    `    ${s.dim('               ')}    own servers. Prompts for confirmation before spending API credits.`,
+    `    ${s.brand('-y')}, ${s.brand('--yes')}       Skip the --consensus cost confirmation prompt`,
     `    ${s.brand('-h')}, ${s.brand('--help')}   Show this help`,
     '',
     `  ${s.bold('EXAMPLES')}`,
     '',
     `    ${s.dim('$')} ticketlens compliance PROJ-123`,
     `    ${s.dim('$')} ticketlens compliance PROJ-123 --profile=myteam`,
+    `    ${s.dim('$')} ticketlens compliance PROJ-123 --consensus`,
+    `    ${s.dim('$')} ticketlens compliance PROJ-123 --consensus -y`,
     '',
   ];
   stream.write(lines.join('\n') + '\n');

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

@@ -174,9 +174,12 @@ async function callTriage(args, { configDir, runTriageFn }) {
  * printErr through it before this tool existed — see the fetch tool's own
  * shipping notes for why that treatment was deferred per-tool).
  */
-function buildComplianceArgs({ ticket, profile }) {
+function buildComplianceArgs({ ticket, profile, consensus }) {
   const args = ['compliance', ticket];
   if (profile) args.push(`--profile=${profile}`);
+  // MCP has no TTY to answer the interactive cost-confirmation prompt, so --consensus
+  // always implies --yes here — the caller already opted in by setting consensus: true.
+  if (consensus) args.push('--consensus', '--yes');
   return args;
 }
 

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

@@ -42,12 +42,13 @@ export const TOOLS = [
   },
   {
     name: 'compliance',
-    description: 'Check a ticket\'s acceptance-criteria coverage against the current git diff — extracts requirements from the ticket description, matches them against code changes, and reports a coverage percentage plus what\'s missing. Read-only; the same check `ticketlens install-hooks` runs automatically. Free tier: 3 checks per month; TicketLens Pro removes the limit.',
+    description: 'Check a ticket\'s acceptance-criteria coverage against the current git diff — extracts requirements from the ticket description, matches them against code changes, and reports a coverage percentage plus what\'s missing. Read-only; the same check `ticketlens install-hooks` runs automatically. Free tier: 3 checks per month; TicketLens Pro removes the limit. Set `consensus: true` (TicketLens Pro) to replace the local matcher with a multi-agent AI review — routes the same check through every AI provider configured in ~/.ticketlens/credentials.json (2+ required), calling each directly (never TicketLens\'s own servers). Requires 2+ of anthropic/openai/groq keys configured via `cloud-keys` or credentials.json; automatically skips the interactive cost-confirmation prompt since MCP has no TTY.',
     inputSchema: {
       type: 'object',
       properties: {
         ticket: { type: 'string', description: 'Ticket key, e.g. PROJ-123.' },
         profile: { type: 'string', description: 'Connection profile to target, overriding folder-based inference and the default profile.' },
+        consensus: { type: 'boolean', description: 'Use multi-agent AI consensus instead of the local deterministic matcher. Requires TicketLens Pro and 2+ configured AI provider keys.' },
       },
       required: ['ticket'],
     },