ticketlens 0.38.46 → 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,13 +460,13 @@ 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. `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.
 
 **Tags matter for search relevance.** `--tags=a,b` accepts anything, but a generic tag (the project name, "gotcha", "bug") gives future search almost nothing to match on. Tag with what the note is actually *about* — the specific technology, error type, or root cause (`retry-backoff`, `null-pointer`, `auth-middleware`) — so it surfaces when someone else hits the same problem.
 
-**Local file attachments.** `note add --attach=path1,path2` (or the `recall_add` MCP tool's `attachments` array) saves a screenshot or file alongside the note, in your local vault (`~/.ticketlens/recall/<PREFIX>/<note-id>/`) — same 10 MB/file, 50 MB/call, 20-file caps as ticket attachments for the local save. With Team Recall sync active, the attachment syncs too — visible and downloadable from Console > Admin > Recall — but the sync path caps at 12 MB/call (the backend's request-size limit, lower than the 50 MB local-save cap). Going over it fails the whole push, not just the attachment — the note stays saved locally, but neither its text nor the attachment reaches the team until it's pushed within the cap. Attachments with plain-text content (detected from the actual bytes, not the filename) go through the same secret scan as the note body before syncing; a rejected scan blocks the whole push the same way.
+**Local file attachments.** `note add --attach=path1,path2` (or the `recall_add` MCP tool's `attachments` array) saves a screenshot or file alongside the note, in your local vault (`~/.ticketlens/recall/<PREFIX>/<note-id>/`) — same 10 MB/file, 50 MB/call, 20-file caps as ticket attachments for the local save. `note patch --attach=path1,path2` (or `recall_update`'s `attachments` array) attaches more files to an existing note later — appended to what's already there, never replacing it; patch is local-vault only, so these are never pushed even if the note's original attachments were. With Team Recall sync active, the attachment syncs too — visible and downloadable from Console > Admin > Recall — but the sync path caps at 12 MB/call (the backend's request-size limit, lower than the 50 MB local-save cap). Going over it fails the whole push, not just the attachment — the note stays saved locally, but neither its text nor the attachment reaches the team until it's pushed within the cap. Attachments with plain-text content (detected from the actual bytes, not the filename) go through the same secret scan as the note body before syncing; a rejected scan blocks the whole push the same way.
 
 **Gaps** — every `ticketlens PROJ-123` brief also diffs the ticket's own description against its linked tickets (from the depth traversal you already requested) and its own downloaded attachments, looking for requirements mentioned there but missing here. Anything uncovered shows up under a `## Gaps` section, citing exactly where it came from — a linked ticket key or an attachment filename — as evidence, never an instruction to act on. Nothing is saved anywhere; it's recomputed fresh on every fetch. Requires a Pro license, same as Recall. No network call beyond what the brief already made.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.38.46",
+  "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.5 -->
+<!-- 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.
@@ -397,7 +397,9 @@ When it does apply, run up to 3 rounds:
    ```
    `--expect-mtime` is what keeps this safe: if the file changed since step 1 (the user hand-edited it while you were drafting), the patch silently no-ops and prints "not found or already changed" — the user's own edit always wins, never gets clobbered by a stale background draft.
 
-   If this harness has TicketLens's MCP server configured (a tool named `recall_update` — often shown as `mcp__ticketlens__recall_update` — visible in your tool list), prefer it over the bash form: same license gate, same structural/secret-scan checks, same optimistic-concurrency behavior via `expectMtime` — just no shell command or stdin piping to construct. It accepts `id`/`body`/`ticket`/`expectMtime`.
+   `note patch` also takes `--attach=path1,path2` (Pro), same caps and secret-scan treatment as `note add`'s — new files are appended to whatever the note already has, never replacing existing attachments.
+
+   If this harness has TicketLens's MCP server configured (a tool named `recall_update` — often shown as `mcp__ticketlens__recall_update` — visible in your tool list), prefer it over the bash form: same license gate, same structural/secret-scan checks, same optimistic-concurrency behavior via `expectMtime` — just no shell command or stdin piping to construct. It accepts `id`/`body`/`ticket`/`expectMtime`/`attachments`.
 5. Repeat from step 1 (re-capture mtime/body fresh each round) up to 3 total rounds. If no round ever produces a fully-passing draft, patch in whichever round scored highest across all attempts, and let the "not found or already changed" message stand if that patch itself loses a late race — don't retry past round 3.
 
 This never calls any external API or bills any tokens beyond the session you already have open — the generator and validator are subagents inside your own Claude Code session, not a TicketLens server call.
@@ -527,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/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;
 }
 
@@ -393,11 +396,14 @@ async function callRecallAdd(args, { configDir, runNoteAddFn }) {
  * as buildNoteAddArgs above. `expectMtime` is optimistic-concurrency: a
  * caller that fetched a note via recall_search and wants to refine it
  * without racing a concurrent edit passes back the mtime it observed.
+ * `attachments` (backlog #21) is appended to whatever the note already has,
+ * same as buildNoteAddArgs's — never a replace.
  */
-function buildNotePatchArgs({ id, ticket, expectMtime }) {
+function buildNotePatchArgs({ id, ticket, expectMtime, attachments }) {
   const args = [`--id=${id}`];
   if (ticket) args.push(`--ticket=${ticket}`);
   if (expectMtime !== undefined) args.push(`--expect-mtime=${expectMtime}`);
+  if (Array.isArray(attachments) && attachments.length > 0) args.push(`--attach=${attachments.join(',')}`);
   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'],
     },
@@ -180,6 +181,7 @@ export const TOOLS = [
         body: { type: 'string', description: 'The replacement note body — brief, not a paragraph. ~20 (strict), 30 (balanced), or 50 (loose) words max — scales with recallStrictness — going over doesn\'t block the update, but prints a non-blocking warning.' },
         ticket: { type: 'string', description: 'Ticket key the note is about, e.g. PROJ-123. Optional — narrows the search when omitted, the vault is searched across all ticket prefixes.' },
         expectMtime: { type: 'number', description: 'The note file\'s mtime (ms) last observed by the caller. If the note changed since then, the patch is a no-op rather than an overwrite — optimistic concurrency, not a hard requirement.' },
+        attachments: { type: 'array', items: { type: 'string' }, description: 'Local file paths to attach (screenshots, logs, etc.) — appended to whatever the note already has, never replacing existing attachments. Same 10MB/file, 50MB/call, 20-file caps as recall_add. Local vault only — recall_update never syncs to a team backend, so this never pushes.' },
       },
       required: ['id', 'body'],
     },

package/skills/jtb/scripts/lib/note-command.mjs

@@ -228,7 +228,9 @@ export async function runNoteAdd(cmdArgs, {
  * meant to be typed by hand): the loop's generator subagent produces a body,
  * SKILL.md's orchestration pipes it through this command, and the new body
  * gets exactly the same structural and secret gates a user-typed body gets —
- * there is no weaker path here for AI-authored content.
+ * there is no weaker path here for AI-authored content. `--attach` works the
+ * same as `note add`'s — files are appended to whatever the note already has,
+ * never replacing them.
  *
  * @param {string[]} cmdArgs
  * @returns {Promise<{ patched: boolean }>}
@@ -245,6 +247,7 @@ export async function runNotePatch(cmdArgs, {
   resolveEffectiveRecallStrictnessFn = resolveEffectiveRecallStrictness,
   scanForSecretsFn = scanForSecrets,
   patchNoteBodyFn = patchNoteBody,
+  readAttachmentsFn = readAttachments,
 } = {}) {
   if (!isLicensedFn('pro', configDir)) {
     showUpgradePrompt('pro', 'ticketlens note', { stream });
@@ -253,7 +256,7 @@ export async function runNotePatch(cmdArgs, {
 
   const id = parseFlag(cmdArgs, 'id');
   if (!id) {
-    stream.write('Usage: ticketlens note patch --id="..." [--ticket=KEY]\n');
+    stream.write('Usage: ticketlens note patch --id="..." [--ticket=KEY] [--attach=path1,path2]\n');
     return { patched: false };
   }
 
@@ -288,11 +291,18 @@ export async function runNotePatch(cmdArgs, {
     stream.write(`  Warning: ${warning}\n`);
   }
 
+  const attachPaths = parseAttachPaths(cmdArgs);
+  const { saved: attachments, warnings: attachWarnings } = attachPaths.length > 0
+    ? summarizeAttachments(readAttachmentsFn(attachPaths))
+    : { saved: [], warnings: [] };
+  for (const warning of attachWarnings) stream.write(warning);
+
   const ticketKeys = ticketKey ? [ticketKey] : [];
   const expectMtimeArg = parseFlag(cmdArgs, 'expect-mtime');
   const expectedMtimeMs = expectMtimeArg !== undefined ? Number(expectMtimeArg) : undefined;
-  const { patched } = patchNoteBodyFn({ id, ticketKeys, body, expectedMtimeMs }, { configDir });
-  stream.write(patched ? `  Updated note (${id})\n` : `  Note not updated — (${id}) not found or already changed.\n`);
+  const { patched } = patchNoteBodyFn({ id, ticketKeys, body, expectedMtimeMs, attachments }, { configDir });
+  const attachSuffix = patched && attachments.length > 0 ? ` + ${attachments.length} attachment(s)` : '';
+  stream.write(patched ? `  Updated note (${id})${attachSuffix}\n` : `  Note not updated — (${id}) not found or already changed.\n`);
   return { patched };
 }
 

package/skills/jtb/scripts/lib/recall-vault.mjs

@@ -90,7 +90,10 @@ function writeAttachments(noteDir, id, attachments) {
   if (attachments.length === 0) return [];
   const attachDir = attachmentsDirFor(noteDir, id);
   fs.mkdirSync(attachDir, { recursive: true });
-  const used = new Set();
+  // Seeded from what's already on disk, not just this call's batch — patchNoteBody
+  // can call this a second time against the same note id, and a same-named file
+  // from an earlier add/patch must count toward uniqueness too.
+  const used = new Set(fs.readdirSync(attachDir));
   const saved = [];
   for (const { filename, buffer } of attachments) {
     const uniqueName = uniquifyFilename(filename, used);
@@ -248,8 +251,10 @@ export function deleteNoteAnyPrefix(externalId, { configDir = DEFAULT_CONFIG_DIR
  * Overwrites an existing local note's body in place — used by the jtb skill's
  * generator/validator quality loop to swap in a better draft after `note add`
  * already saved the original. Patch-only: never creates a note, and every
- * frontmatter field except body is carried over unchanged, so this can never
- * become a covert way to retitle/retag/re-tie a note to a different ticket.
+ * frontmatter field except body and attachments is carried over unchanged, so
+ * this can never become a covert way to retitle/retag/re-tie a note to a
+ * different ticket. New attachments are appended to whatever the note already
+ * has — a patch refines a note, it never discards what's already attached.
  *
  * Guards, same failure-mode split as deleteNote: a malformed id or ticket key
  * is a caller bug (throw); a missing file, an externalId that doesn't match
@@ -257,17 +262,18 @@ export function deleteNoteAnyPrefix(externalId, { configDir = DEFAULT_CONFIG_DIR
  * (expectedMtimeMs) are all best-effort no-ops, not errors — the original
  * note is always left exactly as-is on any of these.
  *
- * @param {{ id: string, ticketKeys?: string[], body: string, expectedMtimeMs?: number }} params
+ * @param {{ id: string, ticketKeys?: string[], body: string, expectedMtimeMs?: number, attachments?: Array<{ filename: string, buffer: Buffer }> }} params
  * @param {{ configDir?: string }} [opts]
  * @returns {{ patched: boolean, path: string|null }}
  */
-export function patchNoteBody({ id, ticketKeys = [], body, expectedMtimeMs }, { configDir = DEFAULT_CONFIG_DIR } = {}) {
+export function patchNoteBody({ id, ticketKeys = [], body, expectedMtimeMs, attachments = [] }, { configDir = DEFAULT_CONFIG_DIR } = {}) {
   if (!EXTERNAL_ID_PATTERN.test(id)) {
     throw new Error(`Invalid note id: "${id}"`);
   }
 
   const prefix = resolvePrefix(ticketKeys[0]);
-  const notePath = path.join(prefixDir(configDir, prefix), id);
+  const dir = prefixDir(configDir, prefix);
+  const notePath = path.join(dir, id);
 
   if (!fs.existsSync(notePath)) {
     return { patched: false, path: null };
@@ -281,6 +287,13 @@ export function patchNoteBody({ id, ticketKeys = [], body, expectedMtimeMs }, {
     return { patched: false, path: notePath };
   }
 
+  // existing.attachments is the full list already on disk (from add and/or a
+  // prior patch) — carried forward here, or the drop bug returns: patch would
+  // silently strip the attachments: key, orphaning files that stay on disk but
+  // become permanently unlisted and unpushable.
+  const savedAttachments = writeAttachments(dir, id, attachments);
+  const mergedAttachments = [...existing.attachments, ...savedAttachments];
+
   const data = {
     title: existing.title,
     aliases: existing.aliases,
@@ -291,6 +304,7 @@ export function patchNoteBody({ id, ticketKeys = [], body, expectedMtimeMs }, {
     status: existing.status,
     sources: existing.sources,
     externalId: existing.externalId,
+    ...(mergedAttachments.length > 0 ? { attachments: mergedAttachments } : {}),
   };
 
   writeFileAtomically(notePath, serializeFrontmatter(data, body));