@staff0rd/assist 0.660.2 → 0.661.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.660.2",
+  version: "0.661.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -717,7 +717,12 @@ var assistConfigShape = {
     readingWordsPerMinute: z3.number().int().positive().optional()
   }).optional(),
   review: z3.strictObject({
-    codexModel: z3.string().optional()
+    codexModel: z3.string().optional(),
+    highLevel: z3.strictObject({
+      criticalPaths: z3.array(z3.string()).default([]),
+      uiPaths: z3.array(z3.string()).default([]),
+      descriptionWordCap: z3.number().int().positive().default(300)
+    }).optional()
   }).optional(),
   readTime: z3.strictObject({
     wordsPerMinute: z3.number().int().positive().default(200)
@@ -1941,10 +1946,10 @@ import fs11 from "fs";
 
 // src/commands/lint/shared.ts
 import chalk24 from "chalk";
-function reportViolations2(violations, checkName, errorMessage, successMessage) {
+function reportViolations2(violations, checkName2, errorMessage, successMessage) {
   if (violations.length > 0) {
     console.error(chalk24.red(`
-${checkName} failed:
+${checkName2} failed:
 `));
     console.error(chalk24.red(`  ${errorMessage}
 `));
@@ -3363,6 +3368,21 @@ var reviewConfigHelp = [
     key: "review.codexModel",
     setter: "assist config set review.codexModel gpt-5-codex",
     note: "optional; runs the codex reviewer on this model via the LiteLLM proxy (needs litellm.baseUrl and litellm.apiKey)"
+  },
+  {
+    key: "review.highLevel.criticalPaths",
+    setter: 'assist config set review.highLevel.criticalPaths "**/*.graphql,en-AU/translation.json"',
+    note: "comma-separated globs whose full diffs the high-level review shows; unset shows none"
+  },
+  {
+    key: "review.highLevel.uiPaths",
+    setter: 'assist config set review.highLevel.uiPaths "src/ui/**"',
+    note: "comma-separated globs that make a change a UI change, so --high-level requires a screenshot or video; unset requires none"
+  },
+  {
+    key: "review.highLevel.descriptionWordCap",
+    setter: "assist config set review.highLevel.descriptionWordCap 300",
+    note: "word cap --high-level holds the PR description to (default 300)"
   }
 ];
 
@@ -5010,12 +5030,12 @@ function addViteBaseConfig() {
     console.log("vite.config.ts already has base config");
     return;
   }
-  const updated = content.replace(
+  const updated2 = content.replace(
     /defineConfig\(\{/,
     'defineConfig({\n	base: "./",'
   );
-  if (updated !== content) {
-    writeFileSync13(viteConfigPath, updated);
+  if (updated2 !== content) {
+    writeFileSync13(viteConfigPath, updated2);
     console.log('Added base: "./" to vite.config.ts');
   }
 }
@@ -10716,16 +10736,16 @@ async function patchItemStatus(req, res, id) {
   const result = await findItemOr404(res, id);
   if (!result) return;
   await updateStatus(result.orm, id, status3);
-  const updated = { ...result.item, status: status3 };
-  respondJson(res, 200, updated);
+  const updated2 = { ...result.item, status: status3 };
+  respondJson(res, 200, updated2);
 }
 async function patchItemStar(req, res, id) {
   const { starred } = await parseStarBody(req);
   const result = await findItemOr404(res, id);
   if (!result) return;
   await updateStarred(result.orm, id, starred);
-  const updated = { ...result.item, starred };
-  respondJson(res, 200, updated);
+  const updated2 = { ...result.item, starred };
+  respondJson(res, 200, updated2);
 }
 
 // src/commands/backlog/web/deleteItemComment.ts
@@ -13045,15 +13065,15 @@ function setNestedValue(obj, path91, value) {
 }
 
 // src/commands/config/validateConfig.ts
-function validateConfig(updated, key, schema2 = assistConfigSchema) {
-  const result = schema2.safeParse(stripLegacyConfigKeys(updated));
+function validateConfig(updated2, key, schema2 = assistConfigSchema) {
+  const result = schema2.safeParse(stripLegacyConfigKeys(updated2));
   if (result.success) return { ok: true };
   const errors = result.error.issues.flatMap(
     (issue) => formatIssue2(issue, key)
   );
   return {
     ok: false,
-    errors: scrubConfigSecrets(errors, updated, describeConfigNode(schema2))
+    errors: scrubConfigSecrets(errors, updated2, describeConfigNode(schema2))
   };
 }
 function formatIssue2(issue, key) {
@@ -13076,14 +13096,14 @@ function applyConfigSet(key, coerced, global, cwd = process.cwd(), globalConfigP
     };
   }
   const raw = global ? loadGlobalConfigRaw(globalConfigPath) : loadProjectConfig(cwd);
-  const updated = setNestedValue(raw, key, coerced);
-  const validation = validateConfig(updated, key);
+  const updated2 = setNestedValue(raw, key, coerced);
+  const validation = validateConfig(updated2, key);
   if (!validation.ok) return validation;
   if (global) {
-    saveGlobalConfig(updated, globalConfigPath);
+    saveGlobalConfig(updated2, globalConfigPath);
     return { ok: true, target: "global" };
   }
-  saveConfig(updated, cwd);
+  saveConfig(updated2, cwd);
   return { ok: true, target: "project" };
 }
 
@@ -16467,20 +16487,20 @@ function hasListMutations(options2) {
     options2.add && options2.add.length > 0 || options2.edit || options2.remove
   );
 }
-function applyListMutations(current, options2, flags) {
+function applyListMutations(current, options2, flags2) {
   let items2 = [...current];
   if (options2.edit) {
     const [rawIndex, ...textParts] = options2.edit;
     if (rawIndex === void 0 || textParts.length === 0) {
       return {
         ok: false,
-        error: `${flags.edit} requires an index and replacement text.`
+        error: `${flags2.edit} requires an index and replacement text.`
       };
     }
     const parsed = parseListIndex(
       rawIndex,
       items2.length,
-      `${flags.edit} index`
+      `${flags2.edit} index`
     );
     if (!parsed.ok) return parsed;
     items2[parsed.index - 1] = textParts.join(" ");
@@ -16489,7 +16509,7 @@ function applyListMutations(current, options2, flags) {
     const parsed = parseListIndex(
       options2.remove,
       items2.length,
-      `${flags.remove} index`
+      `${flags2.remove} index`
     );
     if (!parsed.ok) return parsed;
     items2 = items2.filter((_, i) => i !== parsed.index - 1);
@@ -16501,15 +16521,15 @@ function applyListMutations(current, options2, flags) {
 }
 
 // src/commands/backlog/update/resolveListUpdate.ts
-function resolveListUpdate(whole, current, mutations, wholeFlag, flags) {
+function resolveListUpdate(whole, current, mutations, wholeFlag, flags2) {
   if (!hasListMutations(mutations)) return { ok: true, items: whole };
   if (whole) {
     return {
       ok: false,
-      error: `Cannot combine ${wholeFlag} with ${flags.add}/${flags.edit}/${flags.remove}.`
+      error: `Cannot combine ${wholeFlag} with ${flags2.add}/${flags2.edit}/${flags2.remove}.`
     };
   }
-  return applyListMutations(current, mutations, flags);
+  return applyListMutations(current, mutations, flags2);
 }
 
 // src/commands/backlog/resolvePhaseFields.ts
@@ -18428,8 +18448,8 @@ function loadDenyConfig(global) {
   const deny = config.deny ?? [];
   return {
     deny,
-    saveDeny: (updated) => {
-      config.deny = updated;
+    saveDeny: (updated2) => {
+      config.deny = updated2;
       save(config);
     }
   };
@@ -27471,8 +27491,218 @@ async function reply(commentId, body) {
   }
 }
 
-// src/commands/prs/wontfix.ts
+// src/commands/prs/status/describeFetchError.ts
+function firstLine2(text18) {
+  const line = text18.split("\n").map((candidate) => candidate.trim()).find((candidate) => candidate.length > 0);
+  return line ?? null;
+}
+function stderrText(error) {
+  const stderr = error?.stderr;
+  if (typeof stderr === "string") return firstLine2(stderr);
+  if (stderr instanceof Uint8Array) {
+    return firstLine2(Buffer.from(stderr).toString("utf8"));
+  }
+  return null;
+}
+function describeFetchError(error) {
+  if (isGhNotInstalled(error)) {
+    return "GitHub CLI (gh) is not installed \u2014 see https://cli.github.com/";
+  }
+  const stderr = stderrText(error);
+  if (stderr) return stderr;
+  if (error instanceof Error) return firstLine2(error.message) ?? error.message;
+  return String(error);
+}
+
+// src/commands/prs/status/fetchRepoPullRequests.ts
 import { execSync as execSync51 } from "child_process";
+var FIELDS = "number,title,url,author,isDraft,createdAt,updatedAt,reviewDecision,latestReviews,statusCheckRollup,mergeable";
+function fetchRepoPullRequests(org, repo) {
+  const output = execSync51(
+    `gh pr list --state open --json ${FIELDS} --limit 100 -R ${org}/${repo}`,
+    { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }
+  );
+  const parsed = JSON.parse(output);
+  if (!Array.isArray(parsed)) {
+    throw new Error("unexpected response from gh pr list");
+  }
+  return parsed;
+}
+
+// src/commands/prs/status/parseRepoArgument.ts
+var REPO_ARGUMENT = /^([A-Za-z0-9._-]+)\/([A-Za-z0-9._-]+)$/;
+function parseRepoArgument(value) {
+  const match = REPO_ARGUMENT.exec(value.trim());
+  if (!match) return null;
+  return { org: match[1], repo: match[2] };
+}
+
+// src/commands/prs/status/describeAge.ts
+function describeAge(timestamp6, now = Date.now()) {
+  const parsed = new Date(timestamp6).getTime();
+  if (Number.isNaN(parsed)) return { hours: null, label: "unknown" };
+  const hours = Math.max(0, Math.floor((now - parsed) / 36e5));
+  if (hours < 1) return { hours, label: "<1h" };
+  if (hours < 24) return { hours, label: `${hours}h` };
+  return { hours, label: `${Math.floor(hours / 24)}d` };
+}
+
+// src/commands/prs/status/summariseChecks.ts
+var PASSING_CONCLUSIONS = /* @__PURE__ */ new Set(["SUCCESS", "NEUTRAL", "SKIPPED"]);
+var PENDING_STATES = /* @__PURE__ */ new Set(["PENDING", "EXPECTED"]);
+function checkName(check2) {
+  return check2.name?.trim() || check2.context?.trim() || "unnamed check";
+}
+function isPending(check2) {
+  if (check2.status) return check2.status !== "COMPLETED";
+  return PENDING_STATES.has(check2.state ?? "");
+}
+function isFailing(check2) {
+  if (check2.status) return !PASSING_CONCLUSIONS.has(check2.conclusion ?? "");
+  return !PASSING_CONCLUSIONS.has(check2.state ?? "");
+}
+function summariseChecks(rollup) {
+  const summary = { failing: [], pending: [] };
+  for (const check2 of rollup ?? []) {
+    if (isPending(check2)) summary.pending.push(checkName(check2));
+    else if (isFailing(check2)) summary.failing.push(checkName(check2));
+  }
+  return summary;
+}
+
+// src/commands/prs/status/toPrStatus.ts
+function toReviews(pr) {
+  return (pr.latestReviews ?? []).map((review2) => ({
+    reviewer: review2.author?.login ?? "unknown",
+    state: review2.state ?? "UNKNOWN"
+  }));
+}
+function toPrStatus(pr, now = Date.now()) {
+  const age = describeAge(pr.updatedAt, now);
+  return {
+    number: pr.number,
+    title: pr.title,
+    url: pr.url,
+    author: pr.author?.login ?? "unknown",
+    isBot: pr.author?.is_bot === true,
+    isDraft: pr.isDraft === true,
+    createdAt: pr.createdAt,
+    updatedAt: pr.updatedAt,
+    age: age.label,
+    ageHours: age.hours,
+    reviewDecision: pr.reviewDecision || null,
+    reviews: toReviews(pr),
+    checks: summariseChecks(pr.statusCheckRollup),
+    mergeable: pr.mergeable || "UNKNOWN"
+  };
+}
+
+// src/commands/prs/status/buildPrsStatusReport.ts
+function buildPrsStatusReport(repoArguments, now = Date.now()) {
+  const report2 = { repos: [], errors: [] };
+  for (const argument of repoArguments) {
+    const parsed = parseRepoArgument(argument);
+    if (!parsed) {
+      report2.errors.push({
+        repo: argument,
+        error: "not an owner/repo argument"
+      });
+      continue;
+    }
+    const repo = `${parsed.org}/${parsed.repo}`;
+    try {
+      const pullRequests = fetchRepoPullRequests(parsed.org, parsed.repo).map(
+        (pr) => toPrStatus(pr, now)
+      );
+      report2.repos.push({ repo, pullRequests });
+    } catch (error) {
+      report2.errors.push({ repo, error: describeFetchError(error) });
+    }
+  }
+  return report2;
+}
+
+// src/commands/prs/status/printPrsStatus.ts
+import chalk187 from "chalk";
+
+// src/commands/prs/status/printPrStatus.ts
+import chalk186 from "chalk";
+function flags(pr) {
+  const markers = [];
+  if (pr.isDraft) markers.push("draft");
+  if (pr.isBot) markers.push("bot");
+  return markers.length ? ` ${chalk186.yellow(`[${markers.join(", ")}]`)}` : "";
+}
+function updated(pr) {
+  return pr.ageHours === null ? "updated unknown" : `updated ${pr.age} ago`;
+}
+function reviewLine(pr) {
+  if (!pr.reviewDecision && pr.reviews.length === 0) return null;
+  const reviewers = pr.reviews.map((review2) => `${review2.reviewer}: ${review2.state}`).join(", ");
+  const decision = pr.reviewDecision ?? "no decision";
+  return reviewers ? `review: ${decision} | ${reviewers}` : `review: ${decision}`;
+}
+function checkLines(pr) {
+  const lines2 = [];
+  if (pr.checks.failing.length) {
+    lines2.push(chalk186.red(`failing: ${pr.checks.failing.join(", ")}`));
+  }
+  if (pr.checks.pending.length) {
+    lines2.push(chalk186.yellow(`pending: ${pr.checks.pending.join(", ")}`));
+  }
+  return lines2;
+}
+function mergeableLine(pr) {
+  if (pr.mergeable === "CONFLICTING") return chalk186.red("conflicting");
+  if (pr.mergeable === "MERGEABLE") return null;
+  return chalk186.dim(`mergeable: ${pr.mergeable.toLowerCase()}`);
+}
+function printPrStatus(pr) {
+  console.log(
+    `  ${chalk186.cyan(`#${pr.number}`)} ${pr.title} ${chalk186.dim(`(${pr.author}, ${updated(pr)})`)}${flags(pr)}`
+  );
+  const details = [
+    reviewLine(pr),
+    ...checkLines(pr),
+    mergeableLine(pr),
+    chalk186.dim(pr.url)
+  ];
+  for (const detail of details) {
+    if (detail) console.log(`      ${detail}`);
+  }
+}
+
+// src/commands/prs/status/printPrsStatus.ts
+function printPrsStatus(report2) {
+  for (const repo of report2.repos) {
+    const count8 = repo.pullRequests.length;
+    console.log(`${chalk187.bold(repo.repo)} ${chalk187.dim(`(${count8} open)`)}`);
+    for (const pr of repo.pullRequests) {
+      printPrStatus(pr);
+    }
+    if (count8 === 0) console.log(chalk187.dim("  no open pull requests"));
+    console.log();
+  }
+  if (report2.errors.length === 0) return;
+  console.log(chalk187.bold("Errors"));
+  for (const failure of report2.errors) {
+    console.log(`  ${chalk187.red(failure.repo)}: ${failure.error}`);
+  }
+  console.log();
+}
+
+// src/commands/prs/status/index.ts
+function prsStatus(repos2, options2) {
+  const report2 = buildPrsStatusReport(repos2);
+  if (options2.json) {
+    console.log(JSON.stringify(report2, null, 2));
+    return;
+  }
+  printPrsStatus(report2);
+}
+
+// src/commands/prs/wontfix.ts
+import { execSync as execSync52 } from "child_process";
 function validateReason(reason4) {
   const lowerReason = reason4.toLowerCase();
   if (lowerReason.includes("claude") || lowerReason.includes("opus")) {
@@ -27489,7 +27719,7 @@ function validateShaReferences(reason4) {
   const invalidShas = [];
   for (const sha of shas) {
     try {
-      execSync51(`git cat-file -t ${sha}`, { stdio: "pipe" });
+      execSync52(`git cat-file -t ${sha}`, { stdio: "pipe" });
     } catch {
       invalidShas.push(sha);
     }
@@ -27782,6 +28012,13 @@ function registerPrsRaise(prsCommand) {
   configHelp(raiseCommand, prsRaiseConfigHelp);
 }
 
+// src/commands/registerPrsStatus.ts
+function registerPrsStatus(prsCommand) {
+  prsCommand.command("status <repo...>").description(
+    "Report every open pull request in each owner/repo, grouped by repo"
+  ).option("--json", "Output as JSON").action(prsStatus);
+}
+
 // src/commands/readTime/readTime.ts
 import { readFileSync as readFileSync46 } from "fs";
 
@@ -27871,7 +28108,7 @@ function resolveReadTimeTarget(target) {
 }
 
 // src/commands/prs/fetchPrBody.ts
-import { execSync as execSync52 } from "child_process";
+import { execSync as execSync53 } from "child_process";
 function exitGhNotInstalled() {
   console.error("Error: GitHub CLI (gh) is not installed.");
   console.error("Install it from https://cli.github.com/");
@@ -27892,7 +28129,7 @@ function currentRepo() {
 function fetchPrBody(number, repo) {
   const { org, repo: name } = repo ?? currentRepo();
   try {
-    const raw = execSync52(`gh pr view ${number} --json body -R ${org}/${name}`, {
+    const raw = execSync53(`gh pr view ${number} --json body -R ${org}/${name}`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -27971,6 +28208,7 @@ function registerReadTime(parent) {
 function registerPrs(program2) {
   const prsCommand = program2.command("prs").description("Pull request utilities").option("--open", "List only open pull requests").option("--closed", "List only closed pull requests").action(prs);
   registerPrsRaise(prsCommand);
+  registerPrsStatus(prsCommand);
   registerPrsEdit(prsCommand);
   registerPrsComments(prsCommand);
   registerReadTime(prsCommand);
@@ -27978,10 +28216,10 @@ function registerPrs(program2) {
 }
 
 // src/commands/ravendb/ravendbAuth.ts
-import chalk191 from "chalk";
+import chalk193 from "chalk";
 
 // src/shared/createConnectionAuth.ts
-import chalk186 from "chalk";
+import chalk188 from "chalk";
 function listConnections(connections, format2) {
   if (connections.length === 0) {
     console.log("No connections configured.");
@@ -27994,7 +28232,7 @@ function listConnections(connections, format2) {
 function removeConnection(connections, name, save) {
   const filtered = connections.filter((c) => c.name !== name);
   if (filtered.length === connections.length) {
-    console.error(chalk186.red(`Connection "${name}" not found.`));
+    console.error(chalk188.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   save(filtered);
@@ -28040,17 +28278,17 @@ function saveConnections(connections) {
 }
 
 // src/commands/ravendb/promptConnection.ts
-import chalk189 from "chalk";
+import chalk191 from "chalk";
 
 // src/commands/ravendb/selectOpSecret.ts
-import chalk188 from "chalk";
+import chalk190 from "chalk";
 import Enquirer2 from "enquirer";
 
 // src/commands/ravendb/searchItems.ts
-import { execSync as execSync53 } from "child_process";
-import chalk187 from "chalk";
+import { execSync as execSync54 } from "child_process";
+import chalk189 from "chalk";
 function opExec(args) {
-  return execSync53(`op ${args}`, {
+  return execSync54(`op ${args}`, {
     encoding: "utf8",
     stdio: ["pipe", "pipe", "pipe"]
   }).trim();
@@ -28061,7 +28299,7 @@ function searchItems(search2) {
     items2 = JSON.parse(opExec("item list --format=json"));
   } catch {
     console.error(
-      chalk187.red(
+      chalk189.red(
         "Failed to search 1Password. Ensure the CLI is installed and you are signed in."
       )
     );
@@ -28075,7 +28313,7 @@ function getItemFields(itemId2) {
     const item = JSON.parse(opExec(`item get "${itemId2}" --format=json`));
     return item.fields.filter((f) => f.reference && f.label);
   } catch {
-    console.error(chalk187.red("Failed to get item details from 1Password."));
+    console.error(chalk189.red("Failed to get item details from 1Password."));
     process.exit(1);
   }
 }
@@ -28094,7 +28332,7 @@ async function selectOpSecret(searchTerm) {
   }).run();
   const items2 = searchItems(search2);
   if (items2.length === 0) {
-    console.error(chalk188.red(`No items found matching "${search2}".`));
+    console.error(chalk190.red(`No items found matching "${search2}".`));
     process.exit(1);
   }
   const itemId2 = await selectOne(
@@ -28103,7 +28341,7 @@ async function selectOpSecret(searchTerm) {
   );
   const fields = getItemFields(itemId2);
   if (fields.length === 0) {
-    console.error(chalk188.red("No fields with references found on this item."));
+    console.error(chalk190.red("No fields with references found on this item."));
     process.exit(1);
   }
   const ref = await selectOne(
@@ -28117,7 +28355,7 @@ async function selectOpSecret(searchTerm) {
 async function promptConnection(existingNames) {
   const name = await promptInput("name", "Connection name:");
   if (existingNames.includes(name)) {
-    console.error(chalk189.red(`Connection "${name}" already exists.`));
+    console.error(chalk191.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
   const url = await promptInput(
@@ -28126,22 +28364,22 @@ async function promptConnection(existingNames) {
   );
   const database = await promptInput("database", "Database name:");
   if (!name || !url || !database) {
-    console.error(chalk189.red("All fields are required."));
+    console.error(chalk191.red("All fields are required."));
     process.exit(1);
   }
   const apiKeyRef = await selectOpSecret();
-  console.log(chalk189.dim(`Using: ${apiKeyRef}`));
+  console.log(chalk191.dim(`Using: ${apiKeyRef}`));
   return { name, url, database, apiKeyRef };
 }
 
 // src/commands/ravendb/ravendbSetConnection.ts
-import chalk190 from "chalk";
+import chalk192 from "chalk";
 function ravendbSetConnection(name) {
   const raw = loadGlobalConfigRaw();
   const ravendb = raw.ravendb ?? {};
   const connections = ravendb.connections ?? [];
   if (!connections.some((c) => c.name === name)) {
-    console.error(chalk190.red(`Connection "${name}" not found.`));
+    console.error(chalk192.red(`Connection "${name}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -28157,16 +28395,16 @@ function ravendbSetConnection(name) {
 var ravendbAuth = createConnectionAuth({
   load: loadConnections,
   save: saveConnections,
-  format: (c) => `${chalk191.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
+  format: (c) => `${chalk193.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
   promptNew: promptConnection,
   onFirst: (c) => ravendbSetConnection(c.name)
 });
 
 // src/commands/ravendb/ravendbCollections.ts
-import chalk195 from "chalk";
+import chalk197 from "chalk";
 
 // src/commands/ravendb/ravenFetch.ts
-import chalk193 from "chalk";
+import chalk195 from "chalk";
 
 // src/commands/ravendb/getAccessToken.ts
 var OAUTH_URL = "https://amazon-useast-1-oauth.ravenhq.com/ApiKeys/OAuth/AccessToken";
@@ -28202,21 +28440,21 @@ ${errorText}`
 }
 
 // src/commands/ravendb/resolveOpSecret.ts
-import { execSync as execSync54 } from "child_process";
-import chalk192 from "chalk";
+import { execSync as execSync55 } from "child_process";
+import chalk194 from "chalk";
 function resolveOpSecret(reference) {
   if (!reference.startsWith("op://")) {
-    console.error(chalk192.red(`Invalid secret reference: must start with op://`));
+    console.error(chalk194.red(`Invalid secret reference: must start with op://`));
     process.exit(1);
   }
   try {
-    return execSync54(`op read "${reference}"`, {
+    return execSync55(`op read "${reference}"`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
   } catch {
     console.error(
-      chalk192.red(
+      chalk194.red(
         "Failed to resolve secret reference. Ensure 1Password CLI is installed and you are signed in."
       )
     );
@@ -28243,7 +28481,7 @@ async function ravenFetch(connection, path91) {
   if (!response.ok) {
     const body = await response.text();
     console.error(
-      chalk193.red(`RavenDB error: ${response.status} ${response.statusText}`)
+      chalk195.red(`RavenDB error: ${response.status} ${response.statusText}`)
     );
     console.error(body.substring(0, 500));
     process.exit(1);
@@ -28252,7 +28490,7 @@ async function ravenFetch(connection, path91) {
 }
 
 // src/commands/ravendb/resolveConnection.ts
-import chalk194 from "chalk";
+import chalk196 from "chalk";
 function loadRavendb() {
   const raw = loadGlobalConfigRaw();
   const ravendb = raw.ravendb;
@@ -28266,7 +28504,7 @@ function resolveConnection(name) {
   const connectionName = name ?? defaultConnection;
   if (!connectionName) {
     console.error(
-      chalk194.red(
+      chalk196.red(
         "No connection specified and no default set. Use assist ravendb set-connection <name> or pass a connection name."
       )
     );
@@ -28274,7 +28512,7 @@ function resolveConnection(name) {
   }
   const connection = connections.find((c) => c.name === connectionName);
   if (!connection) {
-    console.error(chalk194.red(`Connection "${connectionName}" not found.`));
+    console.error(chalk196.red(`Connection "${connectionName}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -28305,15 +28543,15 @@ async function ravendbCollections(connectionName) {
     return;
   }
   for (const c of collections) {
-    console.log(`${chalk195.bold(c.Name)}  ${c.CountOfDocuments} docs`);
+    console.log(`${chalk197.bold(c.Name)}  ${c.CountOfDocuments} docs`);
   }
 }
 
 // src/commands/ravendb/ravendbQuery.ts
-import chalk197 from "chalk";
+import chalk199 from "chalk";
 
 // src/commands/ravendb/fetchAllPages.ts
-import chalk196 from "chalk";
+import chalk198 from "chalk";
 
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
@@ -28351,7 +28589,7 @@ async function fetchAllPages(connection, opts) {
     allResults.push(...results);
     start3 += results.length;
     process.stderr.write(
-      `\r${chalk196.dim(`Fetched ${allResults.length}/${totalResults}`)}`
+      `\r${chalk198.dim(`Fetched ${allResults.length}/${totalResults}`)}`
     );
     if (start3 >= totalResults) break;
     if (opts.limit !== void 0 && allResults.length >= opts.limit) break;
@@ -28366,7 +28604,7 @@ async function fetchAllPages(connection, opts) {
 async function ravendbQuery(connectionName, collection, options2) {
   const resolved = resolveArgs(connectionName, collection);
   if (!resolved.collection && !options2.query) {
-    console.error(chalk197.red("Provide a collection name or --query filter."));
+    console.error(chalk199.red("Provide a collection name or --query filter."));
     process.exit(1);
   }
   const { collection: col } = resolved;
@@ -28405,7 +28643,7 @@ import { spawn as spawn6 } from "child_process";
 import * as path46 from "path";
 
 // src/commands/refactor/logViolations.ts
-import chalk198 from "chalk";
+import chalk200 from "chalk";
 var DEFAULT_MAX_LINES2 = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES2) {
   if (violations.length === 0) {
@@ -28414,43 +28652,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES2) {
     }
     return;
   }
-  console.error(chalk198.red(`
+  console.error(chalk200.red(`
 Refactor check failed:
 `));
-  console.error(chalk198.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk200.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk198.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk200.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk198.yellow(
+    chalk200.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk198.gray(`    assist refactor ignore <file>
+  console.error(chalk200.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk198.cyan(`
+    console.error(chalk200.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk198.cyan(
+      chalk200.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk198.cyan(
+      chalk200.cyan(
         `  1. Keep related logic together: If the extracted code is tightly coupled to the
      original file's domain, create a new folder containing both the original and extracted files.
 `
       )
     );
     console.error(
-      chalk198.cyan(
+      chalk200.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -28460,7 +28698,7 @@ Refactor check failed:
 }
 
 // src/commands/refactor/check/getViolations/index.ts
-import { execSync as execSync55 } from "child_process";
+import { execSync as execSync56 } from "child_process";
 import fs31 from "fs";
 import { minimatch as minimatch6 } from "minimatch";
 
@@ -28510,7 +28748,7 @@ function getGitFiles(options2) {
   }
   const files = /* @__PURE__ */ new Set();
   if (options2.staged || options2.modified) {
-    const staged = execSync55("git diff --cached --name-only", {
+    const staged = execSync56("git diff --cached --name-only", {
       encoding: "utf8"
     });
     for (const file of staged.trim().split("\n").filter(Boolean)) {
@@ -28518,7 +28756,7 @@ function getGitFiles(options2) {
     }
   }
   if (options2.unstaged || options2.modified) {
-    const unstaged = execSync55("git diff --name-only", { encoding: "utf8" });
+    const unstaged = execSync56("git diff --name-only", { encoding: "utf8" });
     for (const file of unstaged.trim().split("\n").filter(Boolean)) {
       files.add(file);
     }
@@ -28606,7 +28844,7 @@ async function check(pattern2, options2) {
 
 // src/commands/refactor/extract/index.ts
 import path54 from "path";
-import chalk201 from "chalk";
+import chalk203 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
 import { SyntaxKind as SyntaxKind4 } from "ts-morph";
@@ -29205,23 +29443,23 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 
 // src/commands/refactor/extract/displayPlan.ts
 import path50 from "path";
-import chalk199 from "chalk";
+import chalk201 from "chalk";
 function section(title) {
   return `
-  ${chalk199.cyan(title)}`;
+  ${chalk201.cyan(title)}`;
 }
 function displayImporters(plan2, cwd) {
   if (plan2.importersToUpdate.length === 0) return;
   console.log(section("Update importers:"));
   for (const imp of plan2.importersToUpdate) {
     const rel = path50.relative(cwd, imp.file.getFilePath());
-    console.log(`    ${chalk199.dim(rel)}: \u2192 import from "${imp.relPath}"`);
+    console.log(`    ${chalk201.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
 function displayPlan(functionName, relDest, plan2, cwd) {
-  console.log(chalk199.bold(`Extract: ${functionName} \u2192 ${relDest}
+  console.log(chalk201.bold(`Extract: ${functionName} \u2192 ${relDest}
 `));
-  console.log(`  ${chalk199.cyan("Functions to move:")}`);
+  console.log(`  ${chalk201.cyan("Functions to move:")}`);
   for (const name of plan2.extractedNames) {
     console.log(`    ${name}`);
   }
@@ -29255,7 +29493,7 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 
 // src/commands/refactor/extract/loadProjectFile.ts
 import path53 from "path";
-import chalk200 from "chalk";
+import chalk202 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
@@ -29347,7 +29585,7 @@ function loadProjectFile(file) {
   });
   const sourceFile = project.getSourceFile(sourcePath);
   if (!sourceFile) {
-    console.log(chalk200.red(`File not found in project: ${file}`));
+    console.log(chalk202.red(`File not found in project: ${file}`));
     process.exit(1);
   }
   return { project, sourceFile };
@@ -29370,19 +29608,19 @@ async function extract(file, functionName, destination, options2 = {}) {
   displayPlan(functionName, relDest, plan2, cwd);
   if (options2.apply) {
     await applyExtraction(functionName, sourceFile, destPath, plan2, project);
-    console.log(chalk201.green("\nExtraction complete"));
+    console.log(chalk203.green("\nExtraction complete"));
   } else {
-    console.log(chalk201.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk203.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/ignore.ts
 import fs34 from "fs";
-import chalk202 from "chalk";
+import chalk204 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore2(file) {
   if (!fs34.existsSync(file)) {
-    console.error(chalk202.red(`Error: File does not exist: ${file}`));
+    console.error(chalk204.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
   const content = fs34.readFileSync(file, "utf8");
@@ -29398,7 +29636,7 @@ function ignore2(file) {
     fs34.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk202.green(
+    chalk204.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
@@ -29407,12 +29645,12 @@ function ignore2(file) {
 // src/commands/refactor/rename/index.ts
 import fs37 from "fs";
 import path59 from "path";
-import chalk205 from "chalk";
+import chalk207 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs36 from "fs";
 import path56 from "path";
-import chalk203 from "chalk";
+import chalk205 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
 import path55 from "path";
@@ -29517,13 +29755,13 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs36.writeFileSync(file, content, "utf8");
-    console.log(chalk203.cyan(`  Updated imports in ${path56.relative(cwd, file)}`));
+    console.log(chalk205.cyan(`  Updated imports in ${path56.relative(cwd, file)}`));
   }
   const destDir = path56.dirname(destPath);
   if (!fs36.existsSync(destDir)) fs36.mkdirSync(destDir, { recursive: true });
   fs36.renameSync(sourcePath, destPath);
   console.log(
-    chalk203.white(
+    chalk205.white(
       `  Moved ${path56.relative(cwd, sourcePath)} \u2192 ${path56.relative(cwd, destPath)}`
     )
   );
@@ -29610,16 +29848,16 @@ function computeRenameRewrites(sourcePath, destPath) {
 
 // src/commands/refactor/rename/printRenamePreview.ts
 import path58 from "path";
-import chalk204 from "chalk";
+import chalk206 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
-      chalk204.dim(
+      chalk206.dim(
         `  ${path58.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
-  console.log(chalk204.dim("Dry run. Use --apply to execute."));
+  console.log(chalk206.dim("Dry run. Use --apply to execute."));
 }
 
 // src/commands/refactor/rename/index.ts
@@ -29630,20 +29868,20 @@ async function rename(source, destination, options2 = {}) {
   const relSource = path59.relative(cwd, sourcePath);
   const relDest = path59.relative(cwd, destPath);
   if (!fs37.existsSync(sourcePath)) {
-    console.log(chalk205.red(`File not found: ${source}`));
+    console.log(chalk207.red(`File not found: ${source}`));
     process.exit(1);
   }
   if (destPath !== sourcePath && fs37.existsSync(destPath)) {
-    console.log(chalk205.red(`Destination already exists: ${destination}`));
+    console.log(chalk207.red(`Destination already exists: ${destination}`));
     process.exit(1);
   }
-  console.log(chalk205.bold(`Rename: ${relSource} \u2192 ${relDest}`));
-  console.log(chalk205.dim("Loading project..."));
-  console.log(chalk205.dim("Scanning imports across the project..."));
+  console.log(chalk207.bold(`Rename: ${relSource} \u2192 ${relDest}`));
+  console.log(chalk207.dim("Loading project..."));
+  console.log(chalk207.dim("Scanning imports across the project..."));
   const rewrites = computeRenameRewrites(sourcePath, destPath);
   const affectedFiles = new Set(rewrites.map((r) => r.file)).size;
   console.log(
-    chalk205.dim(
+    chalk207.dim(
       `${rewrites.length} import path(s) to update across ${affectedFiles} file(s)`
     )
   );
@@ -29652,11 +29890,11 @@ async function rename(source, destination, options2 = {}) {
     return;
   }
   applyRename(rewrites, sourcePath, destPath, cwd);
-  console.log(chalk205.green("Done"));
+  console.log(chalk207.green("Done"));
 }
 
 // src/commands/refactor/renameSymbol/index.ts
-import chalk206 from "chalk";
+import chalk208 from "chalk";
 
 // src/commands/refactor/renameSymbol/findSymbol.ts
 import { SyntaxKind as SyntaxKind15 } from "ts-morph";
@@ -29702,33 +29940,33 @@ async function renameSymbol(file, oldName, newName, options2 = {}) {
   const { project, sourceFile } = loadProjectFile(file);
   const symbol = findSymbol(sourceFile, oldName);
   if (!symbol) {
-    console.log(chalk206.red(`Symbol "${oldName}" not found in ${file}`));
+    console.log(chalk208.red(`Symbol "${oldName}" not found in ${file}`));
     process.exit(1);
   }
   const grouped = groupReferences(symbol, cwd);
   const totalRefs = [...grouped.values()].reduce((s, l) => s + l.length, 0);
   console.log(
-    chalk206.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
+    chalk208.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
 `)
   );
   for (const [refFile, lines2] of grouped) {
     console.log(
-      `  ${chalk206.dim(refFile)}: lines ${chalk206.cyan(lines2.join(", "))}`
+      `  ${chalk208.dim(refFile)}: lines ${chalk208.cyan(lines2.join(", "))}`
     );
   }
   if (options2.apply) {
     symbol.rename(newName);
     await project.save();
-    console.log(chalk206.green(`
+    console.log(chalk208.green(`
 Renamed ${oldName} \u2192 ${newName}`));
   } else {
-    console.log(chalk206.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk208.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/restructure/index.ts
 import path67 from "path";
-import chalk209 from "chalk";
+import chalk211 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
 import path61 from "path";
@@ -29807,50 +30045,50 @@ function clusterFiles(graph) {
 
 // src/commands/refactor/restructure/displayPlan.ts
 import path63 from "path";
-import chalk207 from "chalk";
+import chalk209 from "chalk";
 function relPath(filePath) {
   return path63.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
-  console.log(chalk207.bold("\nFile moves:"));
+  console.log(chalk209.bold("\nFile moves:"));
   for (const move2 of plan2.moves) {
     console.log(
-      `  ${chalk207.red(relPath(move2.from))} \u2192 ${chalk207.green(relPath(move2.to))}`
+      `  ${chalk209.red(relPath(move2.from))} \u2192 ${chalk209.green(relPath(move2.to))}`
     );
-    console.log(chalk207.dim(`    ${move2.reason}`));
+    console.log(chalk209.dim(`    ${move2.reason}`));
   }
 }
 function displayRewrites(rewrites) {
   if (rewrites.length === 0) return;
   const affectedFiles = new Set(rewrites.map((r) => r.file));
-  console.log(chalk207.bold(`
+  console.log(chalk209.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk207.cyan(relPath(file))}:`);
+    console.log(`  ${chalk209.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk207.red(`"${oldSpecifier}"`)} \u2192 ${chalk207.green(`"${newSpecifier}"`)}`
+        `    ${chalk209.red(`"${oldSpecifier}"`)} \u2192 ${chalk209.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
 function displayPlan2(plan2) {
   if (plan2.warnings.length > 0) {
-    console.log(chalk207.yellow("\nWarnings:"));
-    for (const w of plan2.warnings) console.log(chalk207.yellow(`  ${w}`));
+    console.log(chalk209.yellow("\nWarnings:"));
+    for (const w of plan2.warnings) console.log(chalk209.yellow(`  ${w}`));
   }
   if (plan2.newDirectories.length > 0) {
-    console.log(chalk207.bold("\nNew directories:"));
+    console.log(chalk209.bold("\nNew directories:"));
     for (const dir of plan2.newDirectories)
-      console.log(chalk207.green(`  ${dir}/`));
+      console.log(chalk209.green(`  ${dir}/`));
   }
   displayMoves(plan2);
   displayRewrites(plan2.rewrites);
   console.log(
-    chalk207.dim(
+    chalk209.dim(
       `
 Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports rewritten`
     )
@@ -29860,18 +30098,18 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 // src/commands/refactor/restructure/executePlan.ts
 import fs38 from "fs";
 import path64 from "path";
-import chalk208 from "chalk";
+import chalk210 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs38.writeFileSync(file, content, "utf8");
     console.log(
-      chalk208.cyan(`  Rewrote imports in ${path64.relative(process.cwd(), file)}`)
+      chalk210.cyan(`  Rewrote imports in ${path64.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs38.mkdirSync(dir, { recursive: true });
-    console.log(chalk208.green(`  Created ${path64.relative(process.cwd(), dir)}/`));
+    console.log(chalk210.green(`  Created ${path64.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
     const targetDir = path64.dirname(move2.to);
@@ -29880,7 +30118,7 @@ function executePlan(plan2) {
     }
     fs38.renameSync(move2.from, move2.to);
     console.log(
-      chalk208.white(
+      chalk210.white(
         `  Moved ${path64.relative(process.cwd(), move2.from)} \u2192 ${path64.relative(process.cwd(), move2.to)}`
       )
     );
@@ -29895,7 +30133,7 @@ function removeEmptyDirectories(dirs) {
     if (entries.length === 0) {
       fs38.rmdirSync(dir);
       console.log(
-        chalk208.dim(
+        chalk210.dim(
           `  Removed empty directory ${path64.relative(process.cwd(), dir)}`
         )
       );
@@ -30028,22 +30266,22 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk209.yellow("No files found matching pattern"));
+    console.log(chalk211.yellow("No files found matching pattern"));
     return;
   }
   const tsConfigPath = findTsConfig(path67.resolve(files[0]));
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
-    console.log(chalk209.green("No restructuring needed"));
+    console.log(chalk211.green("No restructuring needed"));
     return;
   }
   displayPlan2(plan2);
   if (options2.apply) {
-    console.log(chalk209.bold("\nApplying changes..."));
+    console.log(chalk211.bold("\nApplying changes..."));
     executePlan(plan2);
-    console.log(chalk209.green("\nRestructuring complete"));
+    console.log(chalk211.green("\nRestructuring complete"));
   } else {
-    console.log(chalk209.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk211.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -30096,6 +30334,293 @@ async function checkoutOnlySession(number) {
   await done2;
 }
 
+// src/commands/review/highLevel/runHighLevelReview.ts
+import chalk213 from "chalk";
+
+// src/commands/review/fetchPrDiffInfo.ts
+import { execSync as execSync57 } from "child_process";
+function getCurrentBranch3() {
+  return execSync57("git rev-parse --abbrev-ref HEAD", {
+    encoding: "utf8"
+  }).trim();
+}
+function fetchPrDiffInfo() {
+  const { org, repo } = getRepoInfo();
+  const branch2 = getCurrentBranch3();
+  const fields = "number,baseRefName,baseRefOid,headRefName,headRefOid";
+  const raw = execSync57(
+    `gh pr list --state open --head ${branch2} --json ${fields} -R ${org}/${repo}`,
+    {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }
+  );
+  const parsed = JSON.parse(raw);
+  const pr = parsed[0];
+  if (!pr) {
+    console.error(
+      `Error: No open pull request found for branch \`${branch2}\`. Open a PR for this branch before running \`assist review\`.`
+    );
+    process.exit(1);
+  }
+  return {
+    prNumber: pr.number,
+    baseRef: pr.baseRefName,
+    baseSha: pr.baseRefOid,
+    headRef: pr.headRefName,
+    headSha: pr.headRefOid
+  };
+}
+function fetchPrChangedFiles(prNumber) {
+  const { org, repo } = getRepoInfo();
+  const out = execSync57(
+    `gh api repos/${org}/${repo}/pulls/${prNumber}/files --paginate --jq ".[].filename"`,
+    {
+      encoding: "utf8",
+      maxBuffer: 64 * 1024 * 1024
+    }
+  );
+  return out.trim().split("\n").filter(Boolean);
+}
+
+// src/commands/review/highLevel/checkDescriptionLinksIssue.ts
+var ISSUE_URL_PATTERN = /https?:\/\/github\.com\/[\w.-]+\/[\w.-]+\/issues\/\d+/g;
+var CROSS_REPO_PATTERN = /\b[\w.-]+\/[\w.-]+#\d+/g;
+var SAME_REPO_PATTERN2 = /(?<![\w/#-])#\d+\b/g;
+function firstMatch(body, pattern2) {
+  return body.match(pattern2)?.[0] ?? null;
+}
+function checkDescriptionLinksIssue(body) {
+  const reference = firstMatch(body, ISSUE_URL_PATTERN) ?? firstMatch(body, CROSS_REPO_PATTERN) ?? firstMatch(body, SAME_REPO_PATTERN2);
+  if (!reference)
+    return {
+      status: "fail",
+      reason: "no GitHub issue reference (`#123`, `owner/repo#123`, or an issue URL) in the description"
+    };
+  return { status: "pass", reason: `links ${reference}` };
+}
+
+// src/commands/review/highLevel/checkDescriptionSections.ts
+function sectionContent(body, heading2) {
+  const section2 = parsePrBody(body).find(
+    (candidate) => candidate.heading.trim().toLowerCase() === heading2
+  );
+  return section2 ? section2.content.trim() : null;
+}
+function describe5(heading2, content) {
+  if (content === null) return `no \`## ${heading2}\` section`;
+  if (content === "") return `\`## ${heading2}\` is empty`;
+  return null;
+}
+function checkDescriptionSections(body) {
+  const problems = [
+    describe5("What", sectionContent(body, "what")),
+    describe5("Why", sectionContent(body, "why"))
+  ].filter((problem) => problem !== null);
+  if (problems.length > 0)
+    return { status: "fail", reason: problems.join("; ") };
+  const how = sectionContent(body, "how");
+  const optional = how ? ", plus an optional `## How`" : "";
+  return {
+    status: "pass",
+    reason: `\`## What\` and \`## Why\` are both present${optional}`
+  };
+}
+
+// src/commands/review/highLevel/checkDescriptionWordCap.ts
+function checkDescriptionWordCap(body, cap2) {
+  const { prose, code } = countReadingWords(body);
+  const words = prose + code;
+  if (words > cap2)
+    return {
+      status: "fail",
+      reason: `${words} words, ${words - cap2} over the ${cap2}-word cap`
+    };
+  return { status: "pass", reason: `${words} of ${cap2} words` };
+}
+
+// src/commands/review/highLevel/checkUiEvidence.ts
+import { minimatch as minimatch7 } from "minimatch";
+var EVIDENCE_PATTERNS = [
+  /!\[[^\]]*\]\([^)]+\)/g,
+  /<(?:img|video)\b[^>]*>/gi,
+  /https?:\/\/github\.com\/user-attachments\/assets\/\S+/g,
+  /https?:\/\/\S+\.(?:png|jpe?g|gif|webp|avif|svg|mp4|mov|webm)\b/gi
+];
+function countEvidence(body) {
+  return EVIDENCE_PATTERNS.reduce(
+    (total, pattern2) => total + (body.match(pattern2)?.length ?? 0),
+    0
+  );
+}
+function plural(count8, noun) {
+  return `${count8} ${noun}${count8 === 1 ? "" : "s"}`;
+}
+function checkUiEvidence(body, changedFiles2, uiPaths) {
+  if (uiPaths.length === 0)
+    return {
+      status: "pass",
+      reason: "review.highLevel.uiPaths is unset, so no UI evidence is required"
+    };
+  const touched = changedFiles2.filter(
+    (file) => uiPaths.some((glob) => minimatch7(file, glob))
+  );
+  if (touched.length === 0)
+    return {
+      status: "pass",
+      reason: "no changed file matches review.highLevel.uiPaths"
+    };
+  const evidence = countEvidence(body);
+  if (evidence === 0)
+    return {
+      status: "fail",
+      reason: `${plural(touched.length, "UI file")} changed (${touched[0]}) but no screenshot or video in the description`
+    };
+  const shown = evidence === 1 ? "1 screenshot or video" : `${evidence} screenshots or videos`;
+  return {
+    status: "pass",
+    reason: `${shown} for ${plural(touched.length, "changed UI file")}`
+  };
+}
+
+// src/commands/review/highLevel/highLevelChecklist.ts
+var highLevelChecklist = [
+  {
+    id: "description-what-why",
+    kind: "deterministic",
+    title: "Description has a What and a Why",
+    backing: "The PR body's `## What` and `## Why` sections"
+  },
+  {
+    id: "description-word-cap",
+    kind: "deterministic",
+    title: "Description is under the word cap",
+    backing: "The PR body's word count against review.highLevel.descriptionWordCap"
+  },
+  {
+    id: "description-links-issue",
+    kind: "deterministic",
+    title: "Description links the GitHub issue the PR resolves",
+    backing: "GitHub issue references in the PR body"
+  },
+  {
+    id: "ui-evidence",
+    kind: "deterministic",
+    title: "UI changes are evidenced by a screenshot or video",
+    backing: "Images and videos in the PR body, when a changed file matches review.highLevel.uiPaths"
+  },
+  {
+    id: "structure-sensible",
+    kind: "manual",
+    title: "The structure of the change is sensible",
+    backing: "The changed-file tree with add/delete/modify counts and per-file GitHub diff links"
+  },
+  {
+    id: "critical-diffs-correct",
+    kind: "manual",
+    title: "The critical-file diffs are correct",
+    backing: "Full diffs of files matching review.highLevel.criticalPaths"
+  },
+  {
+    id: "backend-pr-linked",
+    kind: "manual",
+    title: "The backend PR is linked, if the change needs backend work",
+    backing: "The PR body"
+  }
+];
+
+// src/commands/review/highLevel/evaluateHighLevelChecks.ts
+var evaluators = {
+  "description-what-why": (subject) => checkDescriptionSections(subject.body),
+  "description-word-cap": (subject) => checkDescriptionWordCap(subject.body, subject.config.descriptionWordCap),
+  "description-links-issue": (subject) => checkDescriptionLinksIssue(subject.body),
+  "ui-evidence": (subject) => checkUiEvidence(subject.body, subject.changedFiles, subject.config.uiPaths)
+};
+function evaluateHighLevelChecks(subject) {
+  return highLevelChecklist.map((check2) => {
+    if (check2.kind === "manual")
+      return { ...check2, status: "manual", reason: check2.backing };
+    return { ...check2, ...evaluators[check2.id](subject) };
+  });
+}
+
+// src/commands/review/highLevel/formatHighLevelChecklist.ts
+import chalk212 from "chalk";
+var MARKERS = {
+  pass: () => chalk212.green("\u2714"),
+  fail: () => chalk212.red("\u2718"),
+  manual: () => chalk212.yellow("\u25A1")
+};
+function formatCheck(check2) {
+  const title = check2.status === "fail" ? chalk212.red(check2.title) : chalk212.bold(check2.title);
+  return `  ${MARKERS[check2.status]()} ${title}
+      ${chalk212.dim(check2.reason)}`;
+}
+function formatGroup(heading2, checks2) {
+  if (checks2.length === 0) return [];
+  return ["", chalk212.bold.underline(heading2), ...checks2.map(formatCheck)];
+}
+function formatHighLevelChecklist(checks2) {
+  const deterministic = checks2.filter(
+    (check2) => check2.kind === "deterministic"
+  );
+  const failed2 = deterministic.filter(
+    (check2) => check2.status === "fail"
+  ).length;
+  const summary = failed2 === 0 ? chalk212.green(`All ${deterministic.length} deterministic checks pass`) : chalk212.red(
+    `${failed2} of ${deterministic.length} deterministic checks fail`
+  );
+  return [
+    ...formatGroup("Deterministic", deterministic),
+    ...formatGroup(
+      "Manual",
+      checks2.filter((check2) => check2.kind === "manual")
+    ),
+    "",
+    summary
+  ].join("\n");
+}
+
+// src/commands/review/highLevel/resolveHighLevelConfig.ts
+var DEFAULT_DESCRIPTION_WORD_CAP = 300;
+function resolveHighLevelConfig(config) {
+  const highLevel = config.review?.highLevel;
+  return {
+    criticalPaths: highLevel?.criticalPaths ?? [],
+    uiPaths: highLevel?.uiPaths ?? [],
+    descriptionWordCap: highLevel?.descriptionWordCap ?? DEFAULT_DESCRIPTION_WORD_CAP
+  };
+}
+
+// src/commands/review/highLevel/runHighLevelReview.ts
+function resolvePrNumber2(number) {
+  if (number === void 0) return getCurrentPrNumber();
+  const parsed = Number(number);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    console.error(`Error: \`${number}\` is not a pull request number.`);
+    process.exit(1);
+  }
+  return parsed;
+}
+function runHighLevelReview(number) {
+  const prNumber = resolvePrNumber2(number);
+  const { org, repo } = getRepoInfo();
+  const config = resolveHighLevelConfig(loadConfig());
+  const body = fetchPrBody(prNumber, { org, repo });
+  const changedFiles2 = fetchPrChangedFiles(prNumber);
+  const checks2 = evaluateHighLevelChecks({ body, changedFiles: changedFiles2, config });
+  console.log(
+    chalk213.bold(`High-level review of ${org}/${repo}#${prNumber}`),
+    chalk213.dim(`\xB7 ${changedFiles2.length} changed files`)
+  );
+  console.log(formatHighLevelChecklist(checks2));
+  console.log(
+    chalk213.dim(
+      "\nManual items are for the reviewer to judge; see docs/high-level-review.md."
+    )
+  );
+}
+
 // src/commands/review/annotateDiffWithLineNumbers.ts
 var FILE_HEADER2 = /^\+\+\+ (?:b\/)?(.+)$/;
 var HUNK_HEADER2 = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
@@ -30229,9 +30754,9 @@ function buildReviewPaths(repoRoot2, key) {
 }
 
 // src/commands/review/fetchExistingComments.ts
-import { execSync as execSync56 } from "child_process";
+import { execSync as execSync58 } from "child_process";
 function fetchRawComments(org, repo, prNumber) {
-  const out = execSync56(
+  const out = execSync58(
     `gh api --paginate repos/${org}/${repo}/pulls/${prNumber}/comments`,
     { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 }
   );
@@ -30262,14 +30787,14 @@ function fetchExistingComments() {
 }
 
 // src/commands/review/gatherContext.ts
-import { execSync as execSync59 } from "child_process";
+import { execSync as execSync60 } from "child_process";
 
 // src/commands/review/fetchPrDiff.ts
-import { execSync as execSync57 } from "child_process";
+import { execSync as execSync59 } from "child_process";
 function fetchPrDiff(prNumber, baseSha, headSha) {
   const { org, repo } = getRepoInfo();
   try {
-    return execSync57(`gh pr diff ${prNumber} -R ${org}/${repo}`, {
+    return execSync59(`gh pr diff ${prNumber} -R ${org}/${repo}`, {
       encoding: "utf8",
       maxBuffer: 256 * 1024 * 1024,
       stdio: ["ignore", "pipe", "pipe"]
@@ -30284,68 +30809,22 @@ function isDiffTooLarge(error) {
 }
 function fetchDiffViaGit(baseSha, headSha) {
   try {
-    execSync57(`git fetch origin ${baseSha} ${headSha}`, { stdio: "ignore" });
+    execSync59(`git fetch origin ${baseSha} ${headSha}`, { stdio: "ignore" });
   } catch {
   }
-  return execSync57(`git diff ${baseSha}...${headSha}`, {
+  return execSync59(`git diff ${baseSha}...${headSha}`, {
     encoding: "utf8",
     maxBuffer: 256 * 1024 * 1024
   });
 }
 
-// src/commands/review/fetchPrDiffInfo.ts
-import { execSync as execSync58 } from "child_process";
-function getCurrentBranch3() {
-  return execSync58("git rev-parse --abbrev-ref HEAD", {
-    encoding: "utf8"
-  }).trim();
-}
-function fetchPrDiffInfo() {
-  const { org, repo } = getRepoInfo();
-  const branch2 = getCurrentBranch3();
-  const fields = "number,baseRefName,baseRefOid,headRefName,headRefOid";
-  const raw = execSync58(
-    `gh pr list --state open --head ${branch2} --json ${fields} -R ${org}/${repo}`,
-    {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"]
-    }
-  );
-  const parsed = JSON.parse(raw);
-  const pr = parsed[0];
-  if (!pr) {
-    console.error(
-      `Error: No open pull request found for branch \`${branch2}\`. Open a PR for this branch before running \`assist review\`.`
-    );
-    process.exit(1);
-  }
-  return {
-    prNumber: pr.number,
-    baseRef: pr.baseRefName,
-    baseSha: pr.baseRefOid,
-    headRef: pr.headRefName,
-    headSha: pr.headRefOid
-  };
-}
-function fetchPrChangedFiles(prNumber) {
-  const { org, repo } = getRepoInfo();
-  const out = execSync58(
-    `gh api repos/${org}/${repo}/pulls/${prNumber}/files --paginate --jq ".[].filename"`,
-    {
-      encoding: "utf8",
-      maxBuffer: 64 * 1024 * 1024
-    }
-  );
-  return out.trim().split("\n").filter(Boolean);
-}
-
 // src/commands/review/gatherContext.ts
 function gatherContext() {
-  const branch2 = execSync59("git rev-parse --abbrev-ref HEAD", {
+  const branch2 = execSync60("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf8"
   }).trim();
-  const sha = execSync59("git rev-parse HEAD", { encoding: "utf8" }).trim();
-  const shortSha = execSync59("git rev-parse --short=7 HEAD", {
+  const sha = execSync60("git rev-parse HEAD", { encoding: "utf8" }).trim();
+  const shortSha = execSync60("git rev-parse --short=7 HEAD", {
     encoding: "utf8"
   }).trim();
   const prInfo = fetchPrDiffInfo();
@@ -30704,18 +31183,18 @@ function partitionFindingsByDiff(findings, index3) {
 }
 
 // src/commands/review/warnOutOfDiff.ts
-import chalk210 from "chalk";
+import chalk214 from "chalk";
 function warnOutOfDiff(outOfDiff) {
   if (outOfDiff.length === 0) return;
   console.warn(
-    chalk210.yellow(
+    chalk214.yellow(
       `Moved ${outOfDiff.length} finding(s) whose lines fall outside the PR diff into the review body (GitHub cannot anchor a comment on these):`
     )
   );
   for (const finding of outOfDiff) {
     const range = finding.startLine !== void 0 ? `${finding.startLine}-${finding.line}` : `${finding.line}`;
     console.warn(
-      `  ${chalk210.yellow("\xB7")} ${finding.title} ${chalk210.dim(
+      `  ${chalk214.yellow("\xB7")} ${finding.title} ${chalk214.dim(
         `(${finding.file}:${range})`
       )}`
     );
@@ -30739,18 +31218,18 @@ function selectInDiffFindings(lineBound, prDiff) {
 }
 
 // src/commands/review/warnUnlocated.ts
-import chalk211 from "chalk";
+import chalk215 from "chalk";
 function warnUnlocated(unlocated) {
   if (unlocated.length === 0) return;
   console.warn(
-    chalk211.yellow(
+    chalk215.yellow(
       `Moved ${unlocated.length} finding(s) without a parseable file:line into the review body:`
     )
   );
   for (const finding of unlocated) {
-    const where = finding.location || chalk211.dim("missing");
+    const where = finding.location || chalk215.dim("missing");
     console.warn(
-      `  ${chalk211.yellow("\xB7")} ${finding.title} ${chalk211.dim(`(${where})`)}`
+      `  ${chalk215.yellow("\xB7")} ${finding.title} ${chalk215.dim(`(${where})`)}`
     );
   }
 }
@@ -31340,9 +31819,9 @@ import { writeFileSync as writeFileSync39 } from "fs";
 // src/commands/review/finaliseReviewerSpinner.ts
 var SUMMARY_MAX_LEN = 80;
 function summariseStderr(stderr) {
-  const firstLine2 = stderr.split(/\r?\n/).find((l) => l.trim().length > 0);
-  if (!firstLine2) return "";
-  const trimmed = firstLine2.trim();
+  const firstLine3 = stderr.split(/\r?\n/).find((l) => l.trim().length > 0);
+  if (!firstLine3) return "";
+  const trimmed = firstLine3.trim();
   return trimmed.length > SUMMARY_MAX_LEN ? `${trimmed.slice(0, SUMMARY_MAX_LEN - 1)}\u2026` : trimmed;
 }
 function finaliseReviewerSpinner(spinner, outcome) {
@@ -32050,14 +32529,8 @@ async function reviewPr(repoRoot2, options2) {
   console.log(`Done. Review folder: ${paths.reviewDir}`);
 }
 
-// src/commands/review/review.ts
-function resolveRepoRoot() {
-  const repoRoot2 = findRepoRoot(process.cwd());
-  if (repoRoot2) return repoRoot2;
-  console.error("Error: not inside a git repository.");
-  process.exit(1);
-}
-function validateOptions(options2) {
+// src/commands/review/validateReviewOptions.ts
+function validateReviewOptions(options2) {
   if (options2.apply && options2.refine) {
     console.error("Error: --apply cannot be combined with --refine.");
     process.exit(1);
@@ -32069,6 +32542,7 @@ function validateOptions(options2) {
     process.exit(1);
   }
   validateCheckoutOnly(options2);
+  validateHighLevel(options2);
 }
 function validateCheckoutOnly(options2) {
   if (!options2.checkoutOnly) return;
@@ -32083,13 +32557,31 @@ function validateCheckoutOnly(options2) {
     process.exit(1);
   }
 }
+function validateHighLevel(options2) {
+  if (!options2.highLevel) return;
+  if (options2.refine || options2.apply || options2.backlog || options2.submit || options2.checkoutOnly) {
+    console.error(
+      "Error: --high-level cannot be combined with --refine, --apply, --backlog, --submit or --checkout-only."
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/review/review.ts
+function resolveRepoRoot() {
+  const repoRoot2 = findRepoRoot(process.cwd());
+  if (repoRoot2) return repoRoot2;
+  console.error("Error: not inside a git repository.");
+  process.exit(1);
+}
 async function review(options2 = {}) {
-  validateOptions(options2);
+  validateReviewOptions(options2);
   startReviewLog();
   const invokedIn = resolveRepoRoot();
   if (options2.checkoutOnly && options2.number)
     return checkoutOnlySession(options2.number);
   emitActivity({ kind: "command", name: "review" });
+  if (options2.highLevel) return runHighLevelReview(options2.number);
   if (!options2.number) return reviewPr(invokedIn, options2);
   await checkoutPr(options2.number);
   return reviewPr(resolveRepoRoot(), options2);
@@ -32123,6 +32615,9 @@ function registerReview(program2) {
   ).option(
     "--checkout-only",
     "Check the PR out and start an idle interactive Claude session in the checkout tree instead of reviewing; requires a PR number and cannot be combined with --refine, --apply, --backlog or --submit"
+  ).option(
+    "--high-level",
+    "Skip the LLM review; evaluate the high-level review checklist against the PR description and changed files and print each item as pass, fail or manual. Nothing is posted to GitHub; cannot be combined with --refine, --apply, --backlog, --submit or --checkout-only"
   ).option(
     "--address-comments",
     "After posting and submitting the review, start an Address Comments session (assist review-pr-comments <n>) for the PR; no-op when nothing was posted or the review was not submitted, and only inside an assist session"
@@ -32145,7 +32640,7 @@ function registerReview(program2) {
 // src/commands/rules/addRule.ts
 import { existsSync as existsSync68, readFileSync as readFileSync52, writeFileSync as writeFileSync41 } from "fs";
 import path72 from "path";
-import chalk212 from "chalk";
+import chalk216 from "chalk";
 
 // src/commands/rules/insertRuleBullet.ts
 function ruleBullet({ code, title, text: text18 }) {
@@ -32281,7 +32776,7 @@ function read2(file) {
 function addRule(text18, options2) {
   const rule = text18.trim();
   if (rule === "") {
-    console.error(chalk212.red("Rule text is required"));
+    console.error(chalk216.red("Rule text is required"));
     process.exitCode = 1;
     return;
   }
@@ -32299,13 +32794,13 @@ function addRule(text18, options2) {
   );
   updateScopedRulesIndex(root);
   console.log(
-    `Added ${chalk212.cyan(code)} to ${path72.relative(process.cwd(), target) || target}`
+    `Added ${chalk216.cyan(code)} to ${path72.relative(process.cwd(), target) || target}`
   );
 }
 
 // src/commands/rules/indexRules.ts
 import path73 from "path";
-import chalk213 from "chalk";
+import chalk217 from "chalk";
 function indexRules() {
   const startDir = scopeDirectory(process.cwd());
   const root = findRepoRoot(startDir) ?? startDir;
@@ -32313,24 +32808,24 @@ function indexRules() {
   const rootFile = path73.relative(process.cwd(), path73.join(root, "CLAUDE.md"));
   if (directories.length === 0) {
     console.log(
-      chalk213.gray(`No directories carry their own \`## Rules\` under ${root}`)
+      chalk217.gray(`No directories carry their own \`## Rules\` under ${root}`)
     );
     return;
   }
   console.log(`Recorded in ${rootFile || "CLAUDE.md"}`);
   for (const directory of directories)
-    console.log(`  ${chalk213.cyan(directory)}`);
+    console.log(`  ${chalk217.cyan(directory)}`);
 }
 
 // src/commands/rules/listRules.ts
 import path74 from "path";
-import chalk214 from "chalk";
+import chalk218 from "chalk";
 function listRules(target, options2 = {}) {
   const resolved = path74.resolve(target ?? process.cwd());
   const rules3 = readScopedRules(resolved);
   if (rules3.length === 0) {
     const label2 = path74.relative(process.cwd(), resolved) || ".";
-    console.log(chalk214.gray(`No rules in scope for ${label2}`));
+    console.log(chalk218.gray(`No rules in scope for ${label2}`));
     return;
   }
   const base = findRepoRoot(scopeDirectory(resolved));
@@ -32340,14 +32835,14 @@ function listRules(target, options2 = {}) {
     if (rule.source !== shown) {
       shown = rule.source;
       console.log(
-        chalk214.dim(base ? path74.relative(base, rule.source) : rule.source)
+        chalk218.dim(base ? path74.relative(base, rule.source) : rule.source)
       );
     }
     console.log(
-      `  ${chalk214.cyan(rule.code.padEnd(width))}  ${rule.title ?? rule.text}`
+      `  ${chalk218.cyan(rule.code.padEnd(width))}  ${rule.title ?? rule.text}`
     );
     if (options2.full && rule.title)
-      console.log(`  ${" ".repeat(width)}  ${chalk214.dim(rule.text)}`);
+      console.log(`  ${" ".repeat(width)}  ${chalk218.dim(rule.text)}`);
   }
 }
 
@@ -32376,7 +32871,7 @@ function registerRules(program2) {
 }
 
 // src/commands/seq/seqAuth.ts
-import chalk216 from "chalk";
+import chalk220 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -32405,10 +32900,10 @@ function setDefaultConnection(name) {
 }
 
 // src/shared/assertUniqueName.ts
-import chalk215 from "chalk";
+import chalk219 from "chalk";
 function assertUniqueName(existingNames, name) {
   if (existingNames.includes(name)) {
-    console.error(chalk215.red(`Connection "${name}" already exists.`));
+    console.error(chalk219.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
 }
@@ -32426,16 +32921,16 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk216.bold(c.name)}  ${c.url}`,
+  format: (c) => `${chalk220.bold(c.name)}  ${c.url}`,
   promptNew: promptConnection2,
   onFirst: (c) => setDefaultConnection(c.name)
 });
 
 // src/commands/seq/seqQuery.ts
-import chalk220 from "chalk";
+import chalk224 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
-import chalk217 from "chalk";
+import chalk221 from "chalk";
 async function fetchSeq(conn, path91, params) {
   const url = `${conn.url}${path91}?${params}`;
   const response = await fetch(url, {
@@ -32446,7 +32941,7 @@ async function fetchSeq(conn, path91, params) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk217.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk221.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   return response;
@@ -32505,23 +33000,23 @@ async function fetchSeqEvents(conn, params) {
 }
 
 // src/commands/seq/formatEvent.ts
-import chalk218 from "chalk";
+import chalk222 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk218.bgRed.white;
+      return chalk222.bgRed.white;
     case "Error":
-      return chalk218.red;
+      return chalk222.red;
     case "Warning":
-      return chalk218.yellow;
+      return chalk222.yellow;
     case "Information":
-      return chalk218.cyan;
+      return chalk222.cyan;
     case "Debug":
-      return chalk218.gray;
+      return chalk222.gray;
     case "Verbose":
-      return chalk218.dim;
+      return chalk222.dim;
     default:
-      return chalk218.white;
+      return chalk222.white;
   }
 }
 function levelAbbrev(level) {
@@ -32562,12 +33057,12 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk218.dim(formatTimestamp(event.Timestamp));
+  const ts8 = chalk222.dim(formatTimestamp(event.Timestamp));
   const msg = renderMessage(event);
   const lines2 = [`${ts8} ${color(`[${abbrev}]`)} ${msg}`];
   if (event.Exception) {
     for (const line of event.Exception.split("\n")) {
-      lines2.push(chalk218.red(`  ${line}`));
+      lines2.push(chalk222.red(`  ${line}`));
     }
   }
   return lines2.join("\n");
@@ -32600,11 +33095,11 @@ function rejectTimestampFilter(filter) {
 }
 
 // src/shared/resolveNamedConnection.ts
-import chalk219 from "chalk";
+import chalk223 from "chalk";
 function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
   if (connections.length === 0) {
     console.error(
-      chalk219.red(
+      chalk223.red(
         `No ${kind} connections configured. Run '${authCommand}' first.`
       )
     );
@@ -32613,7 +33108,7 @@ function resolveNamedConnection(connections, requested, defaultName, kind, authC
   const target = requested ?? defaultName ?? connections[0].name;
   const connection = connections.find((c) => c.name === target);
   if (!connection) {
-    console.error(chalk219.red(`${kind} connection "${target}" not found.`));
+    console.error(chalk223.red(`${kind} connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -32642,7 +33137,7 @@ async function seqQuery(filter, options2) {
     new URLSearchParams({ filter, count: String(count8) })
   );
   if (events.length === 0) {
-    console.log(chalk220.yellow("No events found."));
+    console.log(chalk224.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -32653,11 +33148,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk220.dim(`
+  console.log(chalk224.dim(`
 ${events.length} events`));
   if (events.length >= count8) {
     console.log(
-      chalk220.yellow(
+      chalk224.yellow(
         `Results limited to ${count8}. Use --count to retrieve more.`
       )
     );
@@ -32665,10 +33160,10 @@ ${events.length} events`));
 }
 
 // src/shared/setNamedDefaultConnection.ts
-import chalk221 from "chalk";
+import chalk225 from "chalk";
 function setNamedDefaultConnection(connections, name, setDefault, kind) {
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk221.red(`Connection "${name}" not found.`));
+    console.error(chalk225.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefault(name);
@@ -32817,7 +33312,7 @@ function registerSlack(program2) {
 }
 
 // src/commands/sql/sqlAuth.ts
-import chalk223 from "chalk";
+import chalk227 from "chalk";
 
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
@@ -32846,7 +33341,7 @@ function setDefaultConnection2(name) {
 }
 
 // src/commands/sql/promptConnection.ts
-import chalk222 from "chalk";
+import chalk226 from "chalk";
 async function promptConnection3(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   assertUniqueName(existingNames, name);
@@ -32854,7 +33349,7 @@ async function promptConnection3(existingNames) {
   const portStr = await promptInput("port", "Port:", "1433");
   const port = Number.parseInt(portStr, 10);
   if (!Number.isFinite(port)) {
-    console.error(chalk222.red(`Invalid port "${portStr}".`));
+    console.error(chalk226.red(`Invalid port "${portStr}".`));
     process.exit(1);
   }
   const user = await promptInput("user", "User:");
@@ -32867,13 +33362,13 @@ async function promptConnection3(existingNames) {
 var sqlAuth = createConnectionAuth({
   load: loadConnections3,
   save: saveConnections3,
-  format: (c) => `${chalk223.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
+  format: (c) => `${chalk227.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
   promptNew: promptConnection3,
   onFirst: (c) => setDefaultConnection2(c.name)
 });
 
 // src/commands/sql/printTable.ts
-import chalk224 from "chalk";
+import chalk228 from "chalk";
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   if (value instanceof Date) return value.toISOString();
@@ -32882,7 +33377,7 @@ function formatCell(value) {
 }
 function printTable(rows) {
   if (rows.length === 0) {
-    console.log(chalk224.yellow("(no rows)"));
+    console.log(chalk228.yellow("(no rows)"));
     return;
   }
   const columns = Object.keys(rows[0]);
@@ -32890,13 +33385,13 @@ function printTable(rows) {
     (col) => Math.max(col.length, ...rows.map((r) => formatCell(r[col]).length))
   );
   const header = columns.map((c, i) => c.padEnd(widths[i])).join("  ");
-  console.log(chalk224.dim(header));
-  console.log(chalk224.dim("-".repeat(header.length)));
+  console.log(chalk228.dim(header));
+  console.log(chalk228.dim("-".repeat(header.length)));
   for (const row of rows) {
     const line = columns.map((c, i) => formatCell(row[c]).padEnd(widths[i])).join("  ");
     console.log(line);
   }
-  console.log(chalk224.dim(`
+  console.log(chalk228.dim(`
 ${rows.length} row${rows.length === 1 ? "" : "s"}`));
 }
 
@@ -32956,7 +33451,7 @@ async function sqlColumns(table, connectionName) {
 }
 
 // src/commands/sql/sqlMutate.ts
-import chalk225 from "chalk";
+import chalk229 from "chalk";
 
 // src/commands/sql/isMutation.ts
 var MUTATION_KEYWORDS = [
@@ -32990,7 +33485,7 @@ function isMutation(sql29) {
 async function sqlMutate(query, connectionName) {
   if (!isMutation(query)) {
     console.error(
-      chalk225.red(
+      chalk229.red(
         "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
       )
     );
@@ -33000,18 +33495,18 @@ async function sqlMutate(query, connectionName) {
   const pool = await sqlConnect(conn);
   try {
     const result = await pool.request().query(query);
-    console.log(chalk225.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
+    console.log(chalk229.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
   } finally {
     await pool.close();
   }
 }
 
 // src/commands/sql/sqlQuery.ts
-import chalk226 from "chalk";
+import chalk230 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk226.red(
+      chalk230.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -33026,7 +33521,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk226.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk230.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -33400,7 +33895,7 @@ function syncPi(claudeDir, options2) {
 // src/commands/sync/syncSettings.ts
 import * as fs48 from "fs";
 import * as path84 from "path";
-import chalk227 from "chalk";
+import chalk231 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path84.join(claudeDir, "settings.json");
   const target = path84.join(targetBase, "settings.json");
@@ -33419,7 +33914,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk227.yellow(
+          chalk231.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
@@ -33427,7 +33922,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
         printDiff(targetContent, mergedContent);
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk227.red("Overwrite existing settings.json?"),
+          chalk231.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -34296,7 +34791,7 @@ import { mkdirSync as mkdirSync31 } from "fs";
 import { join as join93 } from "path";
 
 // src/commands/voice/checkLockFile.ts
-import { execSync as execSync60 } from "child_process";
+import { execSync as execSync61 } from "child_process";
 import { existsSync as existsSync78, mkdirSync as mkdirSync30, readFileSync as readFileSync58, writeFileSync as writeFileSync48 } from "fs";
 import { join as join92 } from "path";
 function isProcessAlive2(pid) {
@@ -34325,7 +34820,7 @@ function bootstrapVenv() {
   if (existsSync78(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
-  execSync60(
+  execSync61(
     `uv sync --project "${pythonDir}" --extra runtime --no-install-project`,
     {
       stdio: "inherit",
@@ -34946,11 +35441,11 @@ function runCommandToCompletion(command, args, env, cwd, quiet) {
 }
 
 // src/commands/run/runPreCommands.ts
-import { execSync as execSync61 } from "child_process";
+import { execSync as execSync62 } from "child_process";
 function runPreCommands(pre, cwd) {
   for (const cmd of pre) {
     try {
-      execSync61(cmd, { stdio: "inherit", cwd });
+      execSync62(cmd, { stdio: "inherit", cwd });
     } catch (error) {
       const code = error && typeof error === "object" && "status" in error ? error.status : 1;
       process.exit(code);
@@ -35169,7 +35664,7 @@ function registerWatch(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk228 from "chalk";
+import chalk232 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
 import { createServer as createServer3 } from "http";
@@ -35300,13 +35795,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk228.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk232.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk228.white("http://localhost:14523/callback\n"));
-  console.log(chalk228.blue("Opening browser for authorization..."));
-  console.log(chalk228.dim("Waiting for authorization callback..."));
+  console.log(chalk232.white("http://localhost:14523/callback\n"));
+  console.log(chalk232.blue("Opening browser for authorization..."));
+  console.log(chalk232.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk228.dim("Exchanging code for tokens..."));
+  console.log(chalk232.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -35322,7 +35817,7 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk228.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk232.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
@@ -35677,11 +36172,11 @@ function registerRun(program2) {
 }
 
 // src/commands/screenshot/index.ts
-import { execSync as execSync62 } from "child_process";
+import { execSync as execSync63 } from "child_process";
 import { existsSync as existsSync85, mkdirSync as mkdirSync34, unlinkSync as unlinkSync22, writeFileSync as writeFileSync51 } from "fs";
 import { tmpdir as tmpdir9 } from "os";
 import { join as join100, resolve as resolve21 } from "path";
-import chalk229 from "chalk";
+import chalk233 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -35820,7 +36315,7 @@ function runPowerShellScript(processName, outputPath) {
   const scriptPath = join100(tmpdir9(), `assist-screenshot-${Date.now()}.ps1`);
   writeFileSync51(scriptPath, captureWindowPs1, "utf8");
   try {
-    execSync62(
+    execSync63(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
       { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" }
     );
@@ -35832,13 +36327,13 @@ function screenshot(processName) {
   const config = loadConfig();
   const outputDir = resolve21(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk229.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk233.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk229.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk233.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk229.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk233.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
@@ -41800,7 +42295,7 @@ async function renameSession(title) {
 
 // src/commands/sessions/summarise/index.ts
 import * as fs57 from "fs";
-import chalk230 from "chalk";
+import chalk234 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
 import * as fs56 from "fs";
@@ -41859,22 +42354,22 @@ ${firstMessage}`);
 async function summarise2(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk230.yellow("No sessions found."));
+    console.log(chalk234.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk230.green("All sessions already summarised."));
+    console.log(chalk234.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk230.cyan(
+    chalk234.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk230.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk230.yellow(`, ${failed2} skipped`) : "")
+    chalk234.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk234.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
@@ -41894,16 +42389,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk230.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk234.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk230.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk234.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk230.yellow("skip")}
+      process.stdout.write(` ${chalk234.yellow("skip")}
 `);
     }
   }
@@ -41930,7 +42425,7 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk232 from "chalk";
+import chalk236 from "chalk";
 
 // src/shared/contextLevel.ts
 function contextLevel(pct) {
@@ -41940,7 +42435,7 @@ function contextLevel(pct) {
 }
 
 // src/commands/buildLimitsSegment.ts
-import chalk231 from "chalk";
+import chalk235 from "chalk";
 
 // src/shared/rateLimitLevel.ts
 var FIVE_HOUR_SECONDS = 5 * 3600;
@@ -41978,9 +42473,9 @@ function rateLimitLevel(pct, resetsAt, windowSeconds, now) {
 
 // src/commands/buildLimitsSegment.ts
 var LEVEL_COLOR = {
-  ok: chalk231.green,
-  warn: chalk231.yellow,
-  over: chalk231.red
+  ok: chalk235.green,
+  warn: chalk235.yellow,
+  over: chalk235.red
 };
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel, now) {
   const level = rateLimitLevel(pct, resetsAt, windowSeconds, now);
@@ -42076,7 +42571,7 @@ async function relayUsage(claudeSessionId, transcriptPath2, usedPct) {
 }
 
 // src/commands/statusLine.ts
-chalk232.level = 3;
+chalk236.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
@@ -42084,9 +42579,9 @@ function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
   switch (contextLevel(pct)) {
     case "red":
-      return chalk232.red(label2);
+      return chalk236.red(label2);
     case "yellow":
-      return chalk232.yellow(label2);
+      return chalk236.yellow(label2);
     default:
       return label2;
   }
@@ -42099,7 +42594,7 @@ async function statusLine() {
   const usedPct = data.context_window.used_percentage ?? 0;
   const dir = data.workspace?.current_dir ?? data.cwd;
   const branch2 = dir ? readGitBranch(toGitCwd(dir)) : null;
-  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk232.cyan(branch2)} | ` : "";
+  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk236.cyan(branch2)} | ` : "";
   console.log(
     `${branchSegment}${model} | Tokens - ${formatNumber(totalIn)} \u2191 : ${formatNumber(totalOut)} \u2193 | Context - ${colorizePercent(usedPct)}${buildLimitsSegment(data.rate_limits)}`
   );
@@ -42112,7 +42607,7 @@ async function statusLine() {
 }
 
 // src/commands/update.ts
-import { execSync as execSync63 } from "child_process";
+import { execSync as execSync64 } from "child_process";
 import * as path90 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
@@ -42136,7 +42631,7 @@ function isGlobalNpmInstall(dir) {
     if (resolved.split(path90.sep).includes("node_modules")) {
       return true;
     }
-    const globalPrefix = execSync63("npm prefix -g", { stdio: "pipe" }).toString().trim();
+    const globalPrefix = execSync64("npm prefix -g", { stdio: "pipe" }).toString().trim();
     return resolved.toLowerCase().startsWith(path90.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
@@ -42147,18 +42642,18 @@ async function update2() {
   console.log(`Assist is installed at: ${installDir}`);
   if (isGitRepo(installDir)) {
     console.log("Detected git repo installation, pulling latest...");
-    execSync63("git pull", { cwd: installDir, stdio: "inherit" });
+    execSync64("git pull", { cwd: installDir, stdio: "inherit" });
     console.log("Installing dependencies...");
-    execSync63("npm i", { cwd: installDir, stdio: "inherit" });
+    execSync64("npm i", { cwd: installDir, stdio: "inherit" });
     console.log("Building...");
-    execSync63("npm run build", { cwd: installDir, stdio: "inherit" });
+    execSync64("npm run build", { cwd: installDir, stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync63("assist sync", { stdio: "inherit" });
+    execSync64("assist sync", { stdio: "inherit" });
   } else if (isGlobalNpmInstall(installDir)) {
     console.log("Detected global npm installation, updating...");
-    execSync63("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
+    execSync64("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync63("assist sync", { stdio: "inherit" });
+    execSync64("assist sync", { stdio: "inherit" });
   } else {
     console.error(
       "Could not determine installation method. Expected a git repo or global npm install."
@@ -42169,10 +42664,10 @@ async function update2() {
 }
 
 // src/reportCliError.ts
-import chalk233 from "chalk";
+import chalk237 from "chalk";
 function reportCliError(error) {
   if (error instanceof InvalidItemIdError || error instanceof AmbiguousRepoConfigError || error instanceof UnknownRepoConfigError || error instanceof MissingRunCwdError || error instanceof MiroExtractError) {
-    console.error(chalk233.red(error.message));
+    console.error(chalk237.red(error.message));
   } else {
     console.error(error);
   }