diffprism 0.49.0 → 1.0.0

package/dist/bin.js

@@ -2,28 +2,286 @@
 import {
   isPrRef,
   parsePrRef
-} from "./chunk-24B33UN6.js";
+} from "./chunk-EPU4F7WT.js";
 import {
   demo
-} from "./chunk-7UQM4WBZ.js";
+} from "./chunk-CJ6LV2XV.js";
 import {
+  COMMIT_GATE_DIFF_REF,
+  DEFAULT_DIFF_REF,
+  MCP_TOOL_NAMES,
+  REPORT_HINT,
+  RETIRED_MCP_TOOL_NAMES,
+  ReviewTimeoutError,
+  ReviewerAskedError,
+  buildFeedbackUrl,
+  currentVersion,
   describeVersion,
   ensureServer,
   getBuildInfo,
   isServerAlive,
+  mcpToolPermission,
+  readLastError,
   readServerFile,
+  recordError,
   startGlobalServer,
   submitReviewToServer
-} from "./chunk-EPUCA2N5.js";
+} from "./chunk-CU2BAL6Q.js";
 import {
   getDiff
-} from "./chunk-QGWYCEJN.js";
+} from "./chunk-3GMPE2ZR.js";
 import "./chunk-DHCVZGHE.js";
 import "./chunk-JSBRDJBE.js";
 
 // cli/src/index.ts
 import { Command } from "commander";
 
+// cli/src/commands/hook.ts
+import { execFileSync } from "child_process";
+import fs from "fs";
+import path from "path";
+var DEFAULT_MIN_LINES = 120;
+var RETRY_ADVICE = "The review stays open in DiffPrism \u2014 once the reviewer decides, run git commit again to pick up the decision. Don't open another review or change the staged files meanwhile.";
+var MARKER_START = "# >>> diffprism >>>";
+var MARKER_END = "# <<< diffprism <<<";
+var HOOK_LINE = "diffprism hook pre-commit || exit 1";
+async function preCommitHook(flags = {}) {
+  const cwd = process.cwd();
+  const minLines = resolveMinLines(flags, cwd);
+  let changedLines;
+  try {
+    const { diffSet } = getDiff(COMMIT_GATE_DIFF_REF, { cwd });
+    changedLines = diffSet.files.reduce(
+      (total, file) => total + file.additions + file.deletions,
+      0
+    );
+  } catch (err) {
+    recordError("hook pre-commit", err);
+    fail(`Could not read the staged diff: ${message(err)}
+${REPORT_HINT}`);
+    return;
+  }
+  if (changedLines === 0) {
+    process.exit(0);
+  }
+  if (changedLines < minLines) {
+    process.exit(0);
+  }
+  console.error(
+    `${changedLines} staged lines (gate at ${minLines}) \u2014 opening DiffPrism review...`
+  );
+  console.error(`Waiting for a decision in the browser. ${RETRY_ADVICE}`);
+  const stopWaiting = onInterrupt((signal) => {
+    console.error("");
+    console.error(`Interrupted (${signal}) before a decision. ${RETRY_ADVICE}`);
+    process.exit(1);
+  });
+  let review2 = null;
+  try {
+    const serverInfo = await ensureServer({ dev: flags.dev });
+    const { result } = await submitReviewToServer(serverInfo, COMMIT_GATE_DIFF_REF, {
+      cwd,
+      diffRef: COMMIT_GATE_DIFF_REF,
+      title: "Pre-commit review"
+    });
+    review2 = result;
+  } catch (err) {
+    stopWaiting();
+    if (err instanceof ReviewerAskedError) {
+      printQuestions(err.threads);
+      fail(
+        `Commit blocked: the reviewer asked you something before deciding. Answer each question with the DiffPrism reply tool (session_id: ${err.sessionId}, annotation_id as listed), then run git commit again \u2014 the review stays open and the decision still comes.`
+      );
+      return;
+    }
+    if (err instanceof ReviewTimeoutError) {
+      fail(`Commit blocked: no decision after ${Math.round(err.waitedMs / 1e3)}s. ${RETRY_ADVICE}`);
+      return;
+    }
+    recordError("hook pre-commit", err);
+    fail(`DiffPrism could not run the review: ${message(err)}
+${REPORT_HINT}`);
+    return;
+  }
+  stopWaiting();
+  const decision = review2?.decision;
+  if (decision === "approved" || decision === "approved_with_comments") {
+    const summary = review2?.summary?.trim();
+    const comments = review2?.comments ?? [];
+    if (summary || comments.length > 0) {
+      printFeedback(review2);
+    }
+    console.error(`Review: ${decision} \u2014 proceeding.`);
+    process.exit(0);
+  }
+  if (decision === "changes_requested") {
+    printFeedback(review2);
+    fail("Commit blocked: the review requested changes.");
+    return;
+  }
+  if (decision === "dismissed") {
+    fail("Commit blocked: the review was dismissed without a decision.");
+    return;
+  }
+  fail(
+    `Commit blocked: no review decision was returned (got ${String(decision)}).`
+  );
+}
+function printQuestions(threads) {
+  console.error("");
+  for (const t of threads) {
+    const last = t.replies?.at(-1)?.body ?? t.body;
+    console.error(`  ${t.file}:${t.line}  (annotation_id: ${t.id})`);
+    for (const line of last.split("\n")) {
+      console.error(`    ${line}`);
+    }
+  }
+  console.error("");
+}
+function printFeedback(review2) {
+  const summary = review2?.summary?.trim();
+  const comments = review2?.comments ?? [];
+  console.error("");
+  if (!summary && comments.length === 0) {
+    console.error("  The review left no summary and no inline comments.");
+    console.error("  Ask what needs changing \u2014 there is nothing here to act on.");
+    console.error("");
+    return;
+  }
+  if (summary) {
+    for (const line of summary.split("\n")) {
+      console.error(`  ${line}`);
+    }
+    if (comments.length > 0) {
+      console.error("");
+    }
+  }
+  for (const c of comments) {
+    console.error(`  ${c.file}:${c.line}  [${c.type}]  ${c.body}`);
+  }
+  console.error("");
+}
+function installHook() {
+  const hookPath = resolveHookPath(process.cwd());
+  const existing = fs.existsSync(hookPath) ? fs.readFileSync(hookPath, "utf8") : "";
+  if (existing.includes(MARKER_START)) {
+    console.log(`Already installed in ${hookPath}`);
+    return;
+  }
+  const block = `${MARKER_START}
+${HOOK_LINE}
+${MARKER_END}
+`;
+  const base = existing === "" ? "#!/bin/sh\n" : ensureTrailingNewline(existing);
+  const created = existing === "";
+  fs.mkdirSync(path.dirname(hookPath), { recursive: true });
+  fs.writeFileSync(hookPath, `${base}
+${block}`);
+  fs.chmodSync(hookPath, 493);
+  console.log(`${created ? "Created" : "Updated"} ${hookPath}`);
+  console.log(
+    `Staged changes of ${DEFAULT_MIN_LINES}+ lines now open a review before the commit lands.`
+  );
+  console.log("Tune with:  git config diffprism.gate-lines <n>");
+  console.log("Remove with: diffprism hook uninstall");
+}
+function uninstallHook() {
+  const hookPath = resolveHookPath(process.cwd());
+  if (!fs.existsSync(hookPath)) {
+    console.log("Nothing to remove \u2014 no hook file.");
+    return;
+  }
+  const existing = fs.readFileSync(hookPath, "utf8");
+  if (!existing.includes(MARKER_START)) {
+    console.log(`Nothing to remove \u2014 no diffprism block in ${hookPath}`);
+    return;
+  }
+  const cleaned = removeMarkedBlock(existing);
+  if (/^\s*(#![^\n]*)?\s*$/.test(cleaned)) {
+    fs.rmSync(hookPath);
+    console.log(`Removed ${hookPath} (it contained nothing else).`);
+    return;
+  }
+  fs.writeFileSync(hookPath, cleaned);
+  console.log(`Removed the diffprism block from ${hookPath}`);
+}
+function removeMarkedBlock(contents) {
+  const lines = contents.split("\n");
+  const out = [];
+  let inside = false;
+  for (const line of lines) {
+    if (line.trim() === MARKER_START) {
+      inside = true;
+      continue;
+    }
+    if (line.trim() === MARKER_END) {
+      inside = false;
+      continue;
+    }
+    if (!inside) {
+      out.push(line);
+    }
+  }
+  return ensureTrailingNewline(out.join("\n").replace(/\n{3,}/g, "\n\n"));
+}
+function onInterrupt(handler) {
+  const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+  for (const signal of signals) {
+    process.once(signal, handler);
+  }
+  return () => {
+    for (const signal of signals) {
+      process.removeListener(signal, handler);
+    }
+  };
+}
+function resolveMinLines(flags, cwd) {
+  const fromFlag = flags.minLines ? Number.parseInt(flags.minLines, 10) : NaN;
+  if (Number.isFinite(fromFlag) && fromFlag > 0) {
+    return fromFlag;
+  }
+  const configured = Number.parseInt(
+    git(["config", "--get", "diffprism.gate-lines"], cwd) ?? "",
+    10
+  );
+  if (Number.isFinite(configured) && configured > 0) {
+    return configured;
+  }
+  return DEFAULT_MIN_LINES;
+}
+function resolveHookPath(cwd) {
+  const configured = git(["config", "--get", "core.hooksPath"], cwd);
+  if (configured) {
+    return path.resolve(cwd, configured, "pre-commit");
+  }
+  const hooksDir = git(["rev-parse", "--git-path", "hooks"], cwd) ?? ".git/hooks";
+  return path.resolve(cwd, hooksDir, "pre-commit");
+}
+function git(args, cwd) {
+  try {
+    const out = execFileSync("git", args, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const trimmed = out.trim();
+    return trimmed === "" ? null : trimmed;
+  } catch {
+    return null;
+  }
+}
+function ensureTrailingNewline(text) {
+  return text.endsWith("\n") ? text : `${text}
+`;
+}
+function message(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function fail(text) {
+  console.error(text);
+  process.exit(1);
+}
+
 // cli/src/commands/review.ts
 async function review(ref, flags) {
   let diffRef;
@@ -34,7 +292,7 @@ async function review(ref, flags) {
   } else if (ref) {
     diffRef = ref;
   } else {
-    diffRef = "working-copy";
+    diffRef = DEFAULT_DIFF_REF;
   }
   try {
     if (isPrRef(diffRef)) {
@@ -44,18 +302,32 @@ async function review(ref, flags) {
     }
   } catch (err) {
     const message2 = err instanceof Error ? err.message : String(err);
+    recordError("review", err);
     console.error(`Error: ${message2}`);
+    console.error(REPORT_HINT);
     process.exit(1);
   }
 }
 async function reviewLocalFlow(diffRef, flags) {
   const serverInfo = await ensureServer({ dev: flags.dev });
   console.error("Opening review in browser...");
-  const { result } = await submitReviewToServer(serverInfo, diffRef, {
-    title: flags.title,
-    cwd: process.cwd(),
-    diffRef
-  });
+  let result;
+  try {
+    ({ result } = await submitReviewToServer(serverInfo, diffRef, {
+      title: flags.title,
+      cwd: process.cwd(),
+      diffRef
+    }));
+  } catch (err) {
+    if (err instanceof ReviewerAskedError) {
+      printQuestions(err.threads);
+      console.error(
+        `The reviewer asked something before deciding. Answer each question with the DiffPrism reply tool (session_id: ${err.sessionId}, annotation_id as listed), then run diffprism review again \u2014 the review stays open.`
+      );
+      process.exit(1);
+    }
+    throw err;
+  }
   console.log(JSON.stringify(result, null, 2));
   if (!result) {
     console.error("No review result was returned.");
@@ -100,8 +372,8 @@ async function serve() {
 }
 
 // cli/src/commands/setup.ts
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 import os from "os";
 import readline from "readline";
 
@@ -113,102 +385,127 @@ description: Open current code changes in DiffPrism's browser-based review UI fo
 
 # DiffPrism Review
 
-You have 14 DiffPrism MCP tools available. Use them proactively \u2014 don't wait for the user to ask.
+You have 14 DiffPrism MCP tools. Use the analysis tools proactively; open a human review only when asked.
+
+## How reviews work
+
+- **One review per repo.** Opening a review for a repo that already has one updates it \u2014 new diff, same session, existing annotations kept. A git worktree is its own repo.
+- **\`open_review\` waits for the decision.** It blocks until the reviewer approves, requests changes, or dismisses, and returns their \`ReviewResult\`. Pass \`wait: false\` to get the session id back immediately instead.
+- **Scope defaults to the working copy everywhere.** \`open_review\`, \`get_diff\` and \`analyze_diff\` all review \`"working-copy"\` unless you pass \`diff_ref\` \u2014 the same default as \`diffprism review\` and the dashboard, so your self-review and the human review look at the same changes.
+- **A decision stands while its diff is unchanged.** If your wait is cut short, open the same review again or re-run the same commit and you get the decision the reviewer already gave \u2014 not a second review request. Change the diff and it becomes a new question.
+- **Tools act on the review for your repo.** Every tool that works on an open review takes \`session_id\` or \`repo_path\`, and otherwise uses the repo you are running in. If that is ambiguous the tool says so and lists the sessions \u2014 pass \`session_id\`. It never guesses.
 
 ## Workflow 1: Self-Review Before Human Review
 
 After making multi-file changes, **proactively self-review before requesting human review**:
 
-1. Run \`mcp__diffprism__analyze_diff\` with \`diff_ref: "working-copy"\`
+1. Run \`mcp__diffprism__analyze_diff\` (it covers the working copy by default)
 2. Check the response for:
    - **Pattern flags** \u2014 console.logs left in, TODO comments, security issues (hardcoded secrets, SQL injection, XSS)
    - **Test coverage gaps** \u2014 new code paths without corresponding tests
    - **High complexity scores** \u2014 functions or files with elevated complexity
 3. **Fix any issues found** \u2014 remove debug logs, add missing tests, simplify complex code
-4. Only then open a human review with \`mcp__diffprism__open_review\`
+4. Only then open a human review
 
 This should happen automatically after significant changes. You don't need the user to ask.
 
 ## Workflow 2: Annotated Human Review
 
-When opening a review, help the reviewer by flagging what matters:
-
 1. Call \`mcp__diffprism__open_review\` with:
-   - \`diff_ref\`: \`"working-copy"\` (or what the user specified, e.g. \`"staged"\`, \`"HEAD~3..HEAD"\`)
+   - \`diff_ref\`: omit it for the working copy, or pass what the user asked for \u2014 see *Choosing a scope*
    - \`title\`: Brief summary of the changes
-   - \`reasoning\`: Your reasoning about implementation decisions
-   - \`annotations\`: Array of inline findings to pre-populate the review (see tool schema)
-2. Use annotations to flag:
+   - \`reasoning\`: What you were trying to accomplish \u2014 this is how the reviewer tells sessions apart
+   - \`annotations\`: Findings to show when the review opens
+2. Annotate what matters:
    - Areas of uncertainty ("I chose approach X over Y because...")
    - Security-sensitive changes
    - Performance implications
-   - Anything the reviewer should look at closely
-3. After opening, use \`mcp__diffprism__flag_for_attention\` to highlight files that need careful review (e.g. auth logic, data migrations, public API changes)
-4. Use \`mcp__diffprism__add_annotation\` to post additional findings about specific lines if you discover issues while the review is open
+   - Use \`type: "warning"\` for anything the reviewer must look at \u2014 warnings flag the session in the sidebar
+3. \`open_review\` returns the decision when the reviewer submits:
+   - **\`approved\`** / **\`approved_with_comments\`** \u2014 proceed. Read any comments or summary.
+   - **\`changes_requested\`** \u2014 read the \`summary\` and \`comments\`, make the fixes, and offer to re-review.
+   - **\`dismissed\`** \u2014 the reviewer closed it without deciding. Ask before continuing.
+   - If \`postReviewAction\` is \`"commit"\` \u2014 commit the changes. If \`"commit_and_pr"\` \u2014 commit and open a PR.
+4. If it returns \`status: "timed_out"\`, the reviewer is still reading. Keep waiting with \`mcp__diffprism__get_review_result\` (\`wait: true\`).
+5. If it returns \`status: "reviewer_asked"\`, the reviewer asked you something before deciding. Answer each thread with \`mcp__diffprism__reply\` (its \`id\` is the \`annotation_id\`) \u2014 and change the code if that's what they asked for. Then wait again with \`mcp__diffprism__get_review_result\` (\`wait: true\`), which can return \`reviewer_asked\` again.
 
-Handle the review result:
-- **\`approved\`** \u2014 Proceed with the task.
-- **\`changes_requested\`** \u2014 Read comments, make fixes, offer to re-review.
-- If \`postReviewAction\` is \`"commit"\` \u2014 commit the changes.
-- If \`postReviewAction\` is \`"commit_and_pr"\` \u2014 commit and open a PR.
+**While a review is open, wait for it.** Don't ask the user whether they've finished, and don't move on to other work \u2014 their decision is the answer, and it arrives through the tool. Asking in the terminal splits the conversation in two and the decision gets lost between them.
 
-## Workflow 3: PR Super Review
+To add findings while a review is open, call \`mcp__diffprism__annotate\`.
 
-When the user opens a GitHub PR for review (via \`diffprism review <PR URL>\` or the DiffPrism UI), you become their AI-powered code reviewer. The diff is visible in the browser; you provide the intelligence.
+## Choosing a scope
 
-### Getting oriented
-1. Call \`mcp__diffprism__get_pr_context\` to understand the PR: title, author, branches, file list, briefing summary, and whether a local repo is connected.
+| \`diff_ref\` | Shows | Use when |
+|---|---|---|
+| \`"working-copy"\` *(default)* | Everything uncommitted; staged and unstaged as separate groups | Almost always \u2014 "review my changes" |
+| \`"staged"\` | Only what the next commit contains | Reviewing exactly what is about to be committed |
+| \`"unstaged"\` | Only edits not yet staged | Rarely \u2014 reviewing work in progress beside a staged commit |
+| \`"HEAD~3..HEAD"\`, \`"main..feature"\` | A range of commits | Reviewing work that is already committed |
 
-### Investigating changes
-2. Call \`mcp__diffprism__get_file_diff\` for specific files to see their hunks and triage category (critical/notable/mechanical).
-3. Call \`mcp__diffprism__get_file_context\` to read full files from the local repo \u2014 this gives you surrounding code, not just diff hunks. Use this to understand how changed code fits into the broader file.
-4. Call \`mcp__diffprism__get_user_focus\` to see what file/line the user is currently viewing in the browser. Proactively offer context about what they're looking at.
+## Commit gate
 
-### Leaving findings
-5. Call \`mcp__diffprism__add_review_comment\` to post findings directly to the browser UI. Comments appear as inline annotations on the diff in real-time. Use this to flag issues, suggest improvements, or answer the user's questions visually.
-6. Call \`mcp__diffprism__get_review_comments\` to see what's already been noted before adding your own.
+If the repo has the DiffPrism pre-commit gate installed (\`diffprism hook install\`), a \`git commit\` of a large enough change opens a review and **waits for a human**. It reviews **staged** changes only \u2014 unlike every other entry point \u2014 because a commit contains exactly the index; unstaged edits aren't part of what is being approved.
 
-### Key principle
-The user sees the diff in the browser. You see it through MCP tools. Work together \u2014 they spot visual patterns, you analyze logic and context.
+- Run \`git commit\` with a shell timeout long enough for someone to read the change \u2014 up to 600000 ms \u2014 not the short default.
+- If the commit is interrupted, or reports no decision, the review is still open. Once the reviewer decides, run the **same** \`git commit\` again: their decision is picked up immediately. Don't change the staged files first \u2014 that makes it a new question.
+- If it's blocked with changes requested, the reviewer's summary and comments are printed. Address them, stage, and commit again.
+- If it's blocked because the reviewer asked something, their questions are printed with an \`annotation_id\` each. Answer each with \`mcp__diffprism__reply\`, then run the same \`git commit\` again \u2014 the review is still open.
 
-## Tool Reference
+## Workflow 3: PR Review
 
-### Review Lifecycle
-| Tool | Purpose |
-|------|---------|
-| \`open_review\` | Open browser review UI for local changes or a GitHub PR. |
-| \`get_review_result\` | Fetch result from a previous review. |
-| \`update_review_context\` | Push updated reasoning/description to a running review session. |
+Pull requests are opened by the user \u2014 \`diffprism review <PR URL>\` or "Review PR" in the dashboard \u2014 not by \`open_review\`. You then work inside that review:
+
+1. \`mcp__diffprism__get_pr_context\` \u2014 title, author, branches, file list, briefing summary, and whether a local clone is connected.
+2. \`mcp__diffprism__get_file_diff\` \u2014 one file's hunks and triage category (critical/notable/mechanical).
+3. \`mcp__diffprism__get_file_context\` \u2014 the full file from the local clone, so you see surrounding code rather than just the hunks.
+4. \`mcp__diffprism__get_user_focus\` \u2014 what the user is looking at right now. Offer context about it.
+5. \`mcp__diffprism__get_review_comments\` \u2014 what has already been said, before you add to it.
+6. \`mcp__diffprism__annotate\` \u2014 post findings inline on the diff.
+
+The reviewer can also ask you questions on lines of the PR. Hold that conversation in the dashboard, not the terminal:
+
+1. \`mcp__diffprism__wait_for_comments\` \u2014 blocks until the reviewer writes something you haven't answered, then returns those threads.
+2. \`mcp__diffprism__reply\` \u2014 answer each thread, passing its \`annotation_id\`.
+3. Wait again. On \`timed_out\`, nothing new was said \u2014 keep waiting until the user tells you to stop.
+
+A PR review and a working-copy review can be open for the same clone at once. If a tool reports more than one session, pass the \`session_id\` of the one you mean.
 
-### Headless Analysis
+## Tool Reference
+
+### Opening and deciding
 | Tool | Purpose |
 |------|---------|
-| \`analyze_diff\` | Returns analysis JSON (patterns, complexity, test gaps) without opening a browser. |
-| \`get_diff\` | Returns structured diff JSON (file-level and hunk-level changes). |
+| \`open_review\` | Open a review of local changes and wait for the decision. |
+| \`get_review_result\` | Check the decision on a review already open (after \`wait: false\` or a timeout). |
+| \`update_review_context\` | Update reasoning, title, or description on an open review. |
 
-### PR Super Review
+### Headless analysis
 | Tool | Purpose |
 |------|---------|
-| \`get_pr_context\` | High-level PR overview: metadata, briefing, file list, local repo status. |
-| \`get_file_diff\` | Diff hunks for a specific file with triage category. |
-| \`get_file_context\` | Full file content from local repo via \`git show\`. |
-| \`get_user_focus\` | What file/line the user is currently viewing in the browser UI. |
+| \`analyze_diff\` | Analysis JSON (patterns, complexity, test gaps) without opening a browser. |
+| \`get_diff\` | Structured diff JSON (file-level and hunk-level changes). |
 
-### Annotation & Commenting
+### Working in an open review
 | Tool | Purpose |
 |------|---------|
-| \`add_review_comment\` | Post a comment that appears inline in the browser diff. |
-| \`get_review_comments\` | Read all comments and annotations on the session. |
-| \`add_annotation\` | Post a structured finding (finding/suggestion/question/warning). |
-| \`flag_for_attention\` | Mark files for human attention with warning annotations. |
-| \`get_review_state\` | Get current state of a review session including all annotations. |
+| \`annotate\` | Post one or more findings. \`warning\` flags the session for attention. |
+| \`get_review_comments\` | Every thread on the review; \`awaiting_reply\` narrows to threads waiting for an answer. |
+| \`reply\` | Reply to a thread \u2014 answer the reviewer's question or follow up on a finding. |
+| \`wait_for_comments\` | Block until the reviewer writes something you haven't answered. |
+| \`get_review_state\` | Session status, attention and new-changes flags, and annotations. |
+| \`get_user_focus\` | What the user is currently looking at. |
+| \`get_pr_context\` | PR overview: metadata, briefing, file list, local clone status. |
+| \`get_file_diff\` | Hunks for one file, with triage category. |
+| \`get_file_context\` | Full file content from the local clone. |
 
 ## Rules
 
 - **Self-review is proactive** \u2014 run \`analyze_diff\` after significant changes without being asked.
-- **Human review requires explicit request** \u2014 only open \`open_review\` when the user asks (\`/review\`, "review my changes", or as part of a defined workflow like PR creation).
-- **Annotate generously** \u2014 the more context you provide in annotations, the faster the reviewer can make decisions.
-- **PR review is conversational** \u2014 when a PR is open, use the super review tools to answer questions and post findings without being asked to use specific tools.
+- **Human review requires explicit request** \u2014 only call \`open_review\` when the user asks (\`/review\`, "review my changes", or as part of a defined workflow like PR creation).
+- **Don't open a second review to check on the first** \u2014 use \`get_review_result\`.
+- **Don't ask the user about a review that's open** \u2014 wait for the decision; it is their answer.
+- **Annotate generously** \u2014 the more context you provide, the faster the reviewer can decide.
+- **PR review is conversational** \u2014 when a PR is open, use the PR tools to answer questions and post findings without being asked to use specific tools.
 `;
 
 // cli/src/commands/setup.ts
@@ -219,33 +516,33 @@ var GITIGNORE_ENTRIES = [
   ".claude/skills/review/"
 ];
 function findGitRoot(from) {
-  let dir = path.resolve(from);
+  let dir = path2.resolve(from);
   while (true) {
-    if (fs.existsSync(path.join(dir, ".git"))) {
+    if (fs2.existsSync(path2.join(dir, ".git"))) {
       return dir;
     }
-    const parent = path.dirname(dir);
+    const parent = path2.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 function readJsonFile(filePath) {
   try {
-    const raw = fs.readFileSync(filePath, "utf-8");
+    const raw = fs2.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
   }
 }
 function writeJsonFile(filePath, data) {
-  const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
+  const dir = path2.dirname(filePath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
   }
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  fs2.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 }
 function setupMcpJson(gitRoot, force) {
-  const filePath = path.join(gitRoot, ".mcp.json");
+  const filePath = path2.join(gitRoot, ".mcp.json");
   const existing = readJsonFile(filePath);
   const servers = existing.mcpServers ?? {};
   if (servers.diffprism && !force) {
@@ -255,54 +552,47 @@ function setupMcpJson(gitRoot, force) {
     command: "npx",
     args: ["diffprism@latest", "serve"]
   };
-  const action = fs.existsSync(filePath) ? "updated" : "created";
+  const action = fs2.existsSync(filePath) ? "updated" : "created";
   writeJsonFile(filePath, { ...existing, mcpServers: servers });
   return { action, filePath };
 }
 function setupClaudeSettings(baseDir, force) {
-  const filePath = path.join(baseDir, ".claude", "settings.json");
+  const filePath = path2.join(baseDir, ".claude", "settings.json");
   const existing = readJsonFile(filePath);
   const permissions = existing.permissions ?? {};
   const allow = permissions.allow ?? [];
-  const toolNames = [
-    "mcp__diffprism__open_review",
-    "mcp__diffprism__update_review_context",
-    "mcp__diffprism__get_review_result",
-    "mcp__diffprism__get_diff",
-    "mcp__diffprism__analyze_diff",
-    "mcp__diffprism__add_annotation",
-    "mcp__diffprism__get_review_state",
-    "mcp__diffprism__flag_for_attention",
-    "mcp__diffprism__review_pr"
-  ];
+  const toolNames = MCP_TOOL_NAMES.map(mcpToolPermission);
+  const retired = new Set(RETIRED_MCP_TOOL_NAMES.map(mcpToolPermission));
   const allPresent = toolNames.every((t) => allow.includes(t));
-  if (allPresent && !force) {
+  const hasRetired = allow.some((t) => retired.has(t));
+  if (allPresent && !hasRetired && !force) {
     return { action: "skipped", filePath };
   }
+  const next = allow.filter((t) => !retired.has(t));
   for (const toolName of toolNames) {
-    if (!allow.includes(toolName)) {
-      allow.push(toolName);
+    if (!next.includes(toolName)) {
+      next.push(toolName);
     }
   }
-  permissions.allow = allow;
-  const action = fs.existsSync(filePath) ? "updated" : "created";
+  permissions.allow = next;
+  const action = fs2.existsSync(filePath) ? "updated" : "created";
   writeJsonFile(filePath, { ...existing, permissions });
   return { action, filePath };
 }
 function setupSkill(gitRoot, global, force) {
-  const skillDir = global ? path.join(os.homedir(), ".claude", "skills", "review") : path.join(gitRoot, ".claude", "skills", "review");
-  const filePath = path.join(skillDir, "SKILL.md");
-  if (fs.existsSync(filePath)) {
-    const existingContent = fs.readFileSync(filePath, "utf-8");
+  const skillDir = global ? path2.join(os.homedir(), ".claude", "skills", "review") : path2.join(gitRoot, ".claude", "skills", "review");
+  const filePath = path2.join(skillDir, "SKILL.md");
+  if (fs2.existsSync(filePath)) {
+    const existingContent = fs2.readFileSync(filePath, "utf-8");
     if (existingContent === skillContent) {
       return { action: "skipped", filePath };
     }
   }
-  if (!fs.existsSync(skillDir)) {
-    fs.mkdirSync(skillDir, { recursive: true });
+  if (!fs2.existsSync(skillDir)) {
+    fs2.mkdirSync(skillDir, { recursive: true });
   }
-  const action = fs.existsSync(filePath) ? "updated" : "created";
-  fs.writeFileSync(filePath, skillContent);
+  const action = fs2.existsSync(filePath) ? "updated" : "created";
+  fs2.writeFileSync(filePath, skillContent);
   return { action, filePath };
 }
 async function promptUser(question) {
@@ -318,9 +608,9 @@ async function promptUser(question) {
   });
 }
 async function setupGitignore(gitRoot) {
-  const filePath = path.join(gitRoot, ".gitignore");
-  if (fs.existsSync(filePath)) {
-    const content = fs.readFileSync(filePath, "utf-8");
+  const filePath = path2.join(gitRoot, ".gitignore");
+  if (fs2.existsSync(filePath)) {
+    const content = fs2.readFileSync(filePath, "utf-8");
     const lines = content.split("\n").map((l) => l.trim());
     const missing = GITIGNORE_ENTRIES.filter((e) => !lines.includes(e));
     if (missing.length === 0) {
@@ -328,7 +618,7 @@ async function setupGitignore(gitRoot) {
     }
     const suffix = missing.map((e) => e + "\n").join("");
     const newContent = content.endsWith("\n") ? content + suffix : content + "\n" + suffix;
-    fs.writeFileSync(filePath, newContent);
+    fs2.writeFileSync(filePath, newContent);
     return { action: "updated", filePath };
   }
   const confirmed = await promptUser(
@@ -340,7 +630,7 @@ async function setupGitignore(gitRoot) {
     );
     return { action: "skipped", filePath };
   }
-  fs.writeFileSync(filePath, GITIGNORE_ENTRIES.map((e) => e + "\n").join(""));
+  fs2.writeFileSync(filePath, GITIGNORE_ENTRIES.map((e) => e + "\n").join(""));
   return { action: "created", filePath };
 }
 async function setup(flags) {
@@ -379,7 +669,7 @@ async function setupInteractive(flags) {
 }
 async function runDemo(dev) {
   console.log("");
-  const { demo: demo2 } = await import("./demo-VPKUCZT3.js");
+  const { demo: demo2 } = await import("./demo-X5LWQDVU.js");
   await demo2({ dev });
 }
 async function setupBatch(flags) {
@@ -438,27 +728,27 @@ function printSummary(result, baseDir) {
   if (result.created.length > 0) {
     console.log("Created:");
     for (const f of result.created) {
-      console.log(`  + ${path.relative(baseDir, f) || f}`);
+      console.log(`  + ${path2.relative(baseDir, f) || f}`);
     }
   }
   if (result.updated.length > 0) {
     console.log("Updated:");
     for (const f of result.updated) {
-      console.log(`  ~ ${path.relative(baseDir, f) || f}`);
+      console.log(`  ~ ${path2.relative(baseDir, f) || f}`);
     }
   }
   if (result.skipped.length > 0) {
     console.log("Skipped (already configured):");
     for (const f of result.skipped) {
-      console.log(`  - ${path.relative(baseDir, f) || f}`);
+      console.log(`  - ${path2.relative(baseDir, f) || f}`);
     }
   }
 }
 function isGlobalSetupDone() {
   const home = os.homedir();
-  const skillPath = path.join(home, ".claude", "skills", "review", "SKILL.md");
-  const settingsPath = path.join(home, ".claude", "settings.json");
-  if (!fs.existsSync(skillPath)) return false;
+  const skillPath = path2.join(home, ".claude", "skills", "review", "SKILL.md");
+  const settingsPath = path2.join(home, ".claude", "settings.json");
+  if (!fs2.existsSync(skillPath)) return false;
   const settings = readJsonFile(settingsPath);
   const permissions = settings.permissions ?? {};
   const allow = permissions.allow ?? [];
@@ -477,12 +767,12 @@ function isGlobalSetupDone() {
 }
 
 // cli/src/commands/teardown.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import os2 from "os";
 function teardownMcpJson(gitRoot) {
-  const filePath = path2.join(gitRoot, ".mcp.json");
-  if (!fs2.existsSync(filePath)) {
+  const filePath = path3.join(gitRoot, ".mcp.json");
+  if (!fs3.existsSync(filePath)) {
     return { action: "skipped", filePath };
   }
   const existing = readJsonFile(filePath);
@@ -494,7 +784,7 @@ function teardownMcpJson(gitRoot) {
   if (Object.keys(servers).length === 0) {
     const { mcpServers: _, ...rest } = existing;
     if (Object.keys(rest).length === 0) {
-      fs2.unlinkSync(filePath);
+      fs3.unlinkSync(filePath);
     } else {
       writeJsonFile(filePath, rest);
     }
@@ -504,23 +794,14 @@ function teardownMcpJson(gitRoot) {
   return { action: "removed", filePath };
 }
 function teardownClaudePermissions(baseDir) {
-  const filePath = path2.join(baseDir, ".claude", "settings.json");
-  if (!fs2.existsSync(filePath)) {
+  const filePath = path3.join(baseDir, ".claude", "settings.json");
+  if (!fs3.existsSync(filePath)) {
     return { action: "skipped", filePath };
   }
   const existing = readJsonFile(filePath);
   const permissions = existing.permissions ?? {};
   const allow = permissions.allow ?? [];
-  const toolNames = [
-    "mcp__diffprism__open_review",
-    "mcp__diffprism__update_review_context",
-    "mcp__diffprism__get_review_result",
-    "mcp__diffprism__get_diff",
-    "mcp__diffprism__analyze_diff",
-    "mcp__diffprism__add_annotation",
-    "mcp__diffprism__get_review_state",
-    "mcp__diffprism__flag_for_attention"
-  ];
+  const toolNames = [...MCP_TOOL_NAMES, ...RETIRED_MCP_TOOL_NAMES].map(mcpToolPermission);
   const filtered = allow.filter((t) => !toolNames.includes(t));
   if (filtered.length === allow.length) {
     return { action: "skipped", filePath };
@@ -539,40 +820,40 @@ function teardownClaudePermissions(baseDir) {
   return { action: "removed", filePath };
 }
 function cleanupSettingsFile(baseDir) {
-  const filePath = path2.join(baseDir, ".claude", "settings.json");
-  if (!fs2.existsSync(filePath)) return;
+  const filePath = path3.join(baseDir, ".claude", "settings.json");
+  if (!fs3.existsSync(filePath)) return;
   const existing = readJsonFile(filePath);
   if (Object.keys(existing).length === 0) {
-    fs2.unlinkSync(filePath);
-    tryRmdir(path2.join(baseDir, ".claude"));
+    fs3.unlinkSync(filePath);
+    tryRmdir(path3.join(baseDir, ".claude"));
   }
 }
 function tryRmdir(dirPath) {
   try {
-    const entries = fs2.readdirSync(dirPath);
+    const entries = fs3.readdirSync(dirPath);
     if (entries.length === 0) {
-      fs2.rmdirSync(dirPath);
+      fs3.rmdirSync(dirPath);
     }
   } catch {
   }
 }
 function teardownSkill(baseDir, global) {
-  const skillDir = global ? path2.join(os2.homedir(), ".claude", "skills", "review") : path2.join(baseDir, ".claude", "skills", "review");
-  const filePath = path2.join(skillDir, "SKILL.md");
-  if (!fs2.existsSync(filePath)) {
+  const skillDir = global ? path3.join(os2.homedir(), ".claude", "skills", "review") : path3.join(baseDir, ".claude", "skills", "review");
+  const filePath = path3.join(skillDir, "SKILL.md");
+  if (!fs3.existsSync(filePath)) {
     return { action: "skipped", filePath };
   }
-  fs2.unlinkSync(filePath);
+  fs3.unlinkSync(filePath);
   tryRmdir(skillDir);
-  tryRmdir(path2.dirname(skillDir));
+  tryRmdir(path3.dirname(skillDir));
   return { action: "removed", filePath };
 }
 function teardownGitignore(gitRoot) {
-  const filePath = path2.join(gitRoot, ".gitignore");
-  if (!fs2.existsSync(filePath)) {
+  const filePath = path3.join(gitRoot, ".gitignore");
+  if (!fs3.existsSync(filePath)) {
     return { action: "skipped", filePath };
   }
-  const content = fs2.readFileSync(filePath, "utf-8");
+  const content = fs3.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const entrySet = new Set(GITIGNORE_ENTRIES);
   const filtered = lines.filter((l) => !entrySet.has(l.trim()));
@@ -581,18 +862,18 @@ function teardownGitignore(gitRoot) {
   }
   const newContent = filtered.join("\n");
   if (newContent.trim() === "") {
-    fs2.unlinkSync(filePath);
+    fs3.unlinkSync(filePath);
   } else {
-    fs2.writeFileSync(filePath, newContent);
+    fs3.writeFileSync(filePath, newContent);
   }
   return { action: "removed", filePath };
 }
 function teardownDiffprismDir(gitRoot) {
-  const dirPath = path2.join(gitRoot, ".diffprism");
-  if (!fs2.existsSync(dirPath)) {
+  const dirPath = path3.join(gitRoot, ".diffprism");
+  if (!fs3.existsSync(dirPath)) {
     return { action: "skipped", filePath: dirPath };
   }
-  fs2.rmSync(dirPath, { recursive: true });
+  fs3.rmSync(dirPath, { recursive: true });
   return { action: "removed", filePath: dirPath };
 }
 async function teardown(flags) {
@@ -650,21 +931,21 @@ function printTeardownSummary(result, baseDir) {
   if (result.removed.length > 0) {
     console.log("Removed:");
     for (const f of result.removed) {
-      console.log(`  - ${path2.relative(baseDir, f) || f}`);
+      console.log(`  - ${path3.relative(baseDir, f) || f}`);
     }
   }
   if (result.skipped.length > 0) {
     console.log("Skipped (not found):");
     for (const f of result.skipped) {
-      console.log(`  . ${path2.relative(baseDir, f) || f}`);
+      console.log(`  . ${path3.relative(baseDir, f) || f}`);
     }
   }
 }
 
 // cli/src/commands/server.ts
 import { spawn } from "child_process";
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import os3 from "os";
 async function server(flags) {
   if (flags.background) {
@@ -727,19 +1008,19 @@ async function spawnDaemon(flags) {
   }
   const args = process.argv.slice(1).filter((a) => a !== "--background");
   args.push("--_daemon");
-  const logDir = path3.join(os3.homedir(), ".diffprism");
-  if (!fs3.existsSync(logDir)) {
-    fs3.mkdirSync(logDir, { recursive: true });
+  const logDir = path4.join(os3.homedir(), ".diffprism");
+  if (!fs4.existsSync(logDir)) {
+    fs4.mkdirSync(logDir, { recursive: true });
   }
-  const logPath = path3.join(logDir, "server.log");
-  const logFd = fs3.openSync(logPath, "a");
+  const logPath = path4.join(logDir, "server.log");
+  const logFd = fs4.openSync(logPath, "a");
   const child = spawn(process.execPath, args, {
     detached: true,
     stdio: ["ignore", logFd, logFd],
     env: { ...process.env }
   });
   child.unref();
-  fs3.closeSync(logFd);
+  fs4.closeSync(logFd);
   console.log("Starting DiffPrism server in background...");
   const startTime = Date.now();
   const timeoutMs = 15e3;
@@ -826,7 +1107,7 @@ async function fetchStatus(httpPort) {
   return await response.json();
 }
 function printStatus(status, httpPort) {
-  const version = true ? "0.49.0" : "0.0.0-dev";
+  const version = currentVersion();
   console.log(`
 DiffPrism v${version}
 `);
@@ -864,213 +1145,30 @@ async function defaultAction() {
   }
 }
 
-// cli/src/commands/hook.ts
-import { execFileSync } from "child_process";
-import fs4 from "fs";
-import path4 from "path";
-var DEFAULT_MIN_LINES = 120;
-var MARKER_START = "# >>> diffprism >>>";
-var MARKER_END = "# <<< diffprism <<<";
-var HOOK_LINE = "diffprism hook pre-commit || exit 1";
-async function preCommitHook(flags = {}) {
-  const cwd = process.cwd();
-  const minLines = resolveMinLines(flags, cwd);
-  let changedLines;
-  try {
-    const { diffSet } = getDiff("staged", { cwd });
-    changedLines = diffSet.files.reduce(
-      (total, file) => total + file.additions + file.deletions,
-      0
-    );
-  } catch (err) {
-    fail(`Could not read the staged diff: ${message(err)}`);
-    return;
-  }
-  if (changedLines === 0) {
-    process.exit(0);
-  }
-  if (changedLines < minLines) {
-    process.exit(0);
-  }
-  console.error(
-    `${changedLines} staged lines (gate at ${minLines}) \u2014 opening DiffPrism review...`
-  );
-  let review2 = null;
-  try {
-    const serverInfo = await ensureServer({ dev: flags.dev });
-    const { result } = await submitReviewToServer(serverInfo, "staged", {
-      cwd,
-      diffRef: "staged",
-      title: "Pre-commit review"
-    });
-    review2 = result;
-  } catch (err) {
-    fail(`DiffPrism could not run the review: ${message(err)}`);
-    return;
+// cli/src/commands/feedback.ts
+import open2 from "open";
+async function feedback(flags = {}) {
+  const kind = flags.bug ? "bug" : "feedback";
+  const error = flags.bug ? readLastError() : null;
+  const url = buildFeedbackUrl({ kind, message: flags.message, error });
+  if (flags.bug && error) {
+    console.log(`Including the last error, from \`diffprism ${error.command}\` at ${error.at}.`);
   }
-  const decision = review2?.decision;
-  if (decision === "approved" || decision === "approved_with_comments") {
-    const summary = review2?.summary?.trim();
-    const comments = review2?.comments ?? [];
-    if (summary || comments.length > 0) {
-      printFeedback(review2);
-    }
-    console.error(`Review: ${decision} \u2014 proceeding.`);
-    process.exit(0);
-  }
-  if (decision === "changes_requested") {
-    printFeedback(review2);
-    fail("Commit blocked: the review requested changes.");
-    return;
-  }
-  if (decision === "dismissed") {
-    fail("Commit blocked: the review was dismissed without a decision.");
-    return;
-  }
-  fail(
-    `Commit blocked: no review decision was returned (got ${String(decision)}).`
-  );
-}
-function printFeedback(review2) {
-  const summary = review2?.summary?.trim();
-  const comments = review2?.comments ?? [];
-  console.error("");
-  if (!summary && comments.length === 0) {
-    console.error("  The review left no summary and no inline comments.");
-    console.error("  Ask what needs changing \u2014 there is nothing here to act on.");
-    console.error("");
-    return;
-  }
-  if (summary) {
-    for (const line of summary.split("\n")) {
-      console.error(`  ${line}`);
-    }
-    if (comments.length > 0) {
-      console.error("");
-    }
-  }
-  for (const c of comments) {
-    console.error(`  ${c.file}:${c.line}  [${c.type}]  ${c.body}`);
-  }
-  console.error("");
-}
-function installHook() {
-  const hookPath = resolveHookPath(process.cwd());
-  const existing = fs4.existsSync(hookPath) ? fs4.readFileSync(hookPath, "utf8") : "";
-  if (existing.includes(MARKER_START)) {
-    console.log(`Already installed in ${hookPath}`);
-    return;
-  }
-  const block = `${MARKER_START}
-${HOOK_LINE}
-${MARKER_END}
-`;
-  const base = existing === "" ? "#!/bin/sh\n" : ensureTrailingNewline(existing);
-  const created = existing === "";
-  fs4.mkdirSync(path4.dirname(hookPath), { recursive: true });
-  fs4.writeFileSync(hookPath, `${base}
-${block}`);
-  fs4.chmodSync(hookPath, 493);
-  console.log(`${created ? "Created" : "Updated"} ${hookPath}`);
   console.log(
-    `Staged changes of ${DEFAULT_MIN_LINES}+ lines now open a review before the commit lands.`
+    flags.print ? url : `Opening a prefilled GitHub issue \u2014 review it, then submit if you're happy with it:
+${url}`
   );
-  console.log("Tune with:  git config diffprism.gate-lines <n>");
-  console.log("Remove with: diffprism hook uninstall");
-}
-function uninstallHook() {
-  const hookPath = resolveHookPath(process.cwd());
-  if (!fs4.existsSync(hookPath)) {
-    console.log("Nothing to remove \u2014 no hook file.");
-    return;
-  }
-  const existing = fs4.readFileSync(hookPath, "utf8");
-  if (!existing.includes(MARKER_START)) {
-    console.log(`Nothing to remove \u2014 no diffprism block in ${hookPath}`);
-    return;
-  }
-  const cleaned = removeMarkedBlock(existing);
-  if (/^\s*(#![^\n]*)?\s*$/.test(cleaned)) {
-    fs4.rmSync(hookPath);
-    console.log(`Removed ${hookPath} (it contained nothing else).`);
-    return;
-  }
-  fs4.writeFileSync(hookPath, cleaned);
-  console.log(`Removed the diffprism block from ${hookPath}`);
-}
-function removeMarkedBlock(contents) {
-  const lines = contents.split("\n");
-  const out = [];
-  let inside = false;
-  for (const line of lines) {
-    if (line.trim() === MARKER_START) {
-      inside = true;
-      continue;
-    }
-    if (line.trim() === MARKER_END) {
-      inside = false;
-      continue;
+  if (!flags.print) {
+    try {
+      await open2(url);
+    } catch {
     }
-    if (!inside) {
-      out.push(line);
-    }
-  }
-  return ensureTrailingNewline(out.join("\n").replace(/\n{3,}/g, "\n\n"));
-}
-function resolveMinLines(flags, cwd) {
-  const fromFlag = flags.minLines ? Number.parseInt(flags.minLines, 10) : NaN;
-  if (Number.isFinite(fromFlag) && fromFlag > 0) {
-    return fromFlag;
-  }
-  const configured = Number.parseInt(
-    git(["config", "--get", "diffprism.gate-lines"], cwd) ?? "",
-    10
-  );
-  if (Number.isFinite(configured) && configured > 0) {
-    return configured;
   }
-  return DEFAULT_MIN_LINES;
-}
-function resolveHookPath(cwd) {
-  const configured = git(["config", "--get", "core.hooksPath"], cwd);
-  if (configured) {
-    return path4.resolve(cwd, configured, "pre-commit");
-  }
-  const hooksDir = git(["rev-parse", "--git-path", "hooks"], cwd) ?? ".git/hooks";
-  return path4.resolve(cwd, hooksDir, "pre-commit");
-}
-function git(args, cwd) {
-  try {
-    const out = execFileSync("git", args, {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    const trimmed = out.trim();
-    return trimmed === "" ? null : trimmed;
-  } catch {
-    return null;
-  }
-}
-function ensureTrailingNewline(text) {
-  return text.endsWith("\n") ? text : `${text}
-`;
-}
-function message(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-function fail(text) {
-  console.error(text);
-  process.exit(1);
 }
 
 // cli/src/index.ts
 var program = new Command();
-program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(
-  describeVersion(
-    true ? "0.49.0" : "0.0.0-dev"
-  )
-);
+program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(describeVersion(currentVersion()));
 program.action(defaultAction);
 program.command("demo").description("Open a sample review to see DiffPrism in action").option("--dev", "Use Vite dev server").action(demo);
 program.command("review [ref]").description("Open a browser-based diff review (local git ref or GitHub PR ref like owner/repo#123)").option("--staged", "Review staged changes").option("--unstaged", "Review unstaged changes").option("-t, --title <title>", "Review title").option("--reasoning <text>", "Agent reasoning about the changes").option("--dev", "Use Vite dev server with HMR instead of static files").option("--post-to-github", "Automatically post review back to GitHub without prompting").action(review);
@@ -1085,6 +1183,7 @@ hookCmd.command("install").description("Add the diffprism gate to this repo's pr
 hookCmd.command("uninstall").description("Remove the diffprism gate from this repo's pre-commit hook").action(() => {
   uninstallHook();
 });
+program.command("feedback").description("Open a prefilled GitHub issue to share feedback or report a bug \u2014 you review it before anything is sent").option("--bug", "Report a bug, including the last error DiffPrism hit").option("-m, --message <text>", "Start the issue with this text").option("--print", "Print the issue URL instead of opening a browser").action((flags) => feedback(flags));
 program.command("serve").description("Start the MCP server for Claude Code integration").action(serve);
 program.command("setup").description("Configure DiffPrism for Claude Code integration").option("--global", "Configure globally (skill + permissions, no git repo required)").option("--force", "Overwrite existing configuration files").option("--dev", "Use Vite dev server").option("--no-demo", "Skip the demo review after setup").action((flags) => {
   setup(flags);