@qwen-code/qwen-code 0.21.7 → 0.21.8

package/chunks/{chunk-KKJJB5X6.js → chunk-7VUERJHS.js}

@@ -2,14 +2,15 @@
 "use strict";
 import {
   serveCommand
-} from "./chunk-CB2464BK.js";
+} from "./chunk-HWX5HPUG.js";
 import {
   listCommand
-} from "./chunk-FPM27XN4.js";
+} from "./chunk-EIVICVHM.js";
 import {
   getErrorMessage as getErrorMessage2
-} from "./chunk-TDXGKHDN.js";
+} from "./chunk-IYES5WOT.js";
 import {
+  OBSERVED_CONTACT_MAX_FRESH_WITHIN_SECONDS,
   ObservedChannelContactStore
 } from "./chunk-OWMAZHIX.js";
 import {
@@ -28,7 +29,7 @@ import {
   collectProviderModelsForProtocol,
   getAuthTypeFromEnv,
   resolveCliGenerationConfig
-} from "./chunk-CSZEXZBE.js";
+} from "./chunk-GBDINRIL.js";
 import {
   resolvePath
 } from "./chunk-AOHJKPKL.js";
@@ -51,17 +52,17 @@ import {
   registerToolCallDispatch,
   selectFirstModel,
   sessionsPath
-} from "./chunk-EUQTXRKZ.js";
+} from "./chunk-E4ZBKMSF.js";
 import {
   getExtensionManager,
   requestChoicePluginNonInteractive,
   requestConsentNonInteractive,
   requestConsentOrFail,
   resolveExtensionCommandScope
-} from "./chunk-OHJLEW5J.js";
+} from "./chunk-QQWD7LZV.js";
 import {
   parseChannelConfig
-} from "./chunk-ZXU5UHMI.js";
+} from "./chunk-QXVSWG66.js";
 import {
   findCliEntryPath
 } from "./chunk-V6WHFGST.js";
@@ -92,7 +93,7 @@ import {
 import {
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
-} from "./chunk-24ER7UV4.js";
+} from "./chunk-UFALT4LK.js";
 import {
   normalizeServeChannelSelection
 } from "./chunk-ALMR3E6Q.js";
@@ -115,7 +116,7 @@ import {
   clearAccount,
   loadAccount,
   saveAccount
-} from "./chunk-WUC6ZFXO.js";
+} from "./chunk-ZWBUH5UP.js";
 import {
   AcpBridge,
   ChannelLoopScheduler,
@@ -126,37 +127,41 @@ import {
   isChannelProactiveDeliveryError,
   sanitizeLogText,
   sanitizePromptText
-} from "./chunk-DIEFUBV6.js";
+} from "./chunk-DIWZNWZT.js";
 import {
   assembleMcpServers,
   getPendingGatedMcpServers,
   mcpCommand
-} from "./chunk-6HVUFDS2.js";
+} from "./chunk-Y4TETC74.js";
 import {
   loadSettings
-} from "./chunk-PQBHU2IA.js";
+} from "./chunk-OHKJVAKG.js";
 import {
   detectSystemLanguage,
   getCurrentLanguage,
   initializeI18n,
   resolveLanguageSetting,
   t
-} from "./chunk-DBOFL3LQ.js";
+} from "./chunk-PG62DFWD.js";
 import {
   loadEnvironment
-} from "./chunk-VOARQPTA.js";
+} from "./chunk-B52AWKBB.js";
+import {
+  resolveAcpChannelFallback,
+  scrubAndReportInheritedLoaderEnv
+} from "./chunk-UA5H3DS2.js";
 import {
   getCliVersion
-} from "./chunk-FZBZSYKU.js";
+} from "./chunk-FN6YXJOP.js";
 import {
   getPackageJson
 } from "./chunk-VJNBRRZG.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-6XU3PH66.js";
+} from "./chunk-HA3SAB64.js";
 import {
   require_strip_json_comments
-} from "./chunk-ALGGS7UH.js";
+} from "./chunk-NPQ5ZKRP.js";
 import {
   hideBin,
   yargs_default
@@ -195,7 +200,7 @@ import {
   unquoteCStylePath,
   updateChannelMemoryEntry,
   updateSetting
-} from "./chunk-Y7E5LNLO.js";
+} from "./chunk-GXSNGY5M.js";
 import {
   nextFireTime,
   parseCron
@@ -211,14 +216,14 @@ import {
   getAllGeminiMdFilenames,
   parseLineTolerant,
   setGeminiMdFilename
-} from "./chunk-2U3WZGZG.js";
+} from "./chunk-3PY4LPJF.js";
 import {
   SchemaValidator,
   ToolNames
-} from "./chunk-IC4Z6LX6.js";
+} from "./chunk-PYQADEFD.js";
 import {
   DEFAULT_QWEN_EMBEDDING_MODEL
-} from "./chunk-6EOI4HOK.js";
+} from "./chunk-F6WFNA7U.js";
 import {
   isTlsVerificationDisabled
 } from "./chunk-KKBPOU75.js";
@@ -364,9 +369,9 @@ var require_command_exists = __commonJS({
       cleanInput = /* @__PURE__ */ __name(function(s) {
         var isPathName = /[\\]/.test(s);
         if (isPathName) {
-          var dirname26 = '"' + path3.dirname(s) + '"';
-          var basename6 = '"' + path3.basename(s) + '"';
-          return dirname26 + ":" + basename6;
+          var dirname27 = '"' + path3.dirname(s) + '"';
+          var basename7 = '"' + path3.basename(s) + '"';
+          return dirname27 + ":" + basename7;
         }
         return '"' + s + '"';
       }, "cleanInput");
@@ -374,10 +379,10 @@ var require_command_exists = __commonJS({
     module.exports = /* @__PURE__ */ __name(function commandExists2(commandName, callback) {
       var cleanedCommandName = cleanInput(commandName);
       if (!callback && typeof Promise !== "undefined") {
-        return new Promise(function(resolve28, reject) {
+        return new Promise(function(resolve29, reject) {
           commandExists2(commandName, function(error, output) {
             if (output) {
-              resolve28(commandName);
+              resolve29(commandName);
             } else {
               reject(error);
             }
@@ -2324,8 +2329,8 @@ function createBridgeReadinessGate() {
     current: /* @__PURE__ */ __name(() => pending, "current"),
     block: /* @__PURE__ */ __name(() => {
       if (pending) return;
-      pending = new Promise((resolve28) => {
-        releasePending = resolve28;
+      pending = new Promise((resolve29) => {
+        releasePending = resolve29;
       });
     }, "block"),
     release: /* @__PURE__ */ __name(() => {
@@ -2407,7 +2412,7 @@ function createBridgeRecovery(options) {
         writeStderrLine(
           `[Channel] Bridge crashed (${recentCrashCount}/${MAX_CRASH_RESTARTS} in window). Restarting in ${RESTART_DELAY_MS / 1e3}s...`
         );
-        await new Promise((resolve28) => setTimeout(resolve28, RESTART_DELAY_MS));
+        await new Promise((resolve29) => setTimeout(resolve29, RESTART_DELAY_MS));
         const bridge = new AcpBridge(bridgeOpts);
         setBridge(bridge);
         attachDisconnectHandler(bridge);
@@ -2725,7 +2730,7 @@ var stopCommand = {
     if (argv["daemon-url"]) {
       const token = argv.token ?? process.env[QWEN_SERVER_TOKEN_ENV] ?? process.env[QWEN_DAEMON_TOKEN_ENV];
       try {
-        const sdk = await import("./daemon-SCTQMM7Z.js");
+        const sdk = await import("./daemon-VZBGJUNL.js");
         const client = new sdk.DaemonClient({
           baseUrl: argv["daemon-url"],
           ...token ? { token } : {}
@@ -2911,7 +2916,7 @@ var statusCommand = {
     if (argv["daemon-url"]) {
       const token = argv.token ?? process.env[QWEN_SERVER_TOKEN_ENV] ?? process.env[QWEN_DAEMON_TOKEN_ENV];
       try {
-        const sdk = await import("./daemon-SCTQMM7Z.js");
+        const sdk = await import("./daemon-VZBGJUNL.js");
         const client = new sdk.DaemonClient({
           baseUrl: argv["daemon-url"],
           ...token ? { token } : {}
@@ -3022,7 +3027,7 @@ var reloadCommand = {
     const token = resolveToken(argv.token);
     let sdk;
     try {
-      sdk = await import("./daemon-SCTQMM7Z.js");
+      sdk = await import("./daemon-VZBGJUNL.js");
     } catch (err) {
       writeStderrLine(
         `[Channel] Failed to load daemon SDK: ${safeChannelCommandErrorMessage(err)}`
@@ -3102,7 +3107,7 @@ var setCommand2 = {
     const selection = names[0] === "all" ? { mode: "all" } : { mode: "names", names };
     let sdk;
     try {
-      sdk = await import("./daemon-SCTQMM7Z.js");
+      sdk = await import("./daemon-VZBGJUNL.js");
     } catch (error) {
       writeStderrLine(
         `[Channel] Failed to load daemon SDK: ${safeChannelCommandErrorMessage(error)}`
@@ -3228,7 +3233,7 @@ function createDaemonChannelBridgeFacade(bridge, opts) {
 }
 __name(createDaemonChannelBridgeFacade, "createDaemonChannelBridgeFacade");
 async function loadDaemonSdk() {
-  return await import("./daemon-SCTQMM7Z.js");
+  return await import("./daemon-VZBGJUNL.js");
 }
 __name(loadDaemonSdk, "loadDaemonSdk");
 function selectedChannelNames(channelsConfig, selection) {
@@ -3275,12 +3280,12 @@ async function abortableStartup(value, signal) {
   const promise = Promise.resolve(value);
   if (!signal) return await promise;
   if (signal.aborted) throw startupAbortError();
-  return await new Promise((resolve28, reject) => {
+  return await new Promise((resolve29, reject) => {
     const onAbort = /* @__PURE__ */ __name(() => {
       reject(startupAbortError());
     }, "onAbort");
     signal.addEventListener("abort", onAbort, { once: true });
-    promise.then(resolve28, reject).finally(() => {
+    promise.then(resolve29, reject).finally(() => {
       signal.removeEventListener("abort", onAbort);
     });
   });
@@ -3472,7 +3477,10 @@ async function runChannelDaemonWorker(opts) {
             observedContacts: {
               observe: /* @__PURE__ */ __name((channelName, observation) => {
                 observedContacts.observe(channelName, observation);
-              }, "observe")
+              }, "observe"),
+              list: /* @__PURE__ */ __name(() => observedContacts.list({
+                freshWithinSeconds: OBSERVED_CONTACT_MAX_FRESH_WITHIN_SECONDS
+              }), "list")
             },
             ...loopController ? { loopController } : {}
           }),
@@ -3689,7 +3697,7 @@ function reportStartupToSupervisor(message, signal, subscribeMessage = (listener
   if (!send) {
     return Promise.reject(new Error("Channel worker IPC is unavailable."));
   }
-  return new Promise((resolve28, reject) => {
+  return new Promise((resolve29, reject) => {
     let settled = false;
     let unsubscribeMessage = /* @__PURE__ */ __name(() => {
     }, "unsubscribeMessage");
@@ -3703,7 +3711,7 @@ function reportStartupToSupervisor(message, signal, subscribeMessage = (listener
       settled = true;
       cleanup();
       if (error) reject(error);
-      else resolve28();
+      else resolve29();
     }, "finish");
     const onMessage = /* @__PURE__ */ __name((value) => {
       if (isChannelStartupReportAckMessage(value)) {
@@ -3785,6 +3793,11 @@ var daemonWorkerCommand = {
     try {
       assertInternalDaemonWorkerInvocation();
       const { daemonToken, daemonUrl, workspace } = readDaemonWorkerEnv();
+      scrubAndReportInheritedLoaderEnv(
+        process.env,
+        "qwen channel daemon-worker",
+        "channel daemon worker"
+      );
       const send = process.send;
       channelLoopMcpHost = new ChannelLoopMcpWorkerHost(
         (message, callback) => send.call(process, message, callback ?? (() => {
@@ -3951,8 +3964,8 @@ var daemonWorkerCommand = {
       let shuttingDown = false;
       let exitCode = 0;
       let finish;
-      const finished = new Promise((resolve28) => {
-        finish = resolve28;
+      const finished = new Promise((resolve29) => {
+        finish = resolve29;
       });
       const shutdown = /* @__PURE__ */ __name(async (reason) => {
         if (shuttingDown) {
@@ -3980,8 +3993,8 @@ var daemonWorkerCommand = {
                   ...activeChannelDeliveries.values(),
                   ...activeWebhookTasks.values()
                 ]),
-                new Promise((resolve28) => {
-                  const timer = setTimeout(resolve28, WORKER_SHUTDOWN_DRAIN_MS);
+                new Promise((resolve29) => {
+                  const timer = setTimeout(resolve29, WORKER_SHUTDOWN_DRAIN_MS);
                   timer.unref();
                 })
               ]);
@@ -4085,9 +4098,8 @@ var pairingListCommand = {
 `);
     for (const req of pending) {
       const ago = Math.round((Date.now() - req.createdAt) / 6e4);
-      writeStdoutLine(
-        `  Code: ${req.code}  Sender: ${req.senderName} (${req.senderId})  ${ago}m ago`
-      );
+      const subject = req.subject.type === "group" ? `Group: ${req.subject.name} (${req.subject.id})  Requested by: ${req.senderName} (${req.senderId})` : `Sender: ${req.subject.name} (${req.subject.id})`;
+      writeStdoutLine(`  Code: ${req.code}  ${subject}  ${ago}m ago`);
     }
   }, "handler")
 };
@@ -4113,8 +4125,9 @@ var pairingApproveCommand = {
       process.exit(1);
       return;
     }
+    const approved = request.subject.type === "group" ? `group ${request.subject.name} (${request.subject.id})` : `${request.subject.name} (${request.subject.id})`;
     writeStdoutLine(
-      `Approved: ${request.senderName} (${request.senderId}) can now use channel "${argv.name}".`
+      `Approved: ${approved} can now use channel "${argv.name}".`
     );
   }, "handler")
 };
@@ -4265,7 +4278,7 @@ var configureWeixinCommand = {
 // packages/cli/src/commands/channel.ts
 var pairingCommand = {
   command: "pairing",
-  describe: "Manage DM pairing requests",
+  describe: "Manage DM and group pairing requests",
   builder: /* @__PURE__ */ __name((yargs) => yargs.command(pairingListCommand).command(pairingApproveCommand).demandCommand(1, "You need at least one command before continuing.").version(false), "builder"),
   handler: /* @__PURE__ */ __name(() => {
   }, "handler")
@@ -4336,8 +4349,211 @@ init_esbuild_shims();
 
 // packages/cli/src/commands/review/parse-args.ts
 init_esbuild_shims();
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname } from "node:path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+
+// packages/cli/src/commands/review/lib/stale-bundle.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import {
+  existsSync as existsSync3,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync2,
+  realpathSync,
+  statSync
+} from "node:fs";
+import {
+  basename as basename3,
+  dirname,
+  extname,
+  join as join5,
+  relative as relative2,
+  resolve as resolve3,
+  sep
+} from "node:path";
+var DIGEST_FILE = "review-sources.sha256";
+var NOT_BUNDLED_RE = /\.(?:test|spec)\.(?:d\.)?[cm]?[jt]sx?$/;
+var NOT_BUNDLED_DIR = /* @__PURE__ */ new Set(["__fixtures__", "__snapshots__"]);
+var NOT_BUNDLED_FILE = /* @__PURE__ */ new Set(["test-utils.ts"]);
+var NOT_BUNDLED_SKILL_FILE = /* @__PURE__ */ new Set(["DESIGN.md"]);
+var DIGESTED_EXTENSIONS = {
+  code: /* @__PURE__ */ new Set([
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".mjs",
+    ".json",
+    ".jsx"
+  ]),
+  skill: /* @__PURE__ */ new Set([".md"])
+};
+function isDigestedFile(kind, name) {
+  if (!DIGESTED_EXTENSIONS[kind].has(extname(name))) return false;
+  if (kind !== "code") return !NOT_BUNDLED_SKILL_FILE.has(name);
+  return !NOT_BUNDLED_RE.test(name) && !NOT_BUNDLED_FILE.has(name);
+}
+__name(isDigestedFile, "isDigestedFile");
+function measureReviewSources(repoRoot, roots) {
+  const state = { incomplete: false, absentRoots: 0 };
+  const files = [];
+  for (const root of roots) files.push(...sourceFilesUnder(root, state, false));
+  const partial = state.absentRoots > 0 && state.absentRoots < roots.length;
+  if (state.incomplete || files.length === 0) {
+    return { digest: void 0, incomplete: state.incomplete, partial };
+  }
+  const hash = createHash("sha256");
+  for (const file of files.sort()) {
+    let content;
+    try {
+      content = readFileSync3(file);
+    } catch {
+      return { digest: void 0, incomplete: true, partial };
+    }
+    hash.update(relative2(repoRoot, file).split(sep).join("/"));
+    hash.update("\0");
+    hash.update(content);
+    hash.update("\0");
+  }
+  return { digest: hash.digest("hex"), incomplete: false, partial };
+}
+__name(measureReviewSources, "measureReviewSources");
+function bundleStaleness(stampedDigest, currentDigest) {
+  if (!stampedDigest) {
+    return { stale: false, unmeasured: "the bundle carries no source digest" };
+  }
+  if (!currentDigest) {
+    return {
+      stale: false,
+      unmeasured: "no review sources were found to compare"
+    };
+  }
+  return { stale: stampedDigest !== currentDigest };
+}
+__name(bundleStaleness, "bundleStaleness");
+function* sourceFilesUnder(root, state, listed) {
+  const { kind } = root;
+  let entries;
+  try {
+    entries = readdirSync2(root.path, { withFileTypes: true });
+  } catch {
+    let stats;
+    try {
+      stats = statSync(root.path);
+    } catch (err) {
+      if (listed || err.code !== "ENOENT")
+        state.incomplete = true;
+      else state.absentRoots += 1;
+      return;
+    }
+    if (stats.isDirectory()) {
+      state.incomplete = true;
+      return;
+    }
+    if (stats.isFile() && isDigestedFile(kind, basename3(root.path)))
+      yield root.path;
+    return;
+  }
+  for (const e of entries) {
+    const full = join5(root.path, e.name);
+    if (e.isDirectory()) {
+      if (kind !== "code" || !NOT_BUNDLED_DIR.has(e.name))
+        yield* sourceFilesUnder({ path: full, kind }, state, true);
+    } else if (e.isFile() && isDigestedFile(kind, e.name)) {
+      yield full;
+    }
+  }
+}
+__name(sourceFilesUnder, "sourceFilesUnder");
+function reviewSourceRoots(repoRoot) {
+  const cli = join5(repoRoot, "packages", "cli", "src", "commands");
+  return [
+    { path: join5(cli, "review"), kind: "code" },
+    // The parent file, which is where every subcommand is registered — a new
+    // command, or a changed dispatch, lives here and nowhere under `review/`.
+    // A root may be a single file for exactly this reason.
+    { path: join5(cli, "review.ts"), kind: "code" },
+    // The worktree lease is review-only code that lives outside `review/`:
+    // `fetch-pr` and `cleanup` import it from `services/`, so an edit to it
+    // with a skipped rebuild is the same silent failure this check exists
+    // for. The two shared files the closure also reaches (`stdioHelpers.ts`,
+    // `skill-args-file.ts`) stay out for the reason SCOPE gives.
+    {
+      path: join5(
+        repoRoot,
+        "packages",
+        "cli",
+        "src",
+        "services",
+        "review-worktree-lease.ts"
+      ),
+      kind: "code"
+    },
+    {
+      path: join5(
+        repoRoot,
+        "packages",
+        "core",
+        "src",
+        "skills",
+        "bundled",
+        "review"
+      ),
+      kind: "skill"
+    }
+  ];
+}
+__name(reviewSourceRoots, "reviewSourceRoots");
+function bundleStalenessNotices(entryPath, brief) {
+  try {
+    if (!entryPath) return void 0;
+    let entry = entryPath;
+    try {
+      entry = realpathSync(entryPath);
+    } catch {
+    }
+    const distDir = dirname(resolve3(entry));
+    if (basename3(distDir) !== "dist") return void 0;
+    const repoRoot = dirname(distDir);
+    let stamped;
+    try {
+      const raw = readFileSync3(join5(distDir, DIGEST_FILE), "utf8").trim();
+      if (/^[0-9a-f]{64}$/.test(raw)) stamped = raw;
+    } catch {
+    }
+    const roots = reviewSourceRoots(repoRoot);
+    const measured = measureReviewSources(repoRoot, roots);
+    const current = measured.digest;
+    if (stamped && current && measured.partial) {
+      return `review: could not check whether the bundle is current \u2014 only some of the review sources are present` + (brief ? " (a partial checkout)." : " (a sparse or partial checkout). The stamp covers the whole tree; materialize the missing sources to compare again.");
+    }
+    const staleness = bundleStaleness(stamped, current);
+    const warning = staleBundleWarning(staleness, brief);
+    if (warning) return warning;
+    if (stamped && !current && (measured.incomplete || roots.some((r) => existsSync3(r.path)))) {
+      const reason = measured.incomplete ? "a review source could not be read, so nothing was compared" + (brief ? "." : ". Re-run once the tree is settled.") : `${staleness.unmeasured}.`;
+      return `review: could not check whether the bundle is current \u2014 ${reason}`;
+    }
+    if (!stamped && current) {
+      return `review: could not check whether the bundle is current \u2014 ${staleness.unmeasured}. ` + (brief ? "Rebuild with `npm run bundle` to record one." : "Either it was built before this check existed, or the build declined to record one; rebuild with `npm run bundle` and, if the line persists, read that build's output for why it refused.");
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(bundleStalenessNotices, "bundleStalenessNotices");
+function staleBundleWarning(s, brief) {
+  if (!s.stale) return void 0;
+  if (brief) {
+    return `review: the bundle these commands run from was NOT built from the review sources in this tree \u2014 rebuild with \`npm run bundle\` and start again, or read every result below as being about the older build.`;
+  }
+  return `review: the bundle these commands run from was NOT built from the review sources in this tree. Every \`qwen review \u2026\` step below runs the BUILT bundle, not the working tree, so a review source changed since that build will not take effect and this run will measure the old behaviour without saying so. Rebuild with \`npm run bundle\` and start again, or read every result below as being about the older build.`;
+}
+__name(staleBundleWarning, "staleBundleWarning");
+
+// packages/cli/src/commands/review/parse-args.ts
 var EFFORT_LEVELS = /* @__PURE__ */ new Set([
   "low",
   "medium",
@@ -4604,108 +4820,475 @@ var parseArgsCommand = {
         `parse-args: unexpected extra argument(s) ${JSON.stringify(unbound)} \u2014 a raw string that begins with a flag must be passed via --stdin, not after --`
       );
     }
-    const rawStr = stdin ? readFileSync3(0, "utf8").replace(/\r?\n$/, "") : raw ?? "";
+    const rawStr = stdin ? readFileSync4(0, "utf8").replace(/\r?\n$/, "") : raw ?? "";
+    const bundleNotice = bundleStalenessNotices(process.argv[1]);
+    if (bundleNotice) {
+      writeStderrLineSafe(bundleNotice);
+    }
     const parsed = parseReviewArgs(rawStr);
     const json = JSON.stringify(parsed, null, 2);
     if (out) {
-      mkdirSync2(dirname(out), { recursive: true });
+      mkdirSync2(dirname2(out), { recursive: true });
       writeFileSync2(out, json, "utf8");
     }
     writeStdoutLine(json);
   }, "handler")
 };
 
-// packages/cli/src/commands/review/compose-review.ts
-init_esbuild_shims();
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname4, join as join9 } from "node:path";
-
-// packages/cli/src/commands/review/lib/coverage.ts
+// packages/cli/src/commands/review/match-remote.ts
 init_esbuild_shims();
-import { readFileSync as readFileSync8, statSync as statSync4 } from "node:fs";
 
-// packages/cli/src/commands/review/lib/transcripts.ts
+// packages/cli/src/commands/review/lib/gh.ts
 init_esbuild_shims();
-import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync } from "node:fs";
-import { join as join5 } from "node:path";
-var TranscriptsUnavailableError = class extends Error {
-  static {
-    __name(this, "TranscriptsUnavailableError");
+import { execFileSync as execFileSync2 } from "node:child_process";
+var MAX_RETRIES = 2;
+var BASE_DELAY_MS = 3e3;
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+__name(sleepSync, "sleepSync");
+var TRANSIENT_RE = /HTTP 5\d{2}|server is currently unavailable|service unavailable|bad gateway|internal server error/i;
+function isTransientGhError(err) {
+  const stderr = typeof err.stderr === "string" ? err.stderr : "";
+  const msg = err instanceof Error ? err.message : "";
+  return TRANSIENT_RE.test(stderr) || TRANSIENT_RE.test(msg);
+}
+__name(isTransientGhError, "isTransientGhError");
+function execGhWithRetry(args, options) {
+  const execOptions = {
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+    env: ghEnv(),
+    ...options.input !== void 0 ? { input: options.input } : {}
+  };
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return execFileSync2("gh", args, execOptions).replace(/\r\n/g, "\n").trim();
+    } catch (err) {
+      if (attempt < MAX_RETRIES && isTransientGhError(err)) {
+        const delay = BASE_DELAY_MS * (attempt + 1);
+        process.stderr.write(
+          `gh transient error (attempt ${attempt + 1}/${MAX_RETRIES}), retrying in ${delay}ms\u2026
+`
+        );
+        sleepSync(delay);
+        continue;
+      }
+      throw err;
+    }
   }
-};
-function transcriptPaths(env = process.env) {
-  const projectDir = env["QWEN_CODE_PROJECT_DIR"]?.trim();
-  const sessionId = env["QWEN_CODE_SESSION_ID"]?.trim();
-  if (!projectDir || !sessionId) {
-    throw new TranscriptsUnavailableError(
-      "the CLI did not export QWEN_CODE_PROJECT_DIR / QWEN_CODE_SESSION_ID, so this run cannot find the harness's record of what its agents did"
+}
+__name(execGhWithRetry, "execGhWithRetry");
+var ghHost;
+var HOSTNAME_RE = /^[A-Za-z0-9.-]+(?::\d+)?$/;
+function setGhHost(host) {
+  if (host === void 0 || host === "") {
+    ghHost = void 0;
+    return;
+  }
+  if (!HOSTNAME_RE.test(host)) {
+    throw new TypeError(
+      `--host must be a hostname (optionally :port), got ${JSON.stringify(host)}`
     );
   }
-  return {
-    projectDir,
-    sessionId,
-    dir: join5(projectDir, "subagents", sessionId)
-  };
+  ghHost = host;
 }
-__name(transcriptPaths, "transcriptPaths");
-function transcriptDir(env = process.env) {
-  return transcriptPaths(env).dir;
+__name(setGhHost, "setGhHost");
+function getGhHost() {
+  return ghHost;
 }
-__name(transcriptDir, "transcriptDir");
-function textOf(rec) {
-  const msg = rec["message"];
-  const parts = Array.isArray(msg?.parts) ? msg.parts : [];
-  return parts.map((p) => p.text).filter((t2) => typeof t2 === "string").join("");
+__name(getGhHost, "getGhHost");
+function resolveGhHost(flagHost) {
+  return flagHost ?? (process.env["GH_HOST"]?.trim() || void 0);
 }
-__name(textOf, "textOf");
-function isErrorPart(part) {
-  const resp = part.functionResponse?.response;
-  return !!resp && resp["error"] !== void 0 && resp["error"] !== null;
+__name(resolveGhHost, "resolveGhHost");
+function ghEnv() {
+  return ghHost ? { ...process.env, GH_HOST: ghHost } : void 0;
 }
-__name(isErrorPart, "isErrorPart");
-function rangeOf(args) {
-  const offset = args["offset"];
-  const limit = args["limit"];
-  if (typeof limit !== "number" || !Number.isInteger(limit) || limit <= 0) {
-    return null;
-  }
-  const off = typeof offset === "number" && Number.isInteger(offset) && offset >= 0 ? offset : 0;
-  return [off + 1, off + limit];
+__name(ghEnv, "ghEnv");
+function gh(...args) {
+  return execGhWithRetry(args, {});
 }
-__name(rangeOf, "rangeOf");
-function parseTranscript(file, diffPath) {
-  let raw;
-  try {
-    raw = readFileSync4(file, "utf8");
-  } catch {
-    return null;
-  }
-  const lines = raw.split("\n").filter((l) => l.trim());
-  if (lines.length === 0) return null;
-  let agentId = "";
-  let agentName = "";
-  let launchPrompt = "";
-  let finalText = "";
-  let successfulToolCalls = 0;
-  let diffToolCalls = 0;
-  const diffReads = [];
-  const successfulCallArgs = [];
-  const successfulReadFileArgs = [];
-  const byId = /* @__PURE__ */ new Map();
-  const anonymous = [];
-  for (const line of lines) {
-    let rec;
+__name(gh, "gh");
+function ghWithInputRetried(input, ...args) {
+  return execGhWithRetry(args, { input });
+}
+__name(ghWithInputRetried, "ghWithInputRetried");
+function ghWithInput(input, ...args) {
+  return execFileSync2("gh", args, {
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+    env: ghEnv(),
+    input
+  }).replace(/\r\n/g, "\n").trim();
+}
+__name(ghWithInput, "ghWithInput");
+function ghApiAll(path3) {
+  const out = gh("api", "--paginate", path3);
+  if (!out) return [];
+  const parsed = JSON.parse(out);
+  return Array.isArray(parsed) ? parsed : [];
+}
+__name(ghApiAll, "ghApiAll");
+function ghApiAllNested(path3, key) {
+  return parseNdjson(gh("api", "--paginate", path3, "--jq", `.${key}[]`), {
+    strict: true
+  });
+}
+__name(ghApiAllNested, "ghApiAllNested");
+function parseNdjson(out, opts = {}) {
+  const strict = opts.strict ?? true;
+  if (!out) return [];
+  const values = [];
+  for (const line of out.split("\n")) {
+    if (line.trim().length === 0) continue;
+    if (strict) {
+      values.push(JSON.parse(line));
+      continue;
+    }
     try {
-      rec = JSON.parse(line);
+      values.push(JSON.parse(line));
     } catch {
-      continue;
     }
-    if (!agentId && typeof rec["agentId"] === "string")
-      agentId = rec["agentId"];
-    if (!agentName && typeof rec["agentName"] === "string") {
-      agentName = rec["agentName"];
+  }
+  return values;
+}
+__name(parseNdjson, "parseNdjson");
+function currentUser() {
+  return gh("api", "user", "--jq", ".login");
+}
+__name(currentUser, "currentUser");
+function ensureAuthenticated() {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      execFileSync2("gh", ["auth", "status"], { stdio: "pipe", env: ghEnv() });
+      return;
+    } catch (err) {
+      if (attempt === 0 && err.code !== "ENOENT") {
+        sleepSync(2e3);
+        continue;
+      }
+      throw new Error(
+        "gh CLI is not authenticated. Run `gh auth login` and retry."
+      );
     }
-    const type = rec["type"];
+  }
+}
+__name(ensureAuthenticated, "ensureAuthenticated");
+
+// packages/cli/src/commands/review/lib/git.ts
+init_esbuild_shims();
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { existsSync as existsSync4, rmSync as rmSync2 } from "node:fs";
+var GIT_TIMEOUT_MS2 = 12e4;
+function gitOpts() {
+  return {
+    timeout: GIT_TIMEOUT_MS2,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  };
+}
+__name(gitOpts, "gitOpts");
+function git(...args) {
+  return execFileSync3("git", args, { ...gitOpts(), encoding: "utf8" }).replace(/\r\n/g, "\n").trim();
+}
+__name(git, "git");
+function gitWithInput(input, args) {
+  return execFileSync3("git", args, { ...gitOpts(), encoding: "utf8", input }).replace(/\r\n/g, "\n").trim();
+}
+__name(gitWithInput, "gitWithInput");
+function gitOpt(...args) {
+  try {
+    return execFileSync3("git", args, {
+      ...gitOpts(),
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).replace(/\r\n/g, "\n").trim();
+  } catch {
+    return null;
+  }
+}
+__name(gitOpt, "gitOpt");
+function refExists(ref) {
+  return gitOpt("rev-parse", "--verify", "--quiet", ref) !== null;
+}
+__name(refExists, "refExists");
+function worktreeReleaseResult(existed, stillThere, removeError) {
+  const freed = existed && !stillThere;
+  if (!existed || freed) {
+    return { existed, freed, reason: void 0 };
+  }
+  return {
+    existed,
+    freed,
+    reason: removeError ? removeError instanceof Error ? removeError.message : String(removeError) : "the path is still there after `git worktree remove --force` and `rm -rf`"
+  };
+}
+__name(worktreeReleaseResult, "worktreeReleaseResult");
+function releaseWorktree(worktreePath2) {
+  const existed = existsSync4(worktreePath2);
+  let removeError;
+  if (existed) {
+    gitOpt("worktree", "remove", worktreePath2, "--force");
+    try {
+      rmSync2(worktreePath2, { recursive: true, force: true });
+    } catch (e) {
+      removeError = e;
+    }
+  }
+  gitOpt("worktree", "prune");
+  return worktreeReleaseResult(existed, existsSync4(worktreePath2), removeError);
+}
+__name(releaseWorktree, "releaseWorktree");
+function gitRaw(...args) {
+  return execFileSync3("git", args, {
+    ...gitOpts(),
+    maxBuffer: 512 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+}
+__name(gitRaw, "gitRaw");
+function gitRawTolerateDiff(...args) {
+  try {
+    return gitRaw(...args);
+  } catch (err) {
+    const e = err;
+    if (e.status === 1 && e.stdout && e.stdout.length > 0) return e.stdout;
+    throw err;
+  }
+}
+__name(gitRawTolerateDiff, "gitRawTolerateDiff");
+
+// packages/cli/src/commands/review/lib/remote-match.ts
+init_esbuild_shims();
+function normalizeSegment(value) {
+  const v = value.toLowerCase();
+  return v.endsWith(".git") ? v.slice(0, -4) : v;
+}
+__name(normalizeSegment, "normalizeSegment");
+function parseRemoteUrl(raw) {
+  const url = raw.trim();
+  if (url === "") return null;
+  let host;
+  let pathPart;
+  const schemeIdx = url.indexOf("://");
+  if (schemeIdx !== -1) {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      return null;
+    }
+    if (parsed.hostname === "") return null;
+    host = parsed.hostname;
+    pathPart = parsed.pathname;
+  } else {
+    const colonIdx = url.indexOf(":");
+    const slashIdx = url.indexOf("/");
+    if (colonIdx === -1 || slashIdx === -1 || colonIdx > slashIdx) {
+      return null;
+    }
+    host = url.slice(0, colonIdx);
+    const atIdx = host.lastIndexOf("@");
+    if (atIdx !== -1) host = host.slice(atIdx + 1);
+    pathPart = url.slice(colonIdx + 1);
+  }
+  const segments = pathPart.split("/").map((s) => s.trim()).filter((s) => s !== "");
+  if (segments.length !== 2) return null;
+  if (host === "") return null;
+  return {
+    host: host.toLowerCase(),
+    owner: normalizeSegment(segments[0]),
+    repo: normalizeSegment(segments[1])
+  };
+}
+__name(parseRemoteUrl, "parseRemoteUrl");
+function matchRemotes(remoteVOutput, { owner, repo, host = "github.com" }) {
+  const wantOwner = normalizeSegment(owner);
+  const wantRepo = normalizeSegment(repo);
+  const wantHost = normalizeSegment(host.replace(/:\d+$/, ""));
+  const matched = [];
+  for (const line of remoteVOutput.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "" || !/\(fetch\)(\s+\[[^\]]*\])?$/.test(trimmed)) {
+      continue;
+    }
+    const nameMatch = trimmed.match(
+      /^(\S+)\s+(.*)\s+\(fetch\)(\s+\[[^\]]*\])?$/
+    );
+    if (!nameMatch) continue;
+    const identity = parseRemoteUrl(nameMatch[2]);
+    if (identity === null) continue;
+    if (identity.host === wantHost && identity.owner === wantOwner && identity.repo === wantRepo) {
+      matched.push(nameMatch[1]);
+    }
+  }
+  return { matched };
+}
+__name(matchRemotes, "matchRemotes");
+
+// packages/cli/src/commands/review/match-remote.ts
+function runMatchRemote(args) {
+  try {
+    git("rev-parse", "--is-inside-work-tree");
+  } catch (err) {
+    writeStderrLineSafe(
+      `match-remote: git cannot resolve this repository: ${err.message}`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const host = resolveGhHost(args.host) ?? "github.com";
+  let remoteV;
+  try {
+    remoteV = git("remote", "-v");
+  } catch (err) {
+    writeStderrLineSafe(
+      `match-remote: \`git remote -v\` failed: ${err.message}`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const { matched } = matchRemotes(remoteV, {
+    owner: args.owner,
+    repo: args.repo,
+    host
+  });
+  if (matched.length === 1) {
+    writeStdoutLine(matched[0]);
+    return;
+  }
+  if (matched.length === 0) {
+    writeStdoutLine("none");
+    writeStderrLineSafe(
+      `match-remote: no remote matches ${host}/${args.owner}/${args.repo} by exact host + owner/repo equality \u2014 the PR is not served by any remote of this repository.`
+    );
+    process.exitCode = 6;
+    return;
+  }
+  for (const name of matched) {
+    writeStdoutLine(name);
+  }
+  writeStderrLineSafe(
+    `warning: ${matched.length} remotes match ${host}/${args.owner}/${args.repo} (${matched.join(", ")}); refusing to pick one \u2014 the review stops here.`
+  );
+  process.exitCode = 7;
+}
+__name(runMatchRemote, "runMatchRemote");
+var matchRemoteCommand = {
+  command: "match-remote",
+  describe: "Print the git remote whose URL matches an owner/repo by exact host + owner/repo equality (exit 6 when none, exit 7 when several)",
+  builder: /* @__PURE__ */ __name((yargs) => yargs.option("owner", {
+    type: "string",
+    demandOption: true,
+    describe: "The repository owner (from the PR URL, or `gh repo view`)"
+  }).option("repo", {
+    type: "string",
+    demandOption: true,
+    describe: "The repository name"
+  }).option("host", {
+    type: "string",
+    describe: "The PR's host \u2014 from its URL, or from `gh repo view` for a bare number (omitted: inherit an operator-exported GH_HOST, else github.com)"
+  }), "builder"),
+  handler: /* @__PURE__ */ __name((argv) => {
+    runMatchRemote({
+      owner: String(argv["owner"]),
+      repo: String(argv["repo"]),
+      host: argv.host
+    });
+  }, "handler")
+};
+
+// packages/cli/src/commands/review/compose-review.ts
+init_esbuild_shims();
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname5, join as join10 } from "node:path";
+
+// packages/cli/src/commands/review/lib/coverage.ts
+init_esbuild_shims();
+import { readFileSync as readFileSync9, statSync as statSync5 } from "node:fs";
+
+// packages/cli/src/commands/review/lib/transcripts.ts
+init_esbuild_shims();
+import { readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync2 } from "node:fs";
+import { join as join6 } from "node:path";
+var TranscriptsUnavailableError = class extends Error {
+  static {
+    __name(this, "TranscriptsUnavailableError");
+  }
+};
+function transcriptPaths(env = process.env) {
+  const projectDir = env["QWEN_CODE_PROJECT_DIR"]?.trim();
+  const sessionId = env["QWEN_CODE_SESSION_ID"]?.trim();
+  if (!projectDir || !sessionId) {
+    throw new TranscriptsUnavailableError(
+      "the CLI did not export QWEN_CODE_PROJECT_DIR / QWEN_CODE_SESSION_ID, so this run cannot find the harness's record of what its agents did"
+    );
+  }
+  return {
+    projectDir,
+    sessionId,
+    dir: join6(projectDir, "subagents", sessionId)
+  };
+}
+__name(transcriptPaths, "transcriptPaths");
+function transcriptDir(env = process.env) {
+  return transcriptPaths(env).dir;
+}
+__name(transcriptDir, "transcriptDir");
+function textOf(rec) {
+  const msg = rec["message"];
+  const parts = Array.isArray(msg?.parts) ? msg.parts : [];
+  return parts.map((p) => p.text).filter((t2) => typeof t2 === "string").join("");
+}
+__name(textOf, "textOf");
+function isErrorPart(part) {
+  const resp = part.functionResponse?.response;
+  return !!resp && resp["error"] !== void 0 && resp["error"] !== null;
+}
+__name(isErrorPart, "isErrorPart");
+function rangeOf(args) {
+  const offset = args["offset"];
+  const limit = args["limit"];
+  if (typeof limit !== "number" || !Number.isInteger(limit) || limit <= 0) {
+    return null;
+  }
+  const off = typeof offset === "number" && Number.isInteger(offset) && offset >= 0 ? offset : 0;
+  return [off + 1, off + limit];
+}
+__name(rangeOf, "rangeOf");
+function parseTranscript(file, diffPath) {
+  let raw;
+  try {
+    raw = readFileSync5(file, "utf8");
+  } catch {
+    return null;
+  }
+  const lines = raw.split("\n").filter((l) => l.trim());
+  if (lines.length === 0) return null;
+  let agentId = "";
+  let agentName = "";
+  let launchPrompt = "";
+  let finalText = "";
+  let successfulToolCalls = 0;
+  let diffToolCalls = 0;
+  const diffReads = [];
+  const successfulCallArgs = [];
+  const successfulReadFileArgs = [];
+  const byId = /* @__PURE__ */ new Map();
+  const anonymous = [];
+  for (const line of lines) {
+    let rec;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!agentId && typeof rec["agentId"] === "string")
+      agentId = rec["agentId"];
+    if (!agentName && typeof rec["agentName"] === "string") {
+      agentName = rec["agentName"];
+    }
+    const type = rec["type"];
     if (!launchPrompt && type === "user") launchPrompt = textOf(rec);
     const msg = rec["message"];
     const parts = Array.isArray(msg?.parts) ? msg.parts : [];
@@ -4753,7 +5336,7 @@ function parseTranscript(file, diffPath) {
   if (!agentId) return null;
   let mtimeMs = 0;
   try {
-    mtimeMs = statSync(file).mtimeMs;
+    mtimeMs = statSync2(file).mtimeMs;
   } catch {
   }
   return {
@@ -4771,7 +5354,7 @@ function parseTranscript(file, diffPath) {
 }
 __name(parseTranscript, "parseTranscript");
 function listAgentTranscriptFiles(dir) {
-  return readdirSync2(dir).filter((name) => name.endsWith(".jsonl"));
+  return readdirSync3(dir).filter((name) => name.endsWith(".jsonl"));
 }
 __name(listAgentTranscriptFiles, "listAgentTranscriptFiles");
 function readTranscripts(since, env = process.env, diffPath) {
@@ -4786,7 +5369,7 @@ function readTranscripts(since, env = process.env, diffPath) {
   }
   const out = [];
   for (const name of names) {
-    const rec = parseTranscript(join5(dir, name), diffPath);
+    const rec = parseTranscript(join6(dir, name), diffPath);
     if (!rec) continue;
     if (since !== void 0 && rec.mtimeMs < since) continue;
     out.push(rec);
@@ -4805,24 +5388,24 @@ __name(wasGivenTheDiff, "wasGivenTheDiff");
 init_esbuild_shims();
 import {
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync5,
-  readdirSync as readdirSync3,
-  statSync as statSync2,
+  readFileSync as readFileSync6,
+  readdirSync as readdirSync4,
+  statSync as statSync3,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { dirname as dirname2, join as join6, basename as basename3, resolve as resolve3 } from "node:path";
+import { dirname as dirname3, join as join7, basename as basename4, resolve as resolve4 } from "node:path";
 function promptRecordDir(planPath) {
-  const p = resolve3(planPath);
-  return join6(dirname2(p), `${basename3(p).replace(/\.json$/i, "")}-prompts`);
+  const p = resolve4(planPath);
+  return join7(dirname3(p), `${basename4(p).replace(/\.json$/i, "")}-prompts`);
 }
 __name(promptRecordDir, "promptRecordDir");
 var fileFor = /* @__PURE__ */ __name((key) => `${encodeURIComponent(key)}.txt`, "fileFor");
 function briefPath(planPath, key) {
-  return join6(promptRecordDir(planPath), `${encodeURIComponent(key)}.brief.md`);
+  return join7(promptRecordDir(planPath), `${encodeURIComponent(key)}.brief.md`);
 }
 __name(briefPath, "briefPath");
 function findingsFilePath(planPath, key) {
-  return join6(
+  return join7(
     promptRecordDir(planPath),
     `${encodeURIComponent(key)}.findings.md`
   );
@@ -4852,7 +5435,7 @@ function writeBrief(planPath, key, brief) {
   const p = briefPath(planPath, key);
   let hadRules = false;
   try {
-    hadRules = readFileSync5(p, "utf8").includes(RULES_MARKER);
+    hadRules = readFileSync6(p, "utf8").includes(RULES_MARKER);
   } catch {
   }
   if (hadRules && !brief.includes(RULES_MARKER)) {
@@ -4872,7 +5455,7 @@ function recordPrompt(planPath, key, prompt) {
   try {
     const dir = promptRecordDir(planPath);
     mkdirSync3(dir, { recursive: true });
-    writeFileSync3(join6(dir, fileFor(key)), prompt);
+    writeFileSync3(join7(dir, fileFor(key)), prompt);
   } catch {
   }
 }
@@ -4882,7 +5465,7 @@ function readRecordedPrompts(planPath, sinceMs) {
   const dir = promptRecordDir(planPath);
   let names;
   try {
-    names = readdirSync3(dir).sort();
+    names = readdirSync4(dir).sort();
   } catch {
     return out;
   }
@@ -4895,9 +5478,9 @@ function readRecordedPrompts(planPath, sinceMs) {
       } catch {
         continue;
       }
-      const file = join6(dir, name);
-      if (sinceMs !== void 0 && statSync2(file).mtimeMs < sinceMs) continue;
-      out.set(key, readFileSync5(file, "utf8"));
+      const file = join7(dir, name);
+      if (sinceMs !== void 0 && statSync3(file).mtimeMs < sinceMs) continue;
+      out.set(key, readFileSync6(file, "utf8"));
     } catch {
     }
   }
@@ -4963,6 +5546,10 @@ __name(isRepositoryContextRoleId, "isRepositoryContextRoleId");
 var REVERSE_AUDIT_EXAMPLE_RECEIPT = "No issues found \u2014 re-walked the reconnect state machine and the two changed exports' call sites; every gap I checked was already in the list";
 var BRIEFS = {
   "0": {
+    // Budget-exempt: Issue-sized mandatory work, not diff-sized: a small bugfix
+    // referencing many issues would exhaust a diff-derived ceiling on
+    // required fetches alone.
+    budgetExempt: true,
     label: "Agent 0: Issue fidelity & root-cause ownership",
     publicLabel: "the linked-issue fidelity pass",
     publicLabelZh: "\u5173\u8054 issue \u4E00\u81F4\u6027\u68C0\u67E5",
@@ -5253,6 +5840,10 @@ Under that framing, look at:
 You are undirected on purpose. Do not restrict yourself to the list.`
   },
   "7": {
+    // Budget-exempt: Deterministic build/test commands — the run costs what the
+    // project scripts cost, and stopping early is the one thing it must
+    // never do.
+    budgetExempt: true,
     label: "Agent 7: Build & test verification",
     publicLabel: "the build-and-test check",
     publicLabelZh: "\u6784\u5EFA\u4E0E\u6D4B\u8BD5\u9A8C\u8BC1",
@@ -5337,6 +5928,9 @@ This file is largely rewritten, and reviewing it as a diff is the wrong frame. T
 Report a **Critical** for each violation, and give **both** locations that together make it a bug (\`<file>:<lineA>\` and \`<file>:<lineB>\`), not just one.`
   },
   verify: {
+    // Budget-exempt: Its per-finding re-trace must not stop early; `verifyShard`
+    // already governs its load.
+    budgetExempt: true,
     reviewsCode: true,
     output: "verdicts",
     acceptsFindings: true,
@@ -5591,21 +6185,21 @@ __name(repositoryContextOf, "repositoryContextOf");
 // packages/cli/src/commands/review/script-lint.ts
 init_esbuild_shims();
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import {
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   writeFileSync as writeFileSync4,
   mkdirSync as mkdirSync4,
   mkdtempSync,
-  rmSync as rmSync2,
+  rmSync as rmSync3,
   lstatSync,
-  realpathSync,
+  realpathSync as realpathSync2,
   openSync,
   readSync,
   closeSync
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname as dirname3, join as join7, resolve as resolve4, basename as basename4, sep } from "node:path";
+import { dirname as dirname4, join as join8, resolve as resolve5, basename as basename5, sep as sep2 } from "node:path";
 
 // packages/cli/src/commands/review/lib/diff-plan.ts
 init_esbuild_shims();
@@ -5986,7 +6580,7 @@ __name(chunksCoverDiff, "chunksCoverDiff");
 // packages/cli/src/commands/review/script-lint.ts
 function pathTool(path3) {
   const p = path3.toLowerCase();
-  const base = basename4(p);
+  const base = basename5(p);
   if (/(^|\/)\.github\/workflows\/.+\.ya?ml$/.test(p)) {
     return "actionlint";
   }
@@ -6035,7 +6629,7 @@ function addedRangesFromDiff(diffText) {
 __name(addedRangesFromDiff, "addedRangesFromDiff");
 function realIfExists(p) {
   try {
-    return realpathSync(p);
+    return realpathSync2(p);
   } catch {
     return void 0;
   }
@@ -6069,14 +6663,14 @@ var hadolintEmptyConfigPath;
 function emptyHadolintConfig() {
   if (!hadolintEmptyConfigPath) {
     try {
-      const d = mkdtempSync(join7(tmpdir(), "qwen-review-hadolint-"));
+      const d = mkdtempSync(join8(tmpdir(), "qwen-review-hadolint-"));
       process.on("exit", () => {
         try {
-          rmSync2(d, { recursive: true, force: true });
+          rmSync3(d, { recursive: true, force: true });
         } catch {
         }
       });
-      const p = join7(d, "config.yaml");
+      const p = join8(d, "config.yaml");
       writeFileSync4(p, "ignored: []\n");
       hadolintEmptyConfigPath = p;
     } catch {
@@ -6185,7 +6779,7 @@ __name(parseFindings, "parseFindings");
 function diffHashOf(diffPath) {
   if (typeof diffPath !== "string" || !diffPath) return void 0;
   try {
-    return createHash("sha256").update(readFileSync6(diffPath)).digest("hex");
+    return createHash2("sha256").update(readFileSync7(diffPath)).digest("hex");
   } catch {
     return void 0;
   }
@@ -6194,7 +6788,7 @@ __name(diffHashOf, "diffHashOf");
 function runScriptLint(args, runner = runTool) {
   let plan;
   try {
-    plan = JSON.parse(readFileSync6(args.plan, "utf8"));
+    plan = JSON.parse(readFileSync7(args.plan, "utf8"));
   } catch (err) {
     throw new Error(
       `script-lint: cannot read the plan ${args.plan}: ${err.message}`
@@ -6206,7 +6800,7 @@ function runScriptLint(args, runner = runTool) {
   let diffBuf;
   if (typeof plan.diffPathAbsolute === "string") {
     try {
-      diffBuf = readFileSync6(plan.diffPathAbsolute);
+      diffBuf = readFileSync7(plan.diffPathAbsolute);
     } catch {
       diffBuf = void 0;
     }
@@ -6214,7 +6808,7 @@ function runScriptLint(args, runner = runTool) {
   if (diffBuf) {
     try {
       addedRanges = addedRangesFromDiff(diffBuf.toString("utf8"));
-      diffHash = createHash("sha256").update(diffBuf).digest("hex");
+      diffHash = createHash2("sha256").update(diffBuf).digest("hex");
     } catch {
       addedRanges = /* @__PURE__ */ new Map();
       diffHash = void 0;
@@ -6228,13 +6822,13 @@ function runScriptLint(args, runner = runTool) {
   const errored = [];
   const deferred = [];
   const missing = /* @__PURE__ */ new Set();
-  const wt = resolve4(args.worktree);
+  const wt = resolve5(args.worktree);
   const wtReal = realIfExists(wt);
   for (const f of files) {
     const path3 = typeof f?.path === "string" ? f.path : "";
     if (!path3) continue;
-    const abs = resolve4(join7(args.worktree, path3));
-    const escapes = /* @__PURE__ */ __name((p, root) => p !== root && !p.startsWith(root + sep), "escapes");
+    const abs = resolve5(join8(args.worktree, path3));
+    const escapes = /* @__PURE__ */ __name((p, root) => p !== root && !p.startsWith(root + sep2), "escapes");
     const real = realIfExists(abs);
     if (escapes(abs, wt) || wtReal && real && escapes(real, wtReal)) {
       const byName = pathTool(path3);
@@ -6365,7 +6959,7 @@ var scriptLintCommand = {
       const report = runScriptLint(args);
       const json = JSON.stringify(report, null, 2);
       if (args.out) {
-        mkdirSync4(dirname3(resolve4(args.out)), { recursive: true });
+        mkdirSync4(dirname4(resolve5(args.out)), { recursive: true });
         writeFileSync4(args.out, json);
       }
       writeStdoutLine(json);
@@ -6496,8 +7090,8 @@ __name(contextRoleRunsInThisReview, "contextRoleRunsInThisReview");
 
 // packages/cli/src/commands/review/lib/deadline.ts
 init_esbuild_shims();
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync7, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join8 } from "node:path";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, statSync as statSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join9 } from "node:path";
 var DEADLINE_ENV = "QWEN_REVIEW_DEADLINE_EPOCH";
 var RESERVE_ENV = "QWEN_REVIEW_DEADLINE_RESERVE_SECONDS";
 var DEFAULT_RESERVE_SECONDS = 4800;
@@ -6508,7 +7102,7 @@ var STOP_FILE = "budget-stop.json";
 var RUN_EPOCH_SLACK_MS = 2e3;
 function runEpochMs(planPath) {
   try {
-    return statSync3(planPath).mtimeMs - RUN_EPOCH_SLACK_MS;
+    return statSync4(planPath).mtimeMs - RUN_EPOCH_SLACK_MS;
   } catch {
     return Number.NEGATIVE_INFINITY;
   }
@@ -6516,8 +7110,8 @@ function runEpochMs(planPath) {
 __name(runEpochMs, "runEpochMs");
 function readRoundStamps(planPath) {
   try {
-    const raw = readFileSync7(
-      join8(promptRecordDir(planPath), STAMPS_FILE),
+    const raw = readFileSync8(
+      join9(promptRecordDir(planPath), STAMPS_FILE),
       "utf8"
     );
     const parsed = JSON.parse(raw);
@@ -6538,7 +7132,7 @@ function stampRound(planPath, round, nowMs = Date.now()) {
     stamps.push({ round: round ?? null, atMs: nowMs });
     const dir = promptRecordDir(planPath);
     mkdirSync5(dir, { recursive: true });
-    writeFileSync5(join8(dir, STAMPS_FILE), JSON.stringify(stamps));
+    writeFileSync5(join9(dir, STAMPS_FILE), JSON.stringify(stamps));
   } catch {
   }
 }
@@ -6613,15 +7207,15 @@ function writeBudgetStop(planPath, spent, round, nowMs = Date.now()) {
       reserveSeconds: spent.reserveSeconds,
       atMs: nowMs
     };
-    writeFileSync5(join8(dir, STOP_FILE), JSON.stringify(stop, null, 2));
+    writeFileSync5(join9(dir, STOP_FILE), JSON.stringify(stop, null, 2));
   } catch {
   }
 }
 __name(writeBudgetStop, "writeBudgetStop");
 function readBudgetStop(planPath) {
   try {
-    const raw = readFileSync7(
-      join8(promptRecordDir(planPath), STOP_FILE),
+    const raw = readFileSync8(
+      join9(promptRecordDir(planPath), STOP_FILE),
       "utf8"
     );
     const parsed = JSON.parse(raw);
@@ -6643,6 +7237,157 @@ function reverseAuditBudgetMessage(spent, round) {
 }
 __name(reverseAuditBudgetMessage, "reverseAuditBudgetMessage");
 
+// packages/cli/src/commands/review/lib/budget.ts
+init_esbuild_shims();
+var SWEEP_FLOOR = 25;
+var SPECIALIST_FLOOR = 80;
+var LINES_PER_ANGLE = 60;
+var MIN_INLINE_ANGLES = 3;
+var MAX_INLINE_ANGLES = 6;
+var VERIFY_SHARD = 8;
+var MIN_AGENT_TOOL_BUDGET = 30;
+var MAX_AGENT_TOOL_BUDGET = 60;
+var LINES_PER_TOOL_CALL = 20;
+function reviewBudget(input) {
+  const src = sane(input.srcDiffLines);
+  const total = sane(input.diffLines);
+  const effective = Math.max(src, Math.floor(total / 8));
+  const extraAngles = Math.floor(effective / LINES_PER_ANGLE);
+  const inlineAngles = clamp(
+    MIN_INLINE_ANGLES + extraAngles,
+    MIN_INLINE_ANGLES,
+    MAX_INLINE_ANGLES
+  );
+  return {
+    inlineAngles,
+    sweep: effective >= SWEEP_FLOOR,
+    specialistCap: src >= SPECIALIST_FLOOR ? 2 : 0,
+    verifyShard: VERIFY_SHARD,
+    agentToolBudget: clamp(
+      MIN_AGENT_TOOL_BUDGET + Math.floor(effective / LINES_PER_TOOL_CALL),
+      MIN_AGENT_TOOL_BUDGET,
+      MAX_AGENT_TOOL_BUDGET
+    )
+  };
+}
+__name(reviewBudget, "reviewBudget");
+var MAX_TOTAL_TOOL_CALLS = 200;
+function launchToolBudget(planBudget, territoryLines, mandatoryReads) {
+  const base = clamp(
+    sane(planBudget) || MIN_AGENT_TOOL_BUDGET,
+    MIN_AGENT_TOOL_BUDGET,
+    MAX_AGENT_TOOL_BUDGET
+  );
+  const allowance = territoryLines === null ? base : Math.min(
+    base,
+    clamp(
+      MIN_AGENT_TOOL_BUDGET + Math.floor(sane(territoryLines) / LINES_PER_TOOL_CALL),
+      MIN_AGENT_TOOL_BUDGET,
+      MAX_AGENT_TOOL_BUDGET
+    )
+  );
+  return Math.min(
+    MAX_TOTAL_TOOL_CALLS,
+    allowance + Math.max(0, Math.floor(sane(mandatoryReads)))
+  );
+}
+__name(launchToolBudget, "launchToolBudget");
+var BUDGET_GAP_LINE_RE = /^[ \t]*(?:[-*+]|\d+[.)])?[ \t]*(`?)[*_~]{0,3}(?:budget gap|预算(?:缺口|不足|用尽))[*_~]{0,3}[ \t]*[:：][*_~]{0,3}[ \t]*(.+?)[ \t]*$/i;
+var GAP_HINT_RE = /budget gap|预算(?:缺口|不足|用尽)/i;
+var INLINE_BUDGET_GAP_RE = /(?:budget gap|预算(?:缺口|不足|用尽))[*_~`]{0,3}[ \t]*[:：]/i;
+var PLACEHOLDER_GAP_RE = /^(?:<[^>]*>|none\b.*|n\/a\b.*|nothing\b.*|no (?:gaps?|checks?)\b.*|[-—*_~`]+)$/i;
+var MAX_GAP_LENGTH = 160;
+var MAX_GAPS_PER_AGENT = 8;
+var DANGEROUS_CHARS_RE = (
+  // eslint-disable-next-line no-control-regex
+  /[\u0000-\u001f\u007f-\u009f\u2028\u2029\u202a-\u202e]/g
+);
+var WRAPPER_PAIRS = [
+  ["**", "**"],
+  ["__", "__"],
+  ["*", "*"],
+  ["_", "_"],
+  ["~", "~"],
+  ["`", "`"]
+];
+function stripWrappers(s) {
+  let out = s;
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [open, close] of WRAPPER_PAIRS) {
+      if (out.length > open.length + close.length && out.startsWith(open) && out.endsWith(close)) {
+        out = out.slice(open.length, out.length - close.length).trim();
+        changed = true;
+      }
+    }
+  }
+  return out;
+}
+__name(stripWrappers, "stripWrappers");
+function truncateGap(s) {
+  const points = [...s];
+  return points.length > MAX_GAP_LENGTH ? `${points.slice(0, MAX_GAP_LENGTH).join("")}\u2026` : s;
+}
+__name(truncateGap, "truncateGap");
+function budgetGapDisclosures(finalText) {
+  if (!GAP_HINT_RE.test(finalText)) return [];
+  const gaps = [];
+  const seen = /* @__PURE__ */ new Set();
+  let inFence = false;
+  for (const line of finalText.split(/\r?\n/)) {
+    if (/^[ \t]*(?:```|~~~)/.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    if (/^[ \t]*>/.test(line)) continue;
+    const m = BUDGET_GAP_LINE_RE.exec(line.replace(DANGEROUS_CHARS_RE, " "));
+    if (!m) continue;
+    let raw = m[2] ?? "";
+    if (m[1] === "`") {
+      if (!raw.endsWith("`")) continue;
+      raw = raw.slice(0, -1);
+    }
+    raw = stripWrappers(raw.trim()).trim();
+    const normalized = raw.replace(/[.!…,;:\s]+$/, "").trim();
+    if (normalized.length === 0 || PLACEHOLDER_GAP_RE.test(normalized)) {
+      continue;
+    }
+    const key = normalized.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    gaps.push(truncateGap(raw));
+    if (gaps.length >= MAX_GAPS_PER_AGENT) break;
+  }
+  return gaps;
+}
+__name(budgetGapDisclosures, "budgetGapDisclosures");
+function stripBudgetGapLines(finalText) {
+  if (!GAP_HINT_RE.test(finalText)) return finalText;
+  const kept = [];
+  let inFence = false;
+  for (const line of finalText.split(/\r?\n/)) {
+    const fence = /^[ \t]*(?:```|~~~)/.test(line);
+    if (fence) inFence = !inFence;
+    if (!fence && !inFence && !/^[ \t]*>/.test(line) && BUDGET_GAP_LINE_RE.test(line)) {
+      continue;
+    }
+    kept.push(line);
+  }
+  return kept.join("\n");
+}
+__name(stripBudgetGapLines, "stripBudgetGapLines");
+function sane(n) {
+  const v = Number(n);
+  return Number.isFinite(v) && v > 0 ? Math.floor(v) : 0;
+}
+__name(sane, "sane");
+function clamp(v, lo, hi) {
+  return Math.min(hi, Math.max(lo, v));
+}
+__name(clamp, "clamp");
+
 // packages/cli/src/commands/review/lib/shell-quote.ts
 init_esbuild_shims();
 function shellQuotePath(p) {
@@ -6652,7 +7397,7 @@ __name(shellQuotePath, "shellQuotePath");
 
 // packages/cli/src/commands/review/lib/coverage.ts
 function readPlan(path3) {
-  const plan = JSON.parse(readFileSync8(path3, "utf8"));
+  const plan = JSON.parse(readFileSync9(path3, "utf8"));
   if (typeof plan?.diffPathAbsolute !== "string" || !plan.diffPathAbsolute) {
     throw new Error(`coverage: ${path3} has no diffPathAbsolute`);
   }
@@ -6663,7 +7408,7 @@ function readPlan(path3) {
   if (problem) {
     throw new Error(`coverage: ${path3} has ${problem}`);
   }
-  return { plan, mtimeMs: statSync4(path3).mtimeMs };
+  return { plan, mtimeMs: statSync5(path3).mtimeMs };
 }
 __name(readPlan, "readPlan");
 var CHUNK_RE = /\bchunk\s+(\d+)\s+of\s+\d+\b/i;
@@ -6787,6 +7532,37 @@ function coverageFromTranscripts(planPath, env = process.env) {
     return false;
   }, "keySatisfied");
   const superseded = /* @__PURE__ */ __name((rec, chunk2) => chunk2 !== null ? chunkSatisfied(chunk2, rec) : keySatisfied(rec), "superseded");
+  const gapsMemo = /* @__PURE__ */ new Map();
+  const gapsOf = /* @__PURE__ */ __name((rec) => {
+    let g = gapsMemo.get(rec);
+    if (g === void 0) {
+      g = budgetGapDisclosures(rec.finalText);
+      gapsMemo.set(rec, g);
+    }
+    return g;
+  }, "gapsOf");
+  const gapsSuperseded = /* @__PURE__ */ __name((rec, chunk2) => {
+    if (chunk2 !== null) {
+      const b = builtOf(`chunk-${chunk2}`);
+      if (b === void 0) return false;
+      return records.some(
+        (r) => r !== rec && assignedChunk(r) === chunk2 && wasDeliveredVerbatim(r.launchPrompt, b) && r.diffToolCalls > 0 && gapsOf(r).length === 0
+      );
+    }
+    for (const key of built.keys()) {
+      const b = builtOf(key);
+      if (b === void 0) continue;
+      if (!wasDeliveredVerbatim(rec.launchPrompt, b)) continue;
+      const needle = JSON.stringify(briefPath(planPath, key));
+      if (records.some(
+        (r) => r !== rec && wasDeliveredVerbatim(r.launchPrompt, b) && r.successfulCallArgs.some((a) => a.includes(needle)) && gapsOf(r).length === 0
+      )) {
+        return true;
+      }
+    }
+    return false;
+  }, "gapsSuperseded");
+  const budgetGaps = [];
   for (const rec of records) {
     const chunk2 = assignedChunk(rec);
     const name = label(rec, chunk2);
@@ -6844,6 +7620,10 @@ function coverageFromTranscripts(planPath, env = process.env) {
       }
       continue;
     }
+    const gaps = gapsOf(rec);
+    if (gaps.length > 0 && !gapsSuperseded(rec, chunk2)) {
+      budgetGaps.push({ agent: name, gaps });
+    }
     const ranges = merge([...told, ...rec.diffReads]);
     if (ranges.length === 0) continue;
     const u = UNCOVERABLE_RE.exec(rec.finalText);
@@ -7001,6 +7781,7 @@ function coverageFromTranscripts(planPath, env = process.env) {
     unreadBriefs,
     missingChunks,
     uncoverableChunks: [...uncoverable].sort((a, b) => a - b),
+    budgetGaps,
     coveredChunks: [...covered].sort((a, b) => a - b),
     plannedChunks: plan.chunks.map((c) => ({
       id: c.id,
@@ -7167,193 +7948,59 @@ function verificationGaps(planPath, opts, env = process.env) {
   }
   let unverifiedFindings = false;
   let verify = null;
-  if (opts.postsFindings) {
-    const verifyKeys = [...built.keys()].filter(
-      (k) => k === "verify" || k.startsWith("verify--")
-    );
-    verify = bestDelivery(verifyKeys);
-    if (verify !== "ok") {
-      unverifiedFindings = true;
-      remediation.push(
-        `verification: ${VERIFY_GAP[verify].fix.replace(
-          "--plan <plan>",
-          // A function replacer: a plain string gives `$&`/`$\`` special
-          // meaning, and a path is not a place for replacement patterns.
-          () => `--plan ${shellQuotePath(planPath)}`
-        )}`
-      );
-    }
-  }
-  if (reverseGap && verify !== null && verify === reverse) {
-    gaps.push({
-      subject: "verification and reverse audit",
-      reason: COMBINED_STEP45_GAP[reverse].en,
-      subjectZh: "\u9A8C\u8BC1\u4E0E\u53CD\u5411\u5BA1\u8BA1",
-      reasonZh: COMBINED_STEP45_GAP[reverse].zh
-    });
-  } else {
-    if (reverseGap) {
-      gaps.push({
-        subject: "reverse audit",
-        reason: REVERSE_AUDIT_GAP[reverse].gap,
-        subjectZh: "\u53CD\u5411\u5BA1\u8BA1",
-        reasonZh: REVERSE_AUDIT_GAP[reverse].gapZh
-      });
-    }
-    if (verify !== null && verify !== "ok") {
-      gaps.push({
-        subject: "verification",
-        reason: VERIFY_GAP[verify].gap,
-        subjectZh: "\u9A8C\u8BC1",
-        reasonZh: VERIFY_GAP[verify].gapZh
-      });
-    }
-  }
-  if (balancedMedium) {
-    gaps.push({
-      subject: "reverse audit",
-      reason: "not run \u2014 the balanced (medium) tier skips the second-look pass, so this verdict is capped at Comment rather than Approve",
-      subjectZh: "\u53CD\u5411\u5BA1\u8BA1",
-      reasonZh: "\u672A\u8FD0\u884C\u2014\u2014\u5747\u8861\uFF08medium\uFF09\u6863\u8DF3\u8FC7\u4E8C\u6B21\u5BA1\u67E5\u6B65\u9AA4\uFF0C\u56E0\u6B64\u672C\u6B21\u5224\u5B9A\u4E0A\u9650\u4E3A Comment\uFF0C\u4E0D\u4F1A Approve"
-    });
-  }
-  return { ok: gaps.length === 0, gaps, remediation, unverifiedFindings };
-}
-__name(verificationGaps, "verificationGaps");
-
-// packages/cli/src/commands/review/lib/gh.ts
-init_esbuild_shims();
-import { execFileSync as execFileSync2 } from "node:child_process";
-var MAX_RETRIES = 2;
-var BASE_DELAY_MS = 3e3;
-function sleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-__name(sleepSync, "sleepSync");
-var TRANSIENT_RE = /HTTP 5\d{2}|server is currently unavailable|service unavailable|bad gateway|internal server error/i;
-function isTransientGhError(err) {
-  const stderr = typeof err.stderr === "string" ? err.stderr : "";
-  const msg = err instanceof Error ? err.message : "";
-  return TRANSIENT_RE.test(stderr) || TRANSIENT_RE.test(msg);
-}
-__name(isTransientGhError, "isTransientGhError");
-function execGhWithRetry(args, options) {
-  const execOptions = {
-    encoding: "utf8",
-    maxBuffer: 64 * 1024 * 1024,
-    env: ghEnv(),
-    ...options.input !== void 0 ? { input: options.input } : {}
-  };
-  for (let attempt = 0; ; attempt++) {
-    try {
-      return execFileSync2("gh", args, execOptions).replace(/\r\n/g, "\n").trim();
-    } catch (err) {
-      if (attempt < MAX_RETRIES && isTransientGhError(err)) {
-        const delay = BASE_DELAY_MS * (attempt + 1);
-        process.stderr.write(
-          `gh transient error (attempt ${attempt + 1}/${MAX_RETRIES}), retrying in ${delay}ms\u2026
-`
-        );
-        sleepSync(delay);
-        continue;
-      }
-      throw err;
-    }
-  }
-}
-__name(execGhWithRetry, "execGhWithRetry");
-var ghHost;
-var HOSTNAME_RE = /^[A-Za-z0-9.-]+(?::\d+)?$/;
-function setGhHost(host) {
-  if (host === void 0 || host === "") {
-    ghHost = void 0;
-    return;
-  }
-  if (!HOSTNAME_RE.test(host)) {
-    throw new TypeError(
-      `--host must be a hostname (optionally :port), got ${JSON.stringify(host)}`
-    );
-  }
-  ghHost = host;
-}
-__name(setGhHost, "setGhHost");
-function getGhHost() {
-  return ghHost;
-}
-__name(getGhHost, "getGhHost");
-function ghEnv() {
-  return ghHost ? { ...process.env, GH_HOST: ghHost } : void 0;
-}
-__name(ghEnv, "ghEnv");
-function gh(...args) {
-  return execGhWithRetry(args, {});
-}
-__name(gh, "gh");
-function ghWithInputRetried(input, ...args) {
-  return execGhWithRetry(args, { input });
-}
-__name(ghWithInputRetried, "ghWithInputRetried");
-function ghWithInput(input, ...args) {
-  return execFileSync2("gh", args, {
-    encoding: "utf8",
-    maxBuffer: 64 * 1024 * 1024,
-    env: ghEnv(),
-    input
-  }).replace(/\r\n/g, "\n").trim();
-}
-__name(ghWithInput, "ghWithInput");
-function ghApiAll(path3) {
-  const out = gh("api", "--paginate", path3);
-  if (!out) return [];
-  const parsed = JSON.parse(out);
-  return Array.isArray(parsed) ? parsed : [];
-}
-__name(ghApiAll, "ghApiAll");
-function ghApiAllNested(path3, key) {
-  return parseNdjson(gh("api", "--paginate", path3, "--jq", `.${key}[]`), {
-    strict: true
-  });
-}
-__name(ghApiAllNested, "ghApiAllNested");
-function parseNdjson(out, opts = {}) {
-  const strict = opts.strict ?? true;
-  if (!out) return [];
-  const values = [];
-  for (const line of out.split("\n")) {
-    if (line.trim().length === 0) continue;
-    if (strict) {
-      values.push(JSON.parse(line));
-      continue;
-    }
-    try {
-      values.push(JSON.parse(line));
-    } catch {
+  if (opts.postsFindings) {
+    const verifyKeys = [...built.keys()].filter(
+      (k) => k === "verify" || k.startsWith("verify--")
+    );
+    verify = bestDelivery(verifyKeys);
+    if (verify !== "ok") {
+      unverifiedFindings = true;
+      remediation.push(
+        `verification: ${VERIFY_GAP[verify].fix.replace(
+          "--plan <plan>",
+          // A function replacer: a plain string gives `$&`/`$\`` special
+          // meaning, and a path is not a place for replacement patterns.
+          () => `--plan ${shellQuotePath(planPath)}`
+        )}`
+      );
     }
   }
-  return values;
-}
-__name(parseNdjson, "parseNdjson");
-function currentUser() {
-  return gh("api", "user", "--jq", ".login");
-}
-__name(currentUser, "currentUser");
-function ensureAuthenticated() {
-  for (let attempt = 0; ; attempt++) {
-    try {
-      execFileSync2("gh", ["auth", "status"], { stdio: "pipe", env: ghEnv() });
-      return;
-    } catch (err) {
-      if (attempt === 0 && err.code !== "ENOENT") {
-        sleepSync(2e3);
-        continue;
-      }
-      throw new Error(
-        "gh CLI is not authenticated. Run `gh auth login` and retry."
-      );
+  if (reverseGap && verify !== null && verify === reverse) {
+    gaps.push({
+      subject: "verification and reverse audit",
+      reason: COMBINED_STEP45_GAP[reverse].en,
+      subjectZh: "\u9A8C\u8BC1\u4E0E\u53CD\u5411\u5BA1\u8BA1",
+      reasonZh: COMBINED_STEP45_GAP[reverse].zh
+    });
+  } else {
+    if (reverseGap) {
+      gaps.push({
+        subject: "reverse audit",
+        reason: REVERSE_AUDIT_GAP[reverse].gap,
+        subjectZh: "\u53CD\u5411\u5BA1\u8BA1",
+        reasonZh: REVERSE_AUDIT_GAP[reverse].gapZh
+      });
+    }
+    if (verify !== null && verify !== "ok") {
+      gaps.push({
+        subject: "verification",
+        reason: VERIFY_GAP[verify].gap,
+        subjectZh: "\u9A8C\u8BC1",
+        reasonZh: VERIFY_GAP[verify].gapZh
+      });
     }
   }
+  if (balancedMedium) {
+    gaps.push({
+      subject: "reverse audit",
+      reason: "not run \u2014 the balanced (medium) tier skips the second-look pass, so this verdict is capped at Comment rather than Approve",
+      subjectZh: "\u53CD\u5411\u5BA1\u8BA1",
+      reasonZh: "\u672A\u8FD0\u884C\u2014\u2014\u5747\u8861\uFF08medium\uFF09\u6863\u8DF3\u8FC7\u4E8C\u6B21\u5BA1\u67E5\u6B65\u9AA4\uFF0C\u56E0\u6B64\u672C\u6B21\u5224\u5B9A\u4E0A\u9650\u4E3A Comment\uFF0C\u4E0D\u4F1A Approve"
+    });
+  }
+  return { ok: gaps.length === 0, gaps, remediation, unverifiedFindings };
 }
-__name(ensureAuthenticated, "ensureAuthenticated");
+__name(verificationGaps, "verificationGaps");
 
 // packages/cli/src/commands/review/lib/ledger.ts
 init_esbuild_shims();
@@ -7529,16 +8176,16 @@ __name(composeReview, "composeReview");
 function ledgerMarkerFor(input) {
   try {
     if (!input.planPath) return null;
-    const plan = JSON.parse(readFileSync9(input.planPath, "utf8"));
+    const plan = JSON.parse(readFileSync10(input.planPath, "utf8"));
     const pr = plan?.prNumber;
     const isPr = typeof pr === "number" && Number.isInteger(pr) && pr > 0 || typeof pr === "string" && /^\d+$/.test(pr);
     if (!isPr) return null;
     let prevRound = 0;
     try {
       const prev = JSON.parse(
-        readFileSync9(
-          join9(
-            dirname4(input.planPath),
+        readFileSync10(
+          join10(
+            dirname5(input.planPath),
             `qwen-review-pr-${pr}-prev-ledger.json`
           ),
           "utf8"
@@ -7598,6 +8245,8 @@ function composeReviewBody(input, cliVersion) {
     }
   }
   const remediation = [];
+  const budgetGapNotes = [];
+  const MAX_BUDGET_GAP_LINES = 5;
   const planRef = input.planPath ? shellQuotePath(input.planPath) : "<plan>";
   const missingReceipts = [];
   let plannedChunks = [];
@@ -7676,6 +8325,7 @@ function composeReviewBody(input, cliVersion) {
           "agents that never opened the diff: relaunch each with the same printed prompt \u2014 the prompt already names the diff and its ranges; the read is what proves the review happened"
         );
       }
+      budgetGapNotes.push(...cov.budgetGaps);
       coverageEntries.push(...cov.disclosures);
       if (cov.rewrittenPrompts.length > 0) {
         remediation.push(
@@ -7740,7 +8390,7 @@ function composeReviewBody(input, cliVersion) {
       );
     }
     try {
-      const findingsContent = readFileSync9(findingsPath, "utf8");
+      const findingsContent = readFileSync10(findingsPath, "utf8");
       unverifiedTagCount = (findingsContent.match(UNVERIFIED_FINDING_TAG_RE) ?? []).length;
       findingsUnverifiedAtCompose = unverifiedTagCount > 0;
       if (findingsUnverifiedAtCompose) {
@@ -7826,7 +8476,7 @@ function composeReviewBody(input, cliVersion) {
   if (event2 === "APPROVE" && input.planPath) {
     let plan;
     try {
-      plan = JSON.parse(readFileSync9(input.planPath, "utf8"));
+      plan = JSON.parse(readFileSync10(input.planPath, "utf8"));
     } catch {
     }
     if (plan) {
@@ -7838,10 +8488,10 @@ function composeReviewBody(input, cliVersion) {
   }
   const footer = reviewFooter(modelId, cliVersion);
   const bilingual = bilingualFromPlan(input.planPath, input.prBodyFetcher);
-  const render = /* @__PURE__ */ __name((parts, sep8) => {
-    const en = parts.map((p) => p.en).join(sep8);
+  const render = /* @__PURE__ */ __name((parts, sep9) => {
+    const en = parts.map((p) => p.en).join(sep9);
     if (en === "") return "";
-    const zh = parts.map((p) => p.zh).join(sep8);
+    const zh = parts.map((p) => p.zh).join(sep9);
     const text = bilingual && zh !== en ? `${en}
 
 <details>
@@ -7913,6 +8563,23 @@ ${footer}`;
       zh: `\u672A\u5BA1\u67E5\uFF1A${d}\u3002`
     });
   }
+  const budgetGapItems = [];
+  for (const g of budgetGapNotes) {
+    for (const gap of g.gaps) budgetGapItems.push({ agent: g.agent, gap });
+  }
+  const keptBudgetGaps = budgetGapItems.filter(
+    (it) => !unreviewed.some((d) => d.includes(it.gap))
+  );
+  if (keptBudgetGaps.length > 0) {
+    const shown = keptBudgetGaps.slice(0, MAX_BUDGET_GAP_LINES);
+    const more = keptBudgetGaps.length - shown.length;
+    const enList = shown.map((it) => `${it.agent}: ${mdField(it.gap)}`).join("; ") + (more > 0 ? `, and ${more} more` : "");
+    const zhList = shown.map((it) => `${it.agent}\uFF1A${mdField(it.gap)}`).join("\uFF1B") + (more > 0 ? `\uFF0C\u53E6\u6709 ${more} \u6761` : "");
+    notReviewedParts.push({
+      en: `Not explored to full depth (tool budget reached): ${enList}.`,
+      zh: `\u672A\u63A2\u7D22\u5230\u5168\u90E8\u6DF1\u5EA6\uFF08\u8FBE\u5230\u5DE5\u5177\u8C03\u7528\u9884\u7B97\uFF09\uFF1A${zhList}\u3002`
+    });
+  }
   const seenSubjects = /* @__PURE__ */ new Set();
   const byReason = /* @__PURE__ */ new Map();
   const reasonZhOf = /* @__PURE__ */ new Map();
@@ -8020,11 +8687,12 @@ ${footer}`;
       body: render(
         [
           { en: "No issues found. LGTM! \u2705", zh: "\u672A\u53D1\u73B0\u95EE\u9898\u3002LGTM\uFF01\u2705" },
+          ...notReviewedParts,
           ...deferredBlock,
           ...testPlanBlock,
           ...repositoryContextBlock2
         ],
-        deferredBlock.length || testPlanBlock.length || repositoryContextBlock2.length ? "\n\n" : " "
+        notReviewedParts.length || deferredBlock.length || testPlanBlock.length || repositoryContextBlock2.length ? "\n\n" : " "
       ),
       baseEvent,
       cappedBy,
@@ -8050,7 +8718,12 @@ ${footer}`;
     // body could open "Reviewed — no blockers." two lines above "nobody read
     // them." Nothing nobody read can be certified blocker-free — and neither
     // can a loop that ended with findings no verifier ever ruled on.
-    missingReceipts.length === 0 && !findingsUnverifiedAtCompose;
+    missingReceipts.length === 0 && // A disclosed budget gap is not a blocker, but "Reviewed — no
+    // blockers." two lines above "Not explored to full depth" is the
+    // opener certifying what the disclosure takes back — the exact
+    // shape the comment below forbids. (A gap the caller promoted into
+    // `unreviewedDimensions` already denies certification above.)
+    keptBudgetGaps.length === 0 && !findingsUnverifiedAtCompose;
     const disclosedChunkIds = /* @__PURE__ */ new Set();
     for (const e of coverageEntries) {
       const m = /^chunk (\d+)$/.exec(e.subject);
@@ -8139,7 +8812,7 @@ var fetchPrBodyViaGh = /* @__PURE__ */ __name((ownerRepo, prNumber) => {
 function repositoryContextGate(planPath) {
   let plan;
   try {
-    plan = JSON.parse(readFileSync9(planPath, "utf8"));
+    plan = JSON.parse(readFileSync10(planPath, "utf8"));
   } catch {
     return [];
   }
@@ -8161,7 +8834,7 @@ function scriptLintGate(planPath) {
   const disclosed = [];
   let plan;
   try {
-    plan = JSON.parse(readFileSync9(planPath, "utf8"));
+    plan = JSON.parse(readFileSync10(planPath, "utf8"));
   } catch {
     unreviewed.push(
       "the executable-script lint \u2014 could not read the plan to check the gate"
@@ -8172,13 +8845,13 @@ function scriptLintGate(planPath) {
     return { criticals, unreviewed, disclosed };
   }
   const owed = hasExecutableScript(plan);
-  const reportPath = join9(
-    dirname4(planPath),
+  const reportPath = join10(
+    dirname5(planPath),
     scriptLintReportName(plan.prNumber)
   );
   let report;
   try {
-    report = JSON.parse(readFileSync9(reportPath, "utf8"));
+    report = JSON.parse(readFileSync10(reportPath, "utf8"));
   } catch {
     if (owed) {
       unreviewed.push(
@@ -8234,7 +8907,7 @@ function testPlanGate(planPath) {
   const notes = [];
   let plan;
   try {
-    plan = JSON.parse(readFileSync9(planPath, "utf8"));
+    plan = JSON.parse(readFileSync10(planPath, "utf8"));
   } catch {
     return { notes };
   }
@@ -8244,8 +8917,8 @@ function testPlanGate(planPath) {
   let report;
   try {
     report = JSON.parse(
-      readFileSync9(
-        join9(dirname4(planPath), `qwen-review-pr-${pr}-test-plan.json`),
+      readFileSync10(
+        join10(dirname5(planPath), `qwen-review-pr-${pr}-test-plan.json`),
         "utf8"
       )
     );
@@ -8278,7 +8951,7 @@ function bilingualFromPlan(planPath, fetchPrBody2 = fetchPrBodyViaGh) {
   if (!planPath) return false;
   let plan;
   try {
-    plan = JSON.parse(readFileSync9(planPath, "utf8"));
+    plan = JSON.parse(readFileSync10(planPath, "utf8"));
   } catch {
     return false;
   }
@@ -8298,7 +8971,7 @@ __name(bilingualFromPlan, "bilingualFromPlan");
 function readDraftedComments(path3) {
   let raw;
   try {
-    raw = readFileSync9(path3, "utf8");
+    raw = readFileSync10(path3, "utf8");
   } catch (err) {
     throw new Error(
       `compose-review: cannot read the comments file ${path3}: ${err.message}. Pass the drafted inline comments \u2014 the same array the review payload will carry \u2014 or a file containing [] when nothing anchors inline.`
@@ -8352,7 +9025,7 @@ var composeReviewCommand = {
         "compose-review: --comments is required \u2014 the inline counts are counted from the drafted comments file, never typed. Pass a file containing [] when nothing anchors inline."
       );
     }
-    const raw = readFileSync9(input ?? 0, "utf8");
+    const raw = readFileSync10(input ?? 0, "utf8");
     const parsed = JSON.parse(raw);
     delete parsed.env;
     delete parsed.prBodyFetcher;
@@ -8379,7 +9052,7 @@ var composeReviewCommand = {
       2
     );
     if (out) {
-      mkdirSync6(dirname4(out), { recursive: true });
+      mkdirSync6(dirname5(out), { recursive: true });
       writeFileSync6(out, json, "utf8");
     }
     writeStdoutLine(json);
@@ -8482,8 +9155,8 @@ __name(verdictLine, "verdictLine");
 
 // packages/cli/src/commands/review/findings.ts
 init_esbuild_shims();
-import { existsSync as existsSync3, readFileSync as readFileSync10, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "node:fs";
-import { dirname as dirname5, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "node:fs";
+import { dirname as dirname6, resolve as resolve6 } from "node:path";
 var SEVERITIES = ["Critical", "Suggestion", "Nice to have"];
 var CONFIDENCES = ["high", "low"];
 var OUTCOMES = ["fixed", "skipped", "no_change_needed"];
@@ -8856,7 +9529,7 @@ __name(renderFindings, "renderFindings");
 function readJson(path3, what) {
   let text;
   try {
-    text = readFileSync10(resolve5(path3), "utf8");
+    text = readFileSync11(resolve6(path3), "utf8");
   } catch (err) {
     throw new Error(
       `Could not read the ${what} file at ${JSON.stringify(path3)}: ${err instanceof Error ? err.message : String(err)}`
@@ -8905,7 +9578,7 @@ var findingsCommand = {
     let readjudicated = [];
     if (testDelta !== void 0) {
       let measurement;
-      if (existsSync3(resolve5(testDelta))) {
+      if (existsSync5(resolve6(testDelta))) {
         try {
           measurement = readJson(testDelta, "test-delta");
         } catch (err) {
@@ -8926,8 +9599,8 @@ var findingsCommand = {
       ));
     }
     const report = buildReport(findings);
-    const target = resolve5(out);
-    mkdirSync7(dirname5(target), { recursive: true });
+    const target = resolve6(out);
+    mkdirSync7(dirname6(target), { recursive: true });
     writeFileSync7(target, `${JSON.stringify(report, null, 2)}
 `, "utf8");
     const { bySeverity, byConfidence } = report.counts;
@@ -8959,90 +9632,8 @@ var findingsCommand = {
 // packages/cli/src/commands/review/fetch-pr.ts
 init_esbuild_shims();
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname6, resolve as resolve6 } from "node:path";
-
-// packages/cli/src/commands/review/lib/git.ts
-init_esbuild_shims();
-import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync4, rmSync as rmSync3 } from "node:fs";
-var GIT_TIMEOUT_MS2 = 12e4;
-function gitOpts() {
-  return {
-    timeout: GIT_TIMEOUT_MS2,
-    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
-  };
-}
-__name(gitOpts, "gitOpts");
-function git(...args) {
-  return execFileSync3("git", args, { ...gitOpts(), encoding: "utf8" }).replace(/\r\n/g, "\n").trim();
-}
-__name(git, "git");
-function gitWithInput(input, args) {
-  return execFileSync3("git", args, { ...gitOpts(), encoding: "utf8", input }).replace(/\r\n/g, "\n").trim();
-}
-__name(gitWithInput, "gitWithInput");
-function gitOpt(...args) {
-  try {
-    return execFileSync3("git", args, {
-      ...gitOpts(),
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"]
-    }).replace(/\r\n/g, "\n").trim();
-  } catch {
-    return null;
-  }
-}
-__name(gitOpt, "gitOpt");
-function refExists(ref) {
-  return gitOpt("rev-parse", "--verify", "--quiet", ref) !== null;
-}
-__name(refExists, "refExists");
-function worktreeReleaseResult(existed, stillThere, removeError) {
-  const freed = existed && !stillThere;
-  if (!existed || freed) {
-    return { existed, freed, reason: void 0 };
-  }
-  return {
-    existed,
-    freed,
-    reason: removeError ? removeError instanceof Error ? removeError.message : String(removeError) : "the path is still there after `git worktree remove --force` and `rm -rf`"
-  };
-}
-__name(worktreeReleaseResult, "worktreeReleaseResult");
-function releaseWorktree(worktreePath2) {
-  const existed = existsSync4(worktreePath2);
-  let removeError;
-  if (existed) {
-    gitOpt("worktree", "remove", worktreePath2, "--force");
-    try {
-      rmSync3(worktreePath2, { recursive: true, force: true });
-    } catch (e) {
-      removeError = e;
-    }
-  }
-  gitOpt("worktree", "prune");
-  return worktreeReleaseResult(existed, existsSync4(worktreePath2), removeError);
-}
-__name(releaseWorktree, "releaseWorktree");
-function gitRaw(...args) {
-  return execFileSync3("git", args, {
-    ...gitOpts(),
-    maxBuffer: 512 * 1024 * 1024,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-}
-__name(gitRaw, "gitRaw");
-function gitRawTolerateDiff(...args) {
-  try {
-    return gitRaw(...args);
-  } catch (err) {
-    const e = err;
-    if (e.status === 1 && e.stdout && e.stdout.length > 0) return e.stdout;
-    throw err;
-  }
-}
-__name(gitRawTolerateDiff, "gitRawTolerateDiff");
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname7, resolve as resolve7 } from "node:path";
 
 // packages/cli/src/commands/review/lib/diff-flags.ts
 init_esbuild_shims();
@@ -9067,11 +9658,11 @@ var LITERAL_PATHSPECS = "--literal-pathspecs";
 
 // packages/cli/src/commands/review/lib/effort.ts
 init_esbuild_shims();
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 function resolveEffort(explicit) {
   if (explicit && EFFORT_LEVELS.has(explicit)) return explicit;
   try {
-    const parsed = JSON.parse(readFileSync11(PARSE_ARGS_REPORT, "utf8"));
+    const parsed = JSON.parse(readFileSync12(PARSE_ARGS_REPORT, "utf8"));
     if (typeof parsed.effort === "string" && EFFORT_LEVELS.has(parsed.effort)) {
       return parsed.effort;
     }
@@ -9092,7 +9683,7 @@ __name(planEffortField, "planEffortField");
 
 // packages/cli/src/commands/review/lib/report.ts
 init_esbuild_shims();
-import { statSync as statSync5 } from "node:fs";
+import { statSync as statSync6 } from "node:fs";
 
 // packages/cli/src/commands/review/lib/heavy.ts
 init_esbuild_shims();
@@ -9109,42 +9700,6 @@ function classifyHeavy(input) {
 }
 __name(classifyHeavy, "classifyHeavy");
 
-// packages/cli/src/commands/review/lib/budget.ts
-init_esbuild_shims();
-var SWEEP_FLOOR = 25;
-var SPECIALIST_FLOOR = 80;
-var LINES_PER_ANGLE = 60;
-var MIN_INLINE_ANGLES = 3;
-var MAX_INLINE_ANGLES = 6;
-var VERIFY_SHARD = 8;
-function reviewBudget(input) {
-  const src = sane(input.srcDiffLines);
-  const total = sane(input.diffLines);
-  const effective = Math.max(src, Math.floor(total / 8));
-  const extraAngles = Math.floor(effective / LINES_PER_ANGLE);
-  const inlineAngles = clamp(
-    MIN_INLINE_ANGLES + extraAngles,
-    MIN_INLINE_ANGLES,
-    MAX_INLINE_ANGLES
-  );
-  return {
-    inlineAngles,
-    sweep: effective >= SWEEP_FLOOR,
-    specialistCap: src >= SPECIALIST_FLOOR ? 2 : 0,
-    verifyShard: VERIFY_SHARD
-  };
-}
-__name(reviewBudget, "reviewBudget");
-function sane(n) {
-  const v = Number(n);
-  return Number.isFinite(v) && v > 0 ? Math.floor(v) : 0;
-}
-__name(sane, "sane");
-function clamp(v, lo, hi) {
-  return Math.min(hi, Math.max(lo, v));
-}
-__name(clamp, "clamp");
-
 // packages/cli/src/commands/review/lib/report.ts
 function buildPlanReport(plan, postImageLines) {
   const files = plan.files.map((f) => {
@@ -9195,7 +9750,7 @@ __name(buildPlanReport, "buildPlanReport");
 function warnOnReportSize(path3, cap) {
   let size = 0;
   try {
-    size = statSync5(path3).size;
+    size = statSync6(path3).size;
   } catch {
     return;
   }
@@ -9318,7 +9873,7 @@ async function runFetchPr(args) {
     );
   }
   try {
-    mkdirSync8(dirname6(wt), { recursive: true });
+    mkdirSync8(dirname7(wt), { recursive: true });
     git("worktree", "add", wt, ref);
   } catch (err) {
     tryRemove(
@@ -9355,7 +9910,7 @@ async function runFetchPr(args) {
       writeFileSync8(diffRel, buf);
       diffText = buf.toString("utf8");
       diffPath = diffRel;
-      diffPathAbsolute = resolve6(diffRel);
+      diffPathAbsolute = resolve7(diffRel);
     } catch (err) {
       writeStderrLine(`Failed to capture diff: ${err.message}`);
     }
@@ -9379,7 +9934,7 @@ async function runFetchPr(args) {
   let auditSince = fetchedAt;
   let prevRaw = null;
   try {
-    prevRaw = readFileSync12(out, "utf8");
+    prevRaw = readFileSync13(out, "utf8");
   } catch (err) {
     const code = err.code;
     if (code !== "ENOENT") {
@@ -9547,12 +10102,12 @@ var fetchPrCommand = {
 // packages/cli/src/commands/review/capture-local.ts
 init_esbuild_shims();
 import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname7, resolve as resolve8 } from "node:path";
+import { dirname as dirname8, resolve as resolve9 } from "node:path";
 
 // packages/cli/src/commands/review/lib/local-diff.ts
 init_esbuild_shims();
-import { lstatSync as lstatSync2, statSync as statSync6, realpathSync as realpathSync2 } from "node:fs";
-import { join as join10, relative as relative2, resolve as resolve7, isAbsolute as isAbsolute2, sep as sep2 } from "node:path";
+import { lstatSync as lstatSync2, statSync as statSync7, realpathSync as realpathSync3 } from "node:fs";
+import { join as join11, relative as relative3, resolve as resolve8, isAbsolute as isAbsolute2, sep as sep3 } from "node:path";
 var MAX_UNTRACKED_BYTES = 1e6;
 var MAX_UNTRACKED_FILES = 500;
 var MAX_UNTRACKED_TOTAL_BYTES = 1e7;
@@ -9573,7 +10128,7 @@ function describeUndiffable(abs, st) {
   }
   if (st.isSymbolicLink()) {
     try {
-      return statSync6(abs).isDirectory() ? "is a symlink to a directory \u2014 git cannot diff it as a file" : null;
+      return statSync7(abs).isDirectory() ? "is a symlink to a directory \u2014 git cannot diff it as a file" : null;
     } catch {
       return null;
     }
@@ -9582,19 +10137,19 @@ function describeUndiffable(abs, st) {
 }
 __name(describeUndiffable, "describeUndiffable");
 function toRepoPathspec(repoRoot, file) {
-  let abs = resolve7(process.cwd(), file);
+  let abs = resolve8(process.cwd(), file);
   try {
-    abs = realpathSync2(abs);
+    abs = realpathSync3(abs);
   } catch {
   }
-  const rel = relative2(repoRoot, abs);
-  const escapes = rel === "" || rel === ".." || rel.startsWith(".." + sep2) || isAbsolute2(rel);
+  const rel = relative3(repoRoot, abs);
+  const escapes = rel === "" || rel === ".." || rel.startsWith(".." + sep3) || isAbsolute2(rel);
   if (escapes) {
     throw new Error(
       `--file ${file} resolves to ${abs}, which is outside the repository at ${repoRoot}.`
     );
   }
-  return rel.split(sep2).join("/");
+  return rel.split(sep3).join("/");
 }
 __name(toRepoPathspec, "toRepoPathspec");
 function isBinarySection(section) {
@@ -9678,7 +10233,7 @@ function captureLocalDiff(opts) {
       for (const path3 of candidates) {
         let bytes;
         try {
-          const abs = join10(repoRoot, path3);
+          const abs = join11(repoRoot, path3);
           const st = lstatSync2(abs);
           const kind = describeUndiffable(abs, st);
           if (kind) {
@@ -9771,13 +10326,13 @@ function runCaptureLocal(args) {
   });
   const diffText = capture.diff.toString("utf8");
   mkdirSync9(REVIEW_TMP_DIR, { recursive: true });
-  mkdirSync9(dirname7(resolve8(out)), { recursive: true });
+  mkdirSync9(dirname8(resolve9(out)), { recursive: true });
   const diffPath = tmpFile(target, "diff.txt");
   writeFileSync9(diffPath, capture.diff);
   const plan = buildDiffPlan(diffText);
   const result = {
     diffPath,
-    diffPathAbsolute: resolve8(diffPath),
+    diffPathAbsolute: resolve9(diffPath),
     // No ref to `git show` a pre-change file out of, so per-file line counts and
     // heaviness are unavailable — same as `plan-diff`. Chunk coverage, which is
     // what the topology needs, is not.
@@ -9844,13 +10399,13 @@ var captureLocalCommand = {
 
 // packages/cli/src/commands/review/plan-diff.ts
 init_esbuild_shims();
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync10, mkdirSync as mkdirSync10 } from "node:fs";
-import { resolve as resolve9 } from "node:path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync10, mkdirSync as mkdirSync10 } from "node:fs";
+import { resolve as resolve10 } from "node:path";
 function runPlanDiff(args) {
   const { diff_path: diffPath, out } = args;
   let diffText;
   try {
-    diffText = readFileSync13(diffPath, "utf8");
+    diffText = readFileSync14(diffPath, "utf8");
   } catch (err) {
     throw new Error(
       `Cannot read diff file ${diffPath}: ${err.message}`
@@ -9864,7 +10419,7 @@ function runPlanDiff(args) {
   const plan = buildDiffPlan(diffText, args.maxChunkLines);
   const result = {
     diffPath,
-    diffPathAbsolute: resolve9(diffPath),
+    diffPathAbsolute: resolve10(diffPath),
     // The PR identity, when the caller resolved one. This is what lets the
     // roster require Agent 0 on a lightweight cross-repo review — a diff-only
     // plan without it cannot demand an agent nobody could build. Passed only
@@ -9925,18 +10480,18 @@ var planDiffCommand = {
 // packages/cli/src/commands/review/repo-context.ts
 init_esbuild_shims();
 import {
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync11,
-  readFileSync as readFileSync14,
-  realpathSync as realpathSync4,
-  statSync as statSync8
+  readFileSync as readFileSync15,
+  realpathSync as realpathSync5,
+  statSync as statSync9
 } from "node:fs";
-import { dirname as dirname8, isAbsolute as isAbsolute4, relative as relative4, resolve as resolve11, sep as sep4 } from "node:path";
+import { dirname as dirname9, isAbsolute as isAbsolute4, relative as relative5, resolve as resolve12, sep as sep5 } from "node:path";
 
 // packages/cli/src/commands/review/lib/manifest-repository-context.ts
 init_esbuild_shims();
-import { lstatSync as lstatSync3, readdirSync as readdirSync4, realpathSync as realpathSync3, statSync as statSync7 } from "node:fs";
-import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve10, sep as sep3 } from "node:path";
+import { lstatSync as lstatSync3, readdirSync as readdirSync5, realpathSync as realpathSync4, statSync as statSync8 } from "node:fs";
+import { isAbsolute as isAbsolute3, relative as relative4, resolve as resolve11, sep as sep4 } from "node:path";
 var MANIFEST_PATH = ".qwen/review-context.json";
 var MAX_GLOB_CANDIDATES = 16384;
 var MAX_MATCH_WORK = 1024 * 1024 * 1024;
@@ -9945,12 +10500,15 @@ var MANIFEST_PREFIX = "repository context manifest ";
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
   ".git",
   ".next",
+  ".playwright",
   ".turbo",
   "coverage",
   "dist",
   "node_modules",
   "out",
-  "target"
+  "playwright-report",
+  "target",
+  "test-results"
 ]);
 var MANIFEST_KEYS = ["label", "rules", "version"].sort();
 var RULE_KEYS = [
@@ -10156,9 +10714,9 @@ function globMatches(pattern, path3) {
 __name(globMatches, "globMatches");
 function isContainedFile(worktree, path3) {
   try {
-    const resolved = realpathSync3(resolve10(worktree, path3));
-    const contained = relative3(worktree, resolved);
-    return contained !== "" && !isAbsolute3(contained) && contained !== ".." && !contained.startsWith(`..${sep3}`) && statSync7(resolved).isFile();
+    const resolved = realpathSync4(resolve11(worktree, path3));
+    const contained = relative4(worktree, resolved);
+    return contained !== "" && !isAbsolute3(contained) && contained !== ".." && !contained.startsWith(`..${sep4}`) && statSync8(resolved).isFile();
   } catch {
     return false;
   }
@@ -10202,7 +10760,7 @@ function expandRelatedPaths(worktree, patterns, changedPaths2) {
   const visit = /* @__PURE__ */ __name((directory) => {
     let entries;
     try {
-      const stat = lstatSync3(resolve10(worktree, directory));
+      const stat = lstatSync3(resolve11(worktree, directory));
       if (stat.isSymbolicLink()) return;
       if (!stat.isDirectory()) {
         candidates++;
@@ -10222,7 +10780,7 @@ function expandRelatedPaths(worktree, patterns, changedPaths2) {
         }
         return;
       }
-      entries = readdirSync4(resolve10(worktree, directory), {
+      entries = readdirSync5(resolve11(worktree, directory), {
         withFileTypes: true
       });
       if (candidates + entries.length > MAX_GLOB_CANDIDATES) {
@@ -10345,24 +10903,24 @@ var manifestRepositoryContextProvider = {
 var REPOSITORY_CONTEXT_PROVIDERS = [manifestRepositoryContextProvider];
 function sameFile(left, right) {
   if (left === right) return true;
-  if (!existsSync5(left) || !existsSync5(right)) return false;
-  const leftStat = statSync8(left);
-  const rightStat = statSync8(right);
+  if (!existsSync6(left) || !existsSync6(right)) return false;
+  const leftStat = statSync9(left);
+  const rightStat = statSync9(right);
   return leftStat.dev === rightStat.dev && leftStat.ino === rightStat.ino;
 }
 __name(sameFile, "sameFile");
 function recordedWorktreeMatches(recordedPath, worktree) {
-  const candidates = [resolve11(recordedPath)];
+  const candidates = [resolve12(recordedPath)];
   if (!isAbsolute4(recordedPath)) {
     const commonDir = gitOpt("-C", worktree, "rev-parse", "--git-common-dir");
     if (commonDir !== null) {
       candidates.push(
-        resolve11(dirname8(resolve11(worktree, commonDir)), recordedPath)
+        resolve12(dirname9(resolve12(worktree, commonDir)), recordedPath)
       );
     }
   }
   return candidates.some(
-    (candidate) => existsSync5(candidate) && realpathSync4(candidate) === worktree
+    (candidate) => existsSync6(candidate) && realpathSync5(candidate) === worktree
   );
 }
 __name(recordedWorktreeMatches, "recordedWorktreeMatches");
@@ -10416,7 +10974,7 @@ function readBaseBlob(worktree, mergeBase, path3) {
 __name(readBaseBlob, "readBaseBlob");
 function resolveTreeSymlinkTarget(fromPath, target) {
   if (target.startsWith("/") || /^[A-Za-z]:/.test(target)) return null;
-  const segments = `${dirname8(fromPath)}/${target}`.split("/");
+  const segments = `${dirname9(fromPath)}/${target}`.split("/");
   const resolved = [];
   for (const segment of segments) {
     if (segment === "" || segment === ".") continue;
@@ -10472,29 +11030,29 @@ function identityReader(worktree, mergeBase) {
     if (mergeBase !== null) {
       return readBaseIdentity(worktree, mergeBase, relativePath);
     }
-    const candidate = resolve11(worktree, relativePath);
+    const candidate = resolve12(worktree, relativePath);
     let resolved;
     try {
-      resolved = realpathSync4(candidate);
+      resolved = realpathSync5(candidate);
     } catch (error) {
       if (isAbsentError(error)) return null;
       throw error;
     }
-    const contained = relative4(worktree, resolved);
-    if (isAbsolute4(contained) || contained === ".." || contained.startsWith(`..${sep4}`)) {
+    const contained = relative5(worktree, resolved);
+    if (isAbsolute4(contained) || contained === ".." || contained.startsWith(`..${sep5}`)) {
       throw new Error(
         `repo-context: identity path escapes the worktree: ${JSON.stringify(relativePath)}`
       );
     }
     try {
-      const stat = statSync8(resolved);
+      const stat = statSync9(resolved);
       if (!stat.isFile()) return null;
       if (stat.size > MAX_IDENTITY_BYTES) {
         throw new Error(
           `repo-context: identity read exceeds the size limit: ${JSON.stringify(relativePath)}`
         );
       }
-      return normalizeIdentityContent(readFileSync14(resolved, "utf8"));
+      return normalizeIdentityContent(readFileSync15(resolved, "utf8"));
     } catch (error) {
       if (isAbsentError(error)) return null;
       throw error;
@@ -10505,7 +11063,7 @@ __name(identityReader, "identityReader");
 function readPlan2(path3) {
   let value;
   try {
-    value = JSON.parse(readFileSync14(path3, "utf8"));
+    value = JSON.parse(readFileSync15(path3, "utf8"));
   } catch (error) {
     throw new Error(`Cannot read plan ${path3}: ${error.message}`);
   }
@@ -10543,13 +11101,13 @@ function contextFromProviders(providers, worktree, paths, readIdentityFile) {
 }
 __name(contextFromProviders, "contextFromProviders");
 function runRepoContext(args, providers = REPOSITORY_CONTEXT_PROVIDERS) {
-  const planPath = resolve11(args.plan);
-  const outPath = resolve11(args.out);
+  const planPath = resolve12(args.plan);
+  const outPath = resolve12(args.out);
   if (sameFile(planPath, outPath)) {
     throw new Error("repo-context: --out must differ from --plan");
   }
-  const worktree = realpathSync4(resolve11(args.worktree));
-  if (!statSync8(worktree).isDirectory()) {
+  const worktree = realpathSync5(resolve12(args.worktree));
+  if (!statSync9(worktree).isDirectory()) {
     throw new Error(`repo-context: worktree is not a directory: ${worktree}`);
   }
   const plan = readPlan2(planPath);
@@ -10575,7 +11133,7 @@ function runRepoContext(args, providers = REPOSITORY_CONTEXT_PROVIDERS) {
   );
   if (context === null) delete plan.repositoryContext;
   else plan.repositoryContext = context;
-  mkdirSync11(dirname8(outPath), { recursive: true });
+  mkdirSync11(dirname9(outPath), { recursive: true });
   atomicWriteFileSync(outPath, `${JSON.stringify(context, null, 2)}
 `);
   atomicWriteFileSync(planPath, stringifyPlanReport(plan));
@@ -10608,7 +11166,7 @@ var repoContextCommand = {
 // packages/cli/src/commands/review/pr-context.ts
 init_esbuild_shims();
 import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname9, join as join11 } from "node:path";
+import { dirname as dirname10, join as join12 } from "node:path";
 var SUMMARY_MARKER = "<!-- qwen-review-suggestion-summary -->";
 function isLegacySuggestionSummary(body) {
   return (body ?? "").includes(SUMMARY_MARKER);
@@ -11086,9 +11644,9 @@ async function runPrContext(args) {
   }
   if (prevLedger) {
     try {
-      mkdirSync12(dirname9(out), { recursive: true });
+      mkdirSync12(dirname10(out), { recursive: true });
       writeFileSync11(
-        join11(dirname9(out), `qwen-review-pr-${prNumber}-prev-ledger.json`),
+        join12(dirname10(out), `qwen-review-pr-${prNumber}-prev-ledger.json`),
         JSON.stringify(prevLedger, null, 2)
       );
     } catch {
@@ -11103,7 +11661,7 @@ async function runPrContext(args) {
     reviews,
     prevLedger
   );
-  mkdirSync12(dirname9(out), { recursive: true });
+  mkdirSync12(dirname10(out), { recursive: true });
   writeFileSync11(out, md, "utf8");
   const meaningfulReviewCount = reviews.filter(
     (r) => isReviewWorthShowing(stripLedgerMarker(r.body ?? ""))
@@ -11159,7 +11717,7 @@ var prContextCommand = {
 // packages/cli/src/commands/review/comment-status.ts
 init_esbuild_shims();
 import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname10 } from "node:path";
+import { dirname as dirname11 } from "node:path";
 var TOUCHED_BY_CAP = 10;
 function buildThreadStatuses(comments, prAuthor, probe) {
   const byId = /* @__PURE__ */ new Map();
@@ -11364,7 +11922,7 @@ async function runCommentStatus(args) {
       summary,
       threads
     };
-    mkdirSync13(dirname10(out), { recursive: true });
+    mkdirSync13(dirname11(out), { recursive: true });
     const json = JSON.stringify(report, null, 2) + "\n";
     writeFileSync12(out, json, "utf8");
     writeStdoutLine(
@@ -11394,7 +11952,7 @@ async function runCommentStatus(args) {
     writeStdoutLine(
       `warning: comment-status failed: ${msg}. It is an index, not the evidence \u2014 re-derive thread statuses per-comment if needed.`
     );
-    mkdirSync13(dirname10(out), { recursive: true });
+    mkdirSync13(dirname11(out), { recursive: true });
     writeFileSync12(
       out,
       JSON.stringify(
@@ -11458,7 +12016,7 @@ var commentStatusCommand = {
 // packages/cli/src/commands/review/load-rules.ts
 init_esbuild_shims();
 import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname11 } from "node:path";
+import { dirname as dirname12 } from "node:path";
 function showFile(baseRef, path3) {
   return gitOpt("show", `${baseRef}:${path3}`);
 }
@@ -11538,7 +12096,7 @@ __name(loadCombined, "loadCombined");
 async function runLoadRules(args) {
   const { base_ref: baseRef, out } = args;
   const { combined, loaded } = loadCombined(baseRef);
-  mkdirSync14(dirname11(out), { recursive: true });
+  mkdirSync14(dirname12(out), { recursive: true });
   writeFileSync13(out, combined, "utf8");
   if (loaded.length === 0) {
     writeStdoutLine(
@@ -11570,7 +12128,7 @@ var loadRulesCommand = {
 
 // packages/cli/src/commands/review/presubmit.ts
 init_esbuild_shims();
-import { writeFileSync as writeFileSync14, readFileSync as readFileSync15 } from "node:fs";
+import { writeFileSync as writeFileSync14, readFileSync as readFileSync16 } from "node:fs";
 function verdictStamp(run4) {
   return run4.completed_at ?? run4.started_at ?? "";
 }
@@ -11606,7 +12164,7 @@ __name(isCurrentActionsRunCheck, "isCurrentActionsRunCheck");
 function parseFindingsFile(path3) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync15(path3, "utf8"));
+    parsed = JSON.parse(readFileSync16(path3, "utf8"));
   } catch {
     return null;
   }
@@ -11947,13 +12505,13 @@ var presubmitCommand = {
 
 // packages/cli/src/commands/review/publish-assets.ts
 init_esbuild_shims();
-import { createHash as createHash2 } from "node:crypto";
-import { readFileSync as readFileSync17, statSync as statSync9, writeFileSync as writeFileSync15, mkdirSync as mkdirSync16 } from "node:fs";
-import { basename as basename5, dirname as dirname12, resolve as resolve12 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import { readFileSync as readFileSync18, statSync as statSync10, writeFileSync as writeFileSync15, mkdirSync as mkdirSync16 } from "node:fs";
+import { basename as basename6, dirname as dirname13, resolve as resolve13 } from "node:path";
 
 // packages/cli/src/commands/review/lib/authorization.ts
 init_esbuild_shims();
-import { readFileSync as readFileSync16 } from "node:fs";
+import { readFileSync as readFileSync17 } from "node:fs";
 
 // packages/cli/src/services/skill-args-file.ts
 init_esbuild_shims();
@@ -11964,12 +12522,12 @@ import {
   closeSync as closeSync2,
   rmSync as rmSync4,
   lstatSync as lstatSync4,
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   constants
 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 var debugLogger3 = createDebugLogger("SKILL_ARGS_FILE");
-var SKILL_ARGS_DIR = join12(".qwen", "tmp");
+var SKILL_ARGS_DIR = join13(".qwen", "tmp");
 function safe(s) {
   return s.replace(/[^A-Za-z0-9._-]/g, "_");
 }
@@ -11979,11 +12537,11 @@ function currentSessionId() {
 }
 __name(currentSessionId, "currentSessionId");
 function skillArgsDir(sessionId = currentSessionId()) {
-  return sessionId ? join12(SKILL_ARGS_DIR, `s-${safe(sessionId)}`) : SKILL_ARGS_DIR;
+  return sessionId ? join13(SKILL_ARGS_DIR, `s-${safe(sessionId)}`) : SKILL_ARGS_DIR;
 }
 __name(skillArgsDir, "skillArgsDir");
 function skillArgsPath(skillName, sessionId = currentSessionId()) {
-  return join12(
+  return join13(
     skillArgsDir(sessionId),
     `qwen-skill-args-${safe(skillName)}.txt`
   );
@@ -12039,7 +12597,7 @@ function clearSkillArgs(skillName) {
     );
     return false;
   }
-  if (existsSync6(path3)) {
+  if (existsSync7(path3)) {
     debugLogger3.warn(`Skill args for ${skillName} survived removal at ${path3}`);
     return false;
   }
@@ -12076,7 +12634,7 @@ function reviewWriteAuthorization(req) {
   const path3 = currentSessionId() === "" && req.skillArgs ? req.skillArgs : sessionScoped;
   let raw;
   try {
-    raw = readFileSync16(path3, "utf8");
+    raw = readFileSync17(path3, "utf8");
   } catch {
     return {
       ok: false,
@@ -12139,8 +12697,8 @@ var EXTENSION_FORMAT = {
   webp: "webp"
 };
 var ASSET_EXTENSIONS = new Set(Object.keys(EXTENSION_FORMAT));
-function claimedExtension(basename6) {
-  return basename6.includes(".") ? basename6.slice(basename6.lastIndexOf(".") + 1).toLowerCase() : "";
+function claimedExtension(basename7) {
+  return basename7.includes(".") ? basename7.slice(basename7.lastIndexOf(".") + 1).toLowerCase() : "";
 }
 __name(claimedExtension, "claimedExtension");
 var ASSET_HEADER_BYTES = 16;
@@ -12166,18 +12724,18 @@ function sniffImageFormat(header) {
   return null;
 }
 __name(sniffImageFormat, "sniffImageFormat");
-function refusedExtension(basename6, ext) {
+function refusedExtension(basename7, ext) {
   return {
     ok: false,
-    reason: `${basename6}: extension ${JSON.stringify(ext)} is not an allowed evidence image type (${[...ASSET_EXTENSIONS].join(", ")})`
+    reason: `${basename7}: extension ${JSON.stringify(ext)} is not an allowed evidence image type (${[...ASSET_EXTENSIONS].join(", ")})`
   };
 }
 __name(refusedExtension, "refusedExtension");
-function validateAssetContent(basename6, header) {
-  const ext = claimedExtension(basename6);
+function validateAssetContent(basename7, header) {
+  const ext = claimedExtension(basename7);
   const claimed = Object.hasOwn(EXTENSION_FORMAT, ext) ? EXTENSION_FORMAT[ext] : void 0;
   if (claimed === void 0) {
-    return refusedExtension(basename6, ext);
+    return refusedExtension(basename7, ext);
   }
   const actual = sniffImageFormat(header);
   if (actual !== claimed) {
@@ -12195,8 +12753,8 @@ function assetsBranch(pr) {
   return `pr-assets/${pr}-review`;
 }
 __name(assetsBranch, "assetsBranch");
-function remoteAssetPath(pr, basename6, sha256Hex) {
-  const safe2 = basename6.replace(/[^A-Za-z0-9._-]/g, "_");
+function remoteAssetPath(pr, basename7, sha256Hex) {
+  const safe2 = basename7.replace(/[^A-Za-z0-9._-]/g, "_");
   return `${pr}-review/${sha256Hex.slice(0, 12)}-${safe2}`;
 }
 __name(remoteAssetPath, "remoteAssetPath");
@@ -12222,18 +12780,18 @@ function parseAssetsRepo(value) {
   return { repo: v };
 }
 __name(parseAssetsRepo, "parseAssetsRepo");
-function validateAssetFile(basename6, bytes) {
-  const ext = claimedExtension(basename6);
+function validateAssetFile(basename7, bytes) {
+  const ext = claimedExtension(basename7);
   if (!ASSET_EXTENSIONS.has(ext)) {
-    return refusedExtension(basename6, ext);
+    return refusedExtension(basename7, ext);
   }
   if (bytes <= 0) {
-    return { ok: false, reason: `${basename6}: empty file` };
+    return { ok: false, reason: `${basename7}: empty file` };
   }
   if (bytes > MAX_ASSET_BYTES) {
     return {
       ok: false,
-      reason: `${basename6}: ${bytes} bytes exceeds the per-file cap of ${MAX_ASSET_BYTES} bytes`
+      reason: `${basename7}: ${bytes} bytes exceeds the per-file cap of ${MAX_ASSET_BYTES} bytes`
     };
   }
   return { ok: true };
@@ -12363,7 +12921,7 @@ function runPublishAssets(args) {
     return;
   }
   const repo = repoResult.repo;
-  const effectiveHost = args.host ?? (process.env["GH_HOST"]?.trim() || void 0);
+  const effectiveHost = resolveGhHost(args.host);
   const auth = reviewWriteAuthorization({
     userAuthorized: args.userAuthorized,
     skillArgs: args.skillArgs,
@@ -12396,7 +12954,7 @@ function runPublishAssets(args) {
   const fileList = [...args.files ?? []];
   if (args.findings) {
     try {
-      const artifact = JSON.parse(readFileSync17(resolve12(args.findings), "utf8"));
+      const artifact = JSON.parse(readFileSync18(resolve13(args.findings), "utf8"));
       findings = validateFindings(
         Array.isArray(artifact) ? artifact : artifact.findings
       );
@@ -12424,11 +12982,11 @@ function runPublishAssets(args) {
   }
   const stats = [];
   for (const file of unique) {
-    const abs = resolve12(file);
+    const abs = resolve13(file);
     try {
-      const st = statSync9(abs);
+      const st = statSync10(abs);
       if (!st.isFile()) throw new Error("not a regular file");
-      stats.push({ file, abs, basename: basename5(abs), bytes: st.size });
+      stats.push({ file, abs, basename: basename6(abs), bytes: st.size });
     } catch (err) {
       refuse(
         `cannot read ${JSON.stringify(file)}: ${err instanceof Error ? err.message : String(err)}`
@@ -12445,7 +13003,7 @@ function runPublishAssets(args) {
   for (const st of stats) {
     let content;
     try {
-      content = readFileSync17(st.abs);
+      content = readFileSync18(st.abs);
     } catch (err) {
       refuse(
         `cannot read ${JSON.stringify(st.file)}: ${err instanceof Error ? err.message : String(err)}`
@@ -12460,7 +13018,7 @@ function runPublishAssets(args) {
       refuse(`${JSON.stringify(st.file)}: ${contentRuling.reason}`);
       return;
     }
-    const sha256 = createHash2("sha256").update(content).digest("hex");
+    const sha256 = createHash3("sha256").update(content).digest("hex");
     prepared.push({
       file: st.file,
       bytes: st.bytes,
@@ -12499,8 +13057,8 @@ function runPublishAssets(args) {
     pr: args.pr,
     published
   };
-  const outPath = resolve12(args.out);
-  mkdirSync16(dirname12(outPath), { recursive: true });
+  const outPath = resolve13(args.out);
+  mkdirSync16(dirname13(outPath), { recursive: true });
   writeFileSync15(outPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   if (findings && !args.findingsOut) {
@@ -12515,8 +13073,8 @@ function runPublishAssets(args) {
       return urls.length > 0 ? { ...f, assets: urls } : f;
     });
     const report = buildReport(updated);
-    const fOut = resolve12(args.findingsOut);
-    mkdirSync16(dirname12(fOut), { recursive: true });
+    const fOut = resolve13(args.findingsOut);
+    mkdirSync16(dirname13(fOut), { recursive: true });
     writeFileSync15(fOut, `${JSON.stringify(report, null, 2)}
 `, "utf8");
   }
@@ -12579,8 +13137,8 @@ var publishAssetsCommand = {
 
 // packages/cli/src/commands/review/resolve-anchors.ts
 init_esbuild_shims();
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync16, mkdirSync as mkdirSync17 } from "node:fs";
-import { dirname as dirname13, resolve as resolve13 } from "node:path";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync16, mkdirSync as mkdirSync17 } from "node:fs";
+import { dirname as dirname14, resolve as resolve14 } from "node:path";
 
 // packages/cli/src/commands/review/lib/anchors.ts
 init_esbuild_shims();
@@ -12804,7 +13362,7 @@ __name(validateRequests, "validateRequests");
 function runResolveAnchors(args) {
   let diffText;
   try {
-    diffText = readFileSync18(args.diff, "utf8");
+    diffText = readFileSync19(args.diff, "utf8");
   } catch (err) {
     throw new Error(
       `Cannot read diff file ${args.diff}: ${err.message}`
@@ -12812,7 +13370,7 @@ function runResolveAnchors(args) {
   }
   let rawText;
   try {
-    rawText = readFileSync18(args.input, "utf8");
+    rawText = readFileSync19(args.input, "utf8");
   } catch (err) {
     throw new Error(
       `Cannot read findings file ${args.input}: ${err.message}`
@@ -12843,7 +13401,7 @@ function runResolveAnchors(args) {
       loose: resolved.filter((r) => r.tier?.startsWith("loose")).length
     }
   };
-  mkdirSync17(dirname13(resolve13(args.out)), { recursive: true });
+  mkdirSync17(dirname14(resolve14(args.out)), { recursive: true });
   writeFileSync16(args.out, JSON.stringify(report, null, 2), "utf8");
   writeStdoutLine(`Wrote resolved anchors to ${args.out}`);
   const s = report.stats;
@@ -12892,7 +13450,7 @@ var resolveAnchorsCommand = {
 // packages/cli/src/commands/review/check-coverage.ts
 init_esbuild_shims();
 import { writeFileSync as writeFileSync17, mkdirSync as mkdirSync18 } from "node:fs";
-import { dirname as dirname14, resolve as resolve14 } from "node:path";
+import { dirname as dirname15, resolve as resolve15 } from "node:path";
 function runCheckCoverage(args) {
   let report;
   try {
@@ -12908,7 +13466,7 @@ This is an environment problem, not a finding about the agents. Coverage cannot
     }
     throw err;
   }
-  mkdirSync18(dirname14(resolve14(args.out)), { recursive: true });
+  mkdirSync18(dirname15(resolve15(args.out)), { recursive: true });
   writeFileSync17(args.out, JSON.stringify(report, null, 2));
   writeStdoutLine(`Wrote coverage report to ${args.out}`);
   const totalChunks = report.coveredChunks.length + report.missingChunks.length + report.uncoverableChunks.length;
@@ -12965,7 +13523,7 @@ This is an environment problem, not a finding about the agents. Coverage cannot
   }
   if (report.missingChunks.length > 0) {
     writeStderrLine(
-      `NOTE: a chunk counts as read when an agent was pointed at its lines AND the harness recorded that agent opening the diff. An agent handed the diff with no line ranges covers nothing. Build every whole-diff agent's prompt with \`"\${QWEN_CODE_CLI:-qwen}" review agent-prompt --plan ${shellQuotePath(args.plan)} --whole-diff\` and paste it verbatim ahead of its brief.`
+      `NOTE: a chunk counts as read when an agent was pointed at its lines AND the harness recorded that agent opening the diff. An agent handed the diff with no line ranges covers nothing. Every rostered agent's launch block \u2014 its diff reads included \u2014 comes from \`"\${QWEN_CODE_CLI:-qwen}" review agent-prompt --plan ${shellQuotePath(args.plan)} --roster\` (or \`--role <r>\` for one, \`--chunk <id>\` for a chunk agent \u2014 the usual reader of a missing chunk, which \`--role\` cannot rebuild); pass each verbatim. \`--whole-diff\` builds the reading block for an Agent 8 specialist alone \u2014 prepending it to a rostered brief double-budgets the agent.`
     );
   }
   if (report.idleAgents.length > 0) {
@@ -12983,6 +13541,12 @@ This is an environment problem, not a finding about the agents. Coverage cannot
       `ERROR: ${report.missingChunks.length} chunk(s) were not reviewed \u2014 ${report.missingChunks.join(", ")}. Nobody read those lines. Do not aggregate findings over a diff that was not read.`
     );
   }
+  if (report.budgetGaps.length > 0) {
+    const total = report.budgetGaps.reduce((n, g) => n + g.gaps.length, 0);
+    writeStderrLine(
+      `NOTE: ${total} budget-gap disclosure(s) from ${report.budgetGaps.length} agent(s). Do not relaunch over these; rule on each: a gap naming an incomplete required trace goes in unreviewedDimensions, optional depth is disclosed in the report's "Not reviewed" section. The disclosures \u2014 ` + report.budgetGaps.map((g) => `${g.agent}: ${g.gaps.join("; ")}`).join(" | ")
+    );
+  }
   if (!report.ok) {
     process.exitCode = 3;
   }
@@ -13007,14 +13571,14 @@ var checkCoverageCommand = {
 
 // packages/cli/src/commands/review/agent-prompt.ts
 init_esbuild_shims();
-import { createHash as createHash3 } from "node:crypto";
-import { readFileSync as readFileSync20 } from "node:fs";
-import { dirname as dirname15, join as join13, resolve as resolve16 } from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+import { readFileSync as readFileSync21 } from "node:fs";
+import { dirname as dirname16, join as join14, resolve as resolve17 } from "node:path";
 
 // packages/cli/src/commands/review/lib/retirement.ts
 init_esbuild_shims();
-import { readFileSync as readFileSync19, statSync as statSync10 } from "node:fs";
-import { resolve as resolve15, sep as sep5 } from "node:path";
+import { readFileSync as readFileSync20, statSync as statSync11 } from "node:fs";
+import { resolve as resolve16, sep as sep6 } from "node:path";
 var REVERSE_AUDIT_MAX_ROUNDS = 5;
 var RECORD_KEY_RE = /^reverse-audit--chunk-(\d+)--round-(\d+)--[0-9a-f]+$/;
 var REVERSE_AUDIT_MARKER = "reverse-audit";
@@ -13056,13 +13620,13 @@ __name(substantiveClause, "substantiveClause");
 function findingsListFor(prompt, recordDir, memo) {
   const pointer = findingsPointerOf(prompt);
   if (pointer === null) return prompt;
-  const root = resolve15(recordDir);
-  const target = resolve15(pointer);
-  if (target !== root && !target.startsWith(root + sep5)) return prompt;
+  const root = resolve16(recordDir);
+  const target = resolve16(pointer);
+  if (target !== root && !target.startsWith(root + sep6)) return prompt;
   const cached = memo.get(pointer);
   if (cached !== void 0) return cached;
   try {
-    const content = readFileSync19(target, "utf8");
+    const content = readFileSync20(target, "utf8");
     memo.set(pointer, content);
     return content;
   } catch {
@@ -13080,8 +13644,12 @@ function classifyReturn(rec, territory, findingsList) {
       return "yielded";
     }
   }
-  const receipt = DRY_RECEIPT_RE.exec(text);
-  if (rec.successfulToolCalls > 0 && rec.diffToolCalls > 0 && openedTheTerritory(rec.diffReads, territory) && receipt !== null && substantiveClause(receipt[1] ?? "")) {
+  const judged = stripBudgetGapLines(text);
+  const receipt = DRY_RECEIPT_RE.exec(judged);
+  const clause = receipt?.[1] ?? "";
+  const inlineGap = INLINE_BUDGET_GAP_RE.exec(clause);
+  const judgedClause = inlineGap === null ? clause : clause.slice(0, inlineGap.index);
+  if (rec.successfulToolCalls > 0 && rec.diffToolCalls > 0 && openedTheTerritory(rec.diffReads, territory) && receipt !== null && substantiveClause(judgedClause)) {
     return "dry";
   }
   return "unknown";
@@ -13109,7 +13677,7 @@ function scheduleReverseAuditRound(planPath, chunkIds, round, env = process.env,
       converged: false
     };
   }
-  const since = statSync10(planPath).mtimeMs;
+  const since = statSync11(planPath).mtimeMs;
   const transcripts = readTranscripts(since, env, diffPath);
   const built = readRecordedPrompts(planPath, since);
   const recordDir = promptRecordDir(planPath);
@@ -13381,6 +13949,60 @@ function chunkFrom(report, id) {
   return { diffPath, chunk: chunk2, total: chunks.length };
 }
 __name(chunkFrom, "chunkFrom");
+var FINDINGS_LIST_READS = 3;
+var LINES_PER_FILE_READ = 500;
+function wholeDiffReadPages(report) {
+  return (Array.isArray(report.chunks) ? report.chunks : []).reduce(
+    (n, c) => {
+      const chars = c?.chars;
+      return n + Math.max(
+        1,
+        Math.ceil(
+          (typeof chars === "number" && Number.isFinite(chars) ? chars : 0) / READ_FILE_CHAR_CAP
+        )
+      );
+    },
+    0
+  );
+}
+__name(wholeDiffReadPages, "wholeDiffReadPages");
+function weightedTerritoryLines(report, chunk2) {
+  const lines = typeof chunk2.lines === "number" && Number.isFinite(chunk2.lines) ? Math.max(0, Math.floor(chunk2.lines)) : 0;
+  if (lines === 0) return 0;
+  const kinds = new Map(
+    (Array.isArray(report.files) ? report.files : []).filter((f) => !!f && typeof f.path === "string").map((f) => [f.path, f.kind])
+  );
+  let src = 0;
+  let other = 0;
+  for (const f of Array.isArray(chunk2.files) ? chunk2.files : []) {
+    const e = f;
+    const span = typeof e?.newStart === "number" && typeof e?.newEnd === "number" ? e.newEnd - e.newStart + 1 : 0;
+    if (!(span > 0)) continue;
+    const kind = typeof e.path === "string" ? kinds.get(e.path) : void 0;
+    if (kind === void 0 || kind === "source") src += span;
+    else other += span;
+  }
+  const total = src + other;
+  if (total === 0) return lines;
+  return Math.max(1, Math.round(lines * (src + other / 8) / total));
+}
+__name(weightedTerritoryLines, "weightedTerritoryLines");
+function toolBudgetBlock(report, launch) {
+  const base = report.budget?.agentToolBudget;
+  if (typeof base !== "number" || !Number.isFinite(base) || base <= 0) {
+    return [];
+  }
+  const reads = Number.isFinite(launch.mandatoryReads) ? Math.max(0, Math.floor(launch.mandatoryReads)) : 0;
+  const territory = typeof launch.territoryLines === "number" && Number.isFinite(launch.territoryLines) ? launch.territoryLines : launch.territoryLines === null || launch.territoryLines === void 0 ? null : 0;
+  const total = launchToolBudget(base, territory, reads);
+  return [
+    "",
+    "## Tool budget",
+    "",
+    `About **${total} tool calls** for this whole review \u2014 reads, greps, shell, everything \u2014 and the ~${reads} reads your launch is assigned (your brief, the diff pages, any files your method mandates) are already counted in. It is a soft ceiling. At the ceiling: stop exploring, write your findings from the evidence already in hand, and disclose each unfinished check on its own line, exactly as \`Budget gap: <the check>\` \u2014 the coverage tool reads those lines, so the format is load-bearing. The budget never suppresses a finding: a candidate you can already name goes in your return regardless (at \`Confidence: low\` if the budget stopped you before verifying it).`
+  ];
+}
+__name(toolBudgetBlock, "toolBudgetBlock");
 function buildChunkAgentPrompt(report, id, rules) {
   const { chunk: chunk2, total } = chunkFrom(report, id);
   const files = (Array.isArray(chunk2.files) ? chunk2.files : []).filter(
@@ -13436,6 +14058,21 @@ function buildChunkAgentPrompt(report, id, rules) {
   if (repositoryContext) {
     parts.push("", ...repositoryContextBlock(repositoryContext));
   }
+  if (!unreachable) {
+    parts.push(
+      ...toolBudgetBlock(report, {
+        territoryLines: weightedTerritoryLines(report, chunk2),
+        // The launch's whole reading list: the brief file, plus the diff pages
+        // this chunk takes.
+        mandatoryReads: 1 + Math.max(
+          1,
+          Math.ceil(
+            (Number.isFinite(chunk2.chars) ? chunk2.chars : 0) / READ_FILE_CHAR_CAP
+          )
+        )
+      })
+    );
+  }
   parts.push(
     "",
     "## When you are done",
@@ -13485,6 +14122,9 @@ function buildWholeDiffBlock(report, rules) {
   if (repositoryContext) {
     parts.push("", ...repositoryContextBlock(repositoryContext));
   }
+  parts.push(
+    ...toolBudgetBlock(report, { mandatoryReads: wholeDiffReadPages(report) })
+  );
   parts.push(...tail(rules));
   return parts.join("\n");
 }
@@ -13672,6 +14312,56 @@ function buildRoleBrief(report, role, opts = {}) {
     parts.push("");
   }
   parts.push("## Your dimension", "", brief.brief);
+  if (!brief.budgetExempt) {
+    const chunks = Array.isArray(report.chunks) ? report.chunks : [];
+    if (typeof opts.chunk === "number") {
+      const c = chunks.find((x) => x?.id === opts.chunk);
+      parts.push(
+        ...toolBudgetBlock(report, {
+          territoryLines: weightedTerritoryLines(report, c ?? {}),
+          // Its reading list: the brief file, the chunk's diff pages, and
+          // the cumulative findings list its brief orders read in full —
+          // measured at 65-82 KB on real runs, several pages of it.
+          mandatoryReads: 1 + Math.max(
+            1,
+            Math.ceil(
+              (typeof c?.chars === "number" && Number.isFinite(c.chars) ? c.chars : 0) / READ_FILE_CHAR_CAP
+            )
+          ) + FINDINGS_LIST_READS
+        })
+      );
+    } else if (role.startsWith("invariant-") && opts.file) {
+      const files = Array.isArray(report.files) ? report.files : [];
+      const f = files.find((x) => x?.path === opts.file);
+      const added = typeof f?.addedLines === "number" ? f.addedLines : 0;
+      const fileLines = typeof f?.fileLines === "number" && Number.isFinite(f.fileLines) ? f.fileLines : 0;
+      const changed = added + (typeof f?.removedLines === "number" ? f.removedLines : 0);
+      parts.push(
+        ...toolBudgetBlock(report, {
+          territoryLines: changed,
+          // Its reading list: the brief, its own diff slice, and the whole
+          // post-change file paged to the end. The pages come from
+          // `fileLines` — the post-change length the plan records for
+          // every file — with `addedLines` as the fallback lower bound
+          // for an older plan without it: a file can go heavy by VOLUME
+          // in a large file it barely rewrote, and estimating its paging
+          // from added lines alone told exactly that agent its mandatory
+          // reading was already overspending. Floors at the old flat 4 so
+          // no launch gets less than before.
+          mandatoryReads: Math.max(
+            4,
+            2 + Math.ceil(Math.max(added, fileLines) / LINES_PER_FILE_READ)
+          )
+        })
+      );
+    } else {
+      parts.push(
+        ...toolBudgetBlock(report, {
+          mandatoryReads: 1 + wholeDiffReadPages(report) + (brief.acceptsFindings ? FINDINGS_LIST_READS : 0)
+        })
+      );
+    }
+  }
   const repositoryContext = repositoryContextOf(report);
   if (role === "7") {
     if (repositoryContext) {
@@ -13702,7 +14392,7 @@ function buildRoleBrief(report, role, opts = {}) {
         "agent-prompt: --role 0 needs a plan with `prNumber` and `ownerRepo` (the report `fetch-pr` writes). Issue fidelity has nothing to check against without a pull request."
       );
     }
-    const ctx = opts.planPath ? join13(dirname15(resolve16(opts.planPath)), `qwen-review-pr-${pr}-context.md`) : null;
+    const ctx = opts.planPath ? join14(dirname16(resolve17(opts.planPath)), `qwen-review-pr-${pr}-context.md`) : null;
     parts.push(
       "",
       `**This PR:** #${pr} of \`${repo}\`. Use exactly that number and repo \u2014 a bare \`gh pr view\` falls back to the current branch's PR and would judge this diff against an unrelated issue.`
@@ -13724,7 +14414,7 @@ function buildRoleBrief(report, role, opts = {}) {
     }
     const base = report.mergeBaseSha;
     const pr = report.prNumber;
-    const buildTree = typeof wt === "string" && wt ? resolve16(wt) : pr === void 0 && opts.planPath ? "." : null;
+    const buildTree = typeof wt === "string" && wt ? resolve17(wt) : pr === void 0 && opts.planPath ? "." : null;
     if (buildTree && opts.planPath) {
       const outName = pr !== void 0 ? `qwen-review-pr-${pr}-build-test.json` : "qwen-review-build-test.json";
       parts.push(
@@ -13740,9 +14430,9 @@ function buildRoleBrief(report, role, opts = {}) {
         // that an old global lacks it entirely, wedging Agent 7 between its
         // mandate (no hand-run `npm run build`) and a command that does not exist.
         `"\${QWEN_CODE_CLI:-qwen}" review build-test \\`,
-        `  --plan ${resolve16(opts.planPath)} \\`,
-        `  --worktree ${resolve16(buildTree)} \\`,
-        `  --out ${resolve16(dirname15(opts.planPath), outName)}`,
+        `  --plan ${resolve17(opts.planPath)} \\`,
+        `  --worktree ${resolve17(buildTree)} \\`,
+        `  --out ${resolve17(dirname16(opts.planPath), outName)}`,
         "```"
       );
     }
@@ -13752,10 +14442,10 @@ function buildRoleBrief(report, role, opts = {}) {
         "**Then run the test-efficacy probe.** A green suite says the tests pass. It does not say they would have failed had the change been wrong, and those are different claims. Give this call `timeout: 600000` too \u2014 besides the revert probe it runs up to 8 single-statement deletion mutants and up to 6 per-hunk reverse-apply probes, each a suite run, and it budgets itself to finish inside that ceiling:",
         "",
         "```bash",
-        `"\${QWEN_CODE_CLI:-qwen}" review test-efficacy ${resolve16(opts.planPath)} \\`,
-        `  --worktree ${typeof wt === "string" ? resolve16(wt) : "<worktree>"} \\`,
+        `"\${QWEN_CODE_CLI:-qwen}" review test-efficacy ${resolve17(opts.planPath)} \\`,
+        `  --worktree ${typeof wt === "string" ? resolve17(wt) : "<worktree>"} \\`,
         `  --base ${base} \\`,
-        `  --out ${resolve16(dirname15(opts.planPath), `qwen-review-pr-${pr}-efficacy.json`)}`,
+        `  --out ${resolve17(dirname16(opts.planPath), `qwen-review-pr-${pr}-efficacy.json`)}`,
         "```",
         "",
         'Read its `findings[]`. `kind: "unreachable"` is a test the project\'s test command never collects \u2014 it did not run here and it does not run in CI. `kind: "inert"` is a test that **still passed with the change reverted**: it is green whether or not the feature exists, so it cannot catch a regression in it. `kind: "mutant-survived"` is a single safety statement the diff added (a `.clear()`, an `.abort(\u2026)`, a reset-to-empty) that was **deleted and every affected test stayed green** \u2014 no test in the diff fails when it is removed, which the whole-file revert cannot see when the file\'s other, tested behaviours mask it. `kind: "hunk-survived"` is one HUNK reverted on its own with every affected test still green \u2014 that specific change ships with nothing gating it. Report each of the four as a **Suggestion** with `Source: [test]`, saying plainly which behaviour has no test in this diff that would catch its removal. `harnessValidated` has THREE values and they are not two: `false` means the positive control failed and every would-be survivor was re-classed \u2014 say the harness could not be validated instead of implying clean coverage; `null` means the control never ran, so the run is neither validated nor refuted and any survivor below is unconfirmed by a control; only `true` licenses reading a survivor as a coverage gap. **`inconclusive` is not a finding** \u2014 for probes, mutants and hunks alike, reverting or mutating the source often breaks the test\'s own compile, and that is not the test catching anything. Entries counted in `mutants.skipped*` or `hunks.skipped*` never ran \u2014 not findings either, and `skippedForControl` in particular means the control stopped the run, NOT that the window ran out. `mutants.note`, when present, explains why no mutants ran at all. Note them and move on.'
@@ -13921,7 +14611,7 @@ function buildLaunch(report, planPath, spec, rules) {
 }
 __name(buildLaunch, "buildLaunch");
 function findingsDigest(content, rules) {
-  return createHash3("sha256").update(JSON.stringify([content, rules ?? null])).digest("hex").slice(0, 12);
+  return createHash4("sha256").update(JSON.stringify([content, rules ?? null])).digest("hex").slice(0, 12);
 }
 __name(findingsDigest, "findingsDigest");
 function foldFindings(role, content, prompt, findingsFile) {
@@ -14215,7 +14905,7 @@ function runAgentPrompt(args) {
   }
   let report;
   try {
-    report = JSON.parse(readFileSync20(args.plan, "utf8"));
+    report = JSON.parse(readFileSync21(args.plan, "utf8"));
   } catch (err) {
     throw new Error(
       `agent-prompt: cannot read the plan ${args.plan}: ${err.message}`
@@ -14224,7 +14914,7 @@ function runAgentPrompt(args) {
   let rules;
   if (args.rules) {
     try {
-      rules = readFileSync20(args.rules, "utf8");
+      rules = readFileSync21(args.rules, "utf8");
     } catch (err) {
       throw new Error(
         `agent-prompt: cannot read the rules ${args.rules}: ${err.message}. Omit --rules if this review has none; passing a path that does not resolve would silently review without the project rules it was told to enforce.`
@@ -14239,7 +14929,7 @@ function runAgentPrompt(args) {
   if (hasFindings && args.role) {
     const role = args.role;
     try {
-      findingsContent = readFileSync20(args.findings, "utf8");
+      findingsContent = readFileSync21(args.findings, "utf8");
     } catch (err) {
       throw new Error(
         `agent-prompt: cannot read the findings ${args.findings}: ${err.message}. Pass a path that resolves \u2014 --findings is required for this role, so omitting it only fails one guard earlier. An early reverse-audit round with nothing confirmed passes an empty file (create it first).`
@@ -14384,18 +15074,18 @@ var agentPromptCommand = {
 init_esbuild_shims();
 import { spawnSync as spawnSync3 } from "node:child_process";
 import {
-  existsSync as existsSync8,
-  readFileSync as readFileSync22,
+  existsSync as existsSync9,
+  readFileSync as readFileSync23,
   rmSync as rmSync5,
   statfsSync,
   writeFileSync as writeFileSync18
 } from "node:fs";
-import { join as join15, resolve as resolve17 } from "node:path";
+import { join as join16, resolve as resolve18 } from "node:path";
 
 // packages/cli/src/commands/review/lib/workspaces.ts
 init_esbuild_shims();
-import { existsSync as existsSync7, readFileSync as readFileSync21, readdirSync as readdirSync5 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync22, readdirSync as readdirSync6 } from "node:fs";
+import { join as join15 } from "node:path";
 function isWorkspaceMember(filePath, workspaceGlobs) {
   return workspaceDirFor(filePath, workspaceGlobs) !== null;
 }
@@ -14447,7 +15137,7 @@ __name(hasUnmodeledWorkspaceGlob, "hasUnmodeledWorkspaceGlob");
 function readWorkspaceGlobs(root) {
   try {
     const pkg = JSON.parse(
-      readFileSync21(join14(root, "package.json"), "utf8")
+      readFileSync22(join15(root, "package.json"), "utf8")
     );
     const ws = pkg.workspaces;
     const globs = Array.isArray(ws) ? ws : Array.isArray(ws?.packages) ? ws.packages : [];
@@ -14460,7 +15150,7 @@ __name(readWorkspaceGlobs, "readWorkspaceGlobs");
 function readRootPackage(root) {
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync21(join14(root, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync22(join15(root, "package.json"), "utf8"));
   } catch {
     return null;
   }
@@ -14502,8 +15192,8 @@ function workspaceDirCandidates(root, globs) {
       const base = g.slice(0, -2);
       let entries;
       try {
-        entries = readdirSync5(join14(root, base), { withFileTypes: true }).filter(
-          (e) => e.isDirectory() || e.isSymbolicLink() && existsSync7(join14(root, base, e.name, "package.json"))
+        entries = readdirSync6(join15(root, base), { withFileTypes: true }).filter(
+          (e) => e.isDirectory() || e.isSymbolicLink() && existsSync8(join15(root, base, e.name, "package.json"))
         ).map((e) => e.name);
       } catch {
         continue;
@@ -14521,8 +15211,8 @@ function readWorkspacePackages(root) {
   const packages = [];
   const skipped = [];
   for (const dir of workspaceDirCandidates(root, globs)) {
-    const manifest = join14(root, dir, "package.json");
-    if (!existsSync7(manifest)) continue;
+    const manifest = join15(root, dir, "package.json");
+    if (!existsSync8(manifest)) continue;
     if (workspaceDirFor(`${dir}/package.json`, globs) !== dir) {
       const positives = globs.filter((g) => !g.startsWith("!"));
       if (workspaceDirFor(`${dir}/package.json`, positives) === dir) continue;
@@ -14531,7 +15221,7 @@ function readWorkspacePackages(root) {
     }
     let pkg;
     try {
-      pkg = JSON.parse(readFileSync21(manifest, "utf8"));
+      pkg = JSON.parse(readFileSync22(manifest, "utf8"));
     } catch {
       skipped.push(dir);
       continue;
@@ -14788,7 +15478,7 @@ __name(unresolvedWorkspaceDeps, "unresolvedWorkspaceDeps");
 function changedFilesFrom(planPath) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync22(planPath, "utf8"));
+    parsed = JSON.parse(readFileSync23(planPath, "utf8"));
   } catch (err) {
     throw new Error(
       `build-test: cannot read the plan ${planPath}: ${err.message}`
@@ -14805,7 +15495,7 @@ function changedFilesFrom(planPath) {
 }
 __name(changedFilesFrom, "changedFilesFrom");
 function runBuildTest(args) {
-  const root = resolve17(args.worktree);
+  const root = resolve18(args.worktree);
   const perCommandMs = args.timeout * 1e3;
   const callBudgetMs = (args.budget ?? Math.max(args.timeout, args.timeout * 2 - 30)) * 1e3;
   const runStarted = Date.now();
@@ -14883,15 +15573,15 @@ function runBuildTest(args) {
     timedOut: [],
     note: ""
   };
-  const npmLock = existsSync8(join15(root, "package-lock.json"));
-  const installComplete = /* @__PURE__ */ __name(() => existsSync8(join15(root, "node_modules", ".package-lock.json")), "installComplete");
-  if (args.install && !npmLock && !existsSync8(join15(root, "node_modules"))) {
+  const npmLock = existsSync9(join16(root, "package-lock.json"));
+  const installComplete = /* @__PURE__ */ __name(() => existsSync9(join16(root, "node_modules", ".package-lock.json")), "installComplete");
+  if (args.install && !npmLock && !existsSync9(join16(root, "node_modules"))) {
     const altLock = [
       ["yarn.lock", "yarn install --frozen-lockfile"],
       ["pnpm-lock.yaml", "pnpm install --frozen-lockfile"],
       ["bun.lockb", "bun install --frozen-lockfile"],
       ["bun.lock", "bun install --frozen-lockfile"]
-    ].find(([f]) => existsSync8(join15(root, f)));
+    ].find(([f]) => existsSync9(join16(root, f)));
     return unsupportedReport(
       altLock ? `This is a ${altLock[0]} repo with no installed \`node_modules\`, so \`npm ci\` cannot install it. Run \`${altLock[1]}\` first, then fall back to the build/test precedence in your brief, each command with a deadline it can meet.` : "There is no lockfile and no `node_modules` here, so nothing can be installed deterministically. Install dependencies first, then fall back to the build/test precedence in your brief."
     );
@@ -14918,7 +15608,7 @@ function runBuildTest(args) {
     if (install.timedOut) results.timedOut.push(install.command);
     if (install.timedOut) {
       try {
-        rmSync5(join15(root, "node_modules"), {
+        rmSync5(join16(root, "node_modules"), {
           recursive: true,
           force: true,
           maxRetries: 3
@@ -15131,14 +15821,14 @@ var buildTestCommand = {
 init_esbuild_shims();
 import { spawnSync as spawnSync5 } from "node:child_process";
 import {
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync19,
-  readFileSync as readFileSync23,
+  readFileSync as readFileSync24,
   rmSync as rmSync7,
-  statSync as statSync11,
+  statSync as statSync12,
   writeFileSync as writeFileSync19
 } from "node:fs";
-import { dirname as dirname16, join as join16, resolve as resolve18 } from "node:path";
+import { dirname as dirname17, join as join17, resolve as resolve19 } from "node:path";
 
 // packages/cli/src/commands/review/lib/worktree.ts
 init_esbuild_shims();
@@ -15185,7 +15875,7 @@ function runBaseTree(args) {
   }), "unavailable");
   let plan;
   try {
-    plan = JSON.parse(readFileSync23(args.plan, "utf8"));
+    plan = JSON.parse(readFileSync24(args.plan, "utf8"));
   } catch (err) {
     return unavailable(
       `cannot read the plan ${args.plan}: ${err.message}`
@@ -15202,15 +15892,15 @@ function runBaseTree(args) {
       "the base branch could not be fetched, so mergeBaseSha may be stale; an A/B against it would attribute the base branch's own commits to this PR"
     );
   }
-  const worktree = resolve18(args.worktree);
-  if (!existsSync9(worktree)) {
+  const worktree = resolve19(args.worktree);
+  if (!existsSync10(worktree)) {
     return unavailable(`the review worktree ${worktree} does not exist`);
   }
   const tree = baseWorktreePath(worktree);
-  const marker = /* @__PURE__ */ __name(() => join16(tree, ".qwen-review-base-ok"), "marker");
-  const failedMarker = /* @__PURE__ */ __name(() => join16(tree, ".qwen-review-base-failed"), "failedMarker");
+  const marker = /* @__PURE__ */ __name(() => join17(tree, ".qwen-review-base-ok"), "marker");
+  const failedMarker = /* @__PURE__ */ __name(() => join17(tree, ".qwen-review-base-failed"), "failedMarker");
   try {
-    if (existsSync9(tree) && readFileSync23(marker(), "utf8").trim() === baseSha && gitOut(tree, "rev-parse", "HEAD") === baseSha) {
+    if (existsSync10(tree) && readFileSync24(marker(), "utf8").trim() === baseSha && gitOut(tree, "rev-parse", "HEAD") === baseSha) {
       return {
         available: true,
         path: tree,
@@ -15222,7 +15912,7 @@ function runBaseTree(args) {
   } catch {
   }
   try {
-    if (existsSync9(tree) && readFileSync23(failedMarker(), "utf8").trim() === baseSha) {
+    if (existsSync10(tree) && readFileSync24(failedMarker(), "utf8").trim() === baseSha) {
       return {
         available: false,
         path: tree,
@@ -15235,7 +15925,7 @@ function runBaseTree(args) {
   }
   const lock = `${tree}.lock`;
   try {
-    const age = Date.now() - statSync11(lock).mtimeMs;
+    const age = Date.now() - statSync12(lock).mtimeMs;
     if (age > 30 * 60 * 1e3) {
       rmSync7(lock, { recursive: true, force: true });
     }
@@ -15342,8 +16032,8 @@ var baseTreeCommand = {
     try {
       const report = runBaseTree(args);
       if (args.out) {
-        mkdirSync19(dirname16(resolve18(args.out)), { recursive: true });
-        writeFileSync19(resolve18(args.out), JSON.stringify(report, null, 2));
+        mkdirSync19(dirname17(resolve19(args.out)), { recursive: true });
+        writeFileSync19(resolve19(args.out), JSON.stringify(report, null, 2));
       }
       writeStdoutLine(JSON.stringify(report, null, 2));
       writeStderrLine(`base-tree: ${report.note}`);
@@ -15357,8 +16047,8 @@ var baseTreeCommand = {
 // packages/cli/src/commands/review/test-delta.ts
 init_esbuild_shims();
 import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync20, readFileSync as readFileSync24, writeFileSync as writeFileSync20 } from "node:fs";
-import { dirname as dirname17, resolve as resolve19 } from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync20, readFileSync as readFileSync25, writeFileSync as writeFileSync20 } from "node:fs";
+import { dirname as dirname18, resolve as resolve20 } from "node:path";
 var ANSI_SGR_RE2 = /\x1b\[[0-9;]*m/g;
 var RERUNNABLE_COMMAND_RE = /^npm test(?: --workspace="[\w@./-]+")?$/;
 var TRIM_MARKER_RE = /\.\.\. \[\d+ characters omitted/;
@@ -15421,7 +16111,7 @@ var TOTAL_BUDGET_MS = 54e4;
 var DEFAULT_TIMEOUT_S = 300;
 function runTestDelta(args) {
   const exec = args.exec ?? run2;
-  const baseline = resolve19(args.baseline);
+  const baseline = resolve20(args.baseline);
   const empty = /* @__PURE__ */ __name((note) => ({
     entries: [],
     netNew: [],
@@ -15431,13 +16121,13 @@ function runTestDelta(args) {
   }), "empty");
   let report;
   try {
-    report = JSON.parse(readFileSync24(args.report, "utf8"));
+    report = JSON.parse(readFileSync25(args.report, "utf8"));
   } catch (err) {
     return empty(
       `cannot read the build-test report ${args.report}: ${err.message}`
     );
   }
-  if (!existsSync10(baseline)) {
+  if (!existsSync11(baseline)) {
     return empty(
       `the base tree ${baseline} does not exist \u2014 run \`qwen review base-tree\` first`
     );
@@ -15573,8 +16263,8 @@ var testDeltaCommand = {
     const args = argv;
     const report = runTestDelta(args);
     if (args.out) {
-      mkdirSync20(dirname17(resolve19(args.out)), { recursive: true });
-      writeFileSync20(resolve19(args.out), JSON.stringify(report, null, 2));
+      mkdirSync20(dirname18(resolve20(args.out)), { recursive: true });
+      writeFileSync20(resolve20(args.out), JSON.stringify(report, null, 2));
     }
     writeStdoutLine(JSON.stringify(report, null, 2));
     writeStderrLine(`test-delta: ${report.note}`);
@@ -15587,12 +16277,12 @@ import { spawnSync as spawnSync7 } from "node:child_process";
 import {
   mkdirSync as mkdirSync21,
   writeFileSync as writeFileSync21,
-  readFileSync as readFileSync25,
-  existsSync as existsSync11,
+  readFileSync as readFileSync26,
+  existsSync as existsSync12,
   rmSync as rmSync8,
-  statSync as statSync12
+  statSync as statSync13
 } from "node:fs";
-import { dirname as dirname18, join as join17, resolve as resolve20 } from "node:path";
+import { dirname as dirname19, join as join18, resolve as resolve21 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 var SERVER_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 function shellQuote(v) {
@@ -15604,7 +16294,7 @@ var LOG_MAX_BYTES = 8 * 1024 * 1024;
 var POLL_MS = 250;
 function logBytes(p) {
   try {
-    return statSync12(p).size;
+    return statSync13(p).size;
   } catch {
     return 0;
   }
@@ -15710,11 +16400,11 @@ function runDrive(args) {
       waitMs(POLL_MS);
     }
   }
-  const dir = join17(tmpdir2(), `qwen-review-drive-${server}`);
+  const dir = join18(tmpdir2(), `qwen-review-drive-${server}`);
   mkdirSync21(dir, { recursive: true });
-  const scriptPath = join17(dir, "drive.sh");
-  const logPath = args.logPath ?? join17(dir, "drive.log");
-  const sentinelPath = join17(dir, "drive.rc");
+  const scriptPath = join18(dir, "drive.sh");
+  const logPath = args.logPath ?? join18(dir, "drive.log");
+  const sentinelPath = join18(dir, "drive.rc");
   rmSync8(sentinelPath, { force: true });
   writeFileSync21(scriptPath, wrapScript(args.script, sentinelPath), "utf8");
   const droveFrom = Date.now();
@@ -15746,8 +16436,8 @@ function runDrive(args) {
     }
     const deadline = droveFrom + args.timeout * 1e3;
     for (; ; ) {
-      output = existsSync11(logPath) ? readFileSync25(logPath, "utf8") : "";
-      exitCode = existsSync11(sentinelPath) ? sentinelExitCode(readFileSync25(sentinelPath, "utf8")) : null;
+      output = existsSync12(logPath) ? readFileSync26(logPath, "utf8") : "";
+      exitCode = existsSync12(sentinelPath) ? sentinelExitCode(readFileSync26(sentinelPath, "utf8")) : null;
       if (exitCode !== null) {
         outcome = "completed";
         break;
@@ -15811,11 +16501,13 @@ var driveCommand = {
   }), "builder"),
   handler: /* @__PURE__ */ __name((argv) => {
     try {
+      const bundleNotice = bundleStalenessNotices(process.argv[1], true);
+      if (bundleNotice) writeStderrLineSafe(bundleNotice);
       const args = argv;
       const report = runDrive(args);
       if (args.out) {
-        mkdirSync21(dirname18(resolve20(args.out)), { recursive: true });
-        writeFileSync21(resolve20(args.out), JSON.stringify(report, null, 2));
+        mkdirSync21(dirname19(resolve21(args.out)), { recursive: true });
+        writeFileSync21(resolve21(args.out), JSON.stringify(report, null, 2));
       }
       writeStdoutLine(JSON.stringify(report, null, 2));
       writeStderrLine(`drive: ${report.note}`);
@@ -15833,7 +16525,7 @@ import {
   createServer
 } from "node:http";
 import { appendFileSync, mkdirSync as mkdirSync22, writeFileSync as writeFileSync22 } from "node:fs";
-import { dirname as dirname19, resolve as resolve21 } from "node:path";
+import { dirname as dirname20, resolve as resolve22 } from "node:path";
 import { pathToFileURL } from "node:url";
 function messagesText(body) {
   const msgs = Array.isArray(body?.["messages"]) ? body["messages"] : [];
@@ -16079,7 +16771,7 @@ var DEFAULT_REPLY = { text: "ok" };
 async function startMockProvider(args, respondOverride) {
   let respond = respondOverride ?? (() => DEFAULT_REPLY);
   if (!respondOverride && args.responder) {
-    const mod = await import(pathToFileURL(resolve21(args.responder)).href);
+    const mod = await import(pathToFileURL(resolve22(args.responder)).href);
     const fn = mod.respond ?? mod.default;
     if (typeof fn !== "function") {
       throw new Error(
@@ -16088,8 +16780,8 @@ async function startMockProvider(args, respondOverride) {
     }
     respond = fn;
   }
-  const logPath = resolve21(args.log);
-  mkdirSync22(dirname19(logPath), { recursive: true });
+  const logPath = resolve22(args.log);
+  mkdirSync22(dirname20(logPath), { recursive: true });
   writeFileSync22(logPath, "");
   let n = 0;
   const record = /* @__PURE__ */ __name((entry) => appendFileSync(logPath, `${JSON.stringify(entry)}
@@ -16252,8 +16944,8 @@ var mockProviderCommand = {
       const args = argv;
       const { report, close } = await startMockProvider(args);
       if (args.out) {
-        mkdirSync22(dirname19(resolve21(args.out)), { recursive: true });
-        writeFileSync22(resolve21(args.out), JSON.stringify(report, null, 2));
+        mkdirSync22(dirname20(resolve22(args.out)), { recursive: true });
+        writeFileSync22(resolve22(args.out), JSON.stringify(report, null, 2));
       }
       writeStdoutLine(JSON.stringify(report, null, 2));
       writeStderrLine(`mock-provider: ${report.note}`);
@@ -16271,8 +16963,8 @@ var mockProviderCommand = {
 // packages/cli/src/commands/review/extract-step.ts
 init_esbuild_shims();
 var import_yaml = __toESM(require_dist(), 1);
-import { mkdirSync as mkdirSync23, readFileSync as readFileSync26, writeFileSync as writeFileSync23, chmodSync } from "node:fs";
-import { dirname as dirname20, resolve as resolve22 } from "node:path";
+import { mkdirSync as mkdirSync23, readFileSync as readFileSync27, writeFileSync as writeFileSync23, chmodSync } from "node:fs";
+import { dirname as dirname21, resolve as resolve23 } from "node:path";
 function expressionsOf(...texts) {
   const seen = /* @__PURE__ */ new Set();
   for (const t2 of texts) {
@@ -16516,10 +17208,10 @@ function nearestFirst(env, sources) {
 }
 __name(nearestFirst, "nearestFirst");
 function runExtractStep(args) {
-  const wfPath = resolve22(args.workflow);
+  const wfPath = resolve23(args.workflow);
   let text;
   try {
-    text = readFileSync26(wfPath, "utf8");
+    text = readFileSync27(wfPath, "utf8");
   } catch (err) {
     throw new Error(
       `extract-step: cannot read ${args.workflow}: ${err.message}`
@@ -16585,8 +17277,8 @@ function runExtractStep(args) {
   const workingDirectory = workingDir?.value;
   const script = step.run;
   const stepLabel = String(step.name ?? step.id ?? index);
-  const outPath = resolve22(args.out);
-  mkdirSync23(dirname20(outPath), { recursive: true });
+  const outPath = resolve23(args.out);
+  mkdirSync23(dirname21(outPath), { recursive: true });
   const header = [
     `#!/usr/bin/env ${shellCommand}`,
     ...commentLines(
@@ -16671,7 +17363,7 @@ var extractStepCommand = {
 
 // packages/cli/src/commands/review/submit.ts
 init_esbuild_shims();
-import { mkdirSync as mkdirSync24, readFileSync as readFileSync27 } from "node:fs";
+import { mkdirSync as mkdirSync24, readFileSync as readFileSync28 } from "node:fs";
 
 // packages/cli/src/commands/review/lib/receipt.ts
 init_esbuild_shims();
@@ -16693,7 +17385,7 @@ __name(parseReceiptIds, "parseReceiptIds");
 var EVENTS = /* @__PURE__ */ new Set(["APPROVE", "REQUEST_CHANGES", "COMMENT"]);
 function readReceiptIds(receiptPath) {
   try {
-    return parseReceiptIds(readFileSync27(receiptPath, "utf8"));
+    return parseReceiptIds(readFileSync28(receiptPath, "utf8"));
   } catch {
     return [];
   }
@@ -16729,12 +17421,8 @@ function authorization(args) {
     repo: args.repo,
     // The EFFECTIVE host, not merely the flag: with --host absent the gh
     // child inherits an operator-exported GH_HOST, so that is where this
-    // write would route — and what the gate must bind. Same resolution as
-    // publish-assets.
-    // `|| undefined`, not `??`: an exported-but-empty GH_HOST ("" survives
-    // `??`, being non-nullish) must read as "no host", not as a host named
-    // "" that fails every comparison.
-    host: args.host ?? (process.env["GH_HOST"]?.trim() || void 0)
+    // write would route — and what the gate must bind.
+    host: resolveGhHost(args.host)
   });
 }
 __name(authorization, "authorization");
@@ -16858,7 +17546,7 @@ function runSubmit(args, cliVersion = "unknown") {
   }
   let payload;
   try {
-    payload = JSON.parse(readFileSync27(args.review, "utf8"));
+    payload = JSON.parse(readFileSync28(args.review, "utf8"));
   } catch (err) {
     throw new Error(
       `Cannot read review JSON ${args.review}: ${err.message}`
@@ -17009,17 +17697,17 @@ init_esbuild_shims();
 import { spawnSync as spawnSync8 } from "node:child_process";
 import {
   mkdirSync as mkdirSync25,
-  readdirSync as readdirSync6,
+  readdirSync as readdirSync7,
   writeFileSync as writeFileSync24,
-  readFileSync as readFileSync28,
+  readFileSync as readFileSync29,
   rmSync as rmSync9,
   lstatSync as lstatSync5,
-  existsSync as existsSync12,
-  statSync as statSync13,
+  existsSync as existsSync13,
+  statSync as statSync14,
   symlinkSync
 } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname as dirname21, join as join18, isAbsolute as isAbsolute5, sep as sep6 } from "node:path";
+import { dirname as dirname22, join as join19, isAbsolute as isAbsolute5, sep as sep7 } from "node:path";
 var FIXTURE_DIR_RE = /(^|\/)(__fixtures__|__mocks__|__snapshots__|fixtures)\//;
 function planTestEfficacy(files, workspaceGlobs) {
   const tests = files.filter((f) => f.kind === "test").map((f) => f.path);
@@ -17543,7 +18231,7 @@ function gitOut2(cwd, ...args) {
 }
 __name(gitOut2, "gitOut");
 function findVitestBin(worktree, resolveModule = createRequire(
-  join18(worktree, "noop.js")
+  join19(worktree, "noop.js")
 ).resolve) {
   let pkgPath;
   try {
@@ -17554,12 +18242,12 @@ function findVitestBin(worktree, resolveModule = createRequire(
     }
     throw error;
   }
-  const pkg = JSON.parse(readFileSync28(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync29(pkgPath, "utf8"));
   const bin = pkg.bin?.vitest;
   if (!bin) {
     throw new Error(`vitest package at ${pkgPath} declares no "vitest" bin`);
   }
-  return join18(dirname21(pkgPath), bin);
+  return join19(dirname22(pkgPath), bin);
 }
 __name(findVitestBin, "findVitestBin");
 function gitCapture(cwd, ...args) {
@@ -17585,7 +18273,7 @@ function safeRmWithin(worktree, relPath) {
   const parts = relPath.split(/[/\\]+/).filter((s) => s && s !== ".");
   let cur = worktree;
   for (let i = 0; i < parts.length; i++) {
-    cur = join18(cur, parts[i]);
+    cur = join19(cur, parts[i]);
     let st;
     try {
       st = lstatSync5(cur);
@@ -17610,15 +18298,15 @@ __name(probeCleanupFailureDetail, "probeCleanupFailureDetail");
 function exposeDependencies(probeTree, dependencyRoot) {
   const done = { linked: 0, failed: 0 };
   if (probeTree === dependencyRoot) return done;
-  const source = join18(dependencyRoot, "node_modules");
-  const target = join18(probeTree, "node_modules");
-  if (!existsSync12(source) || existsSync12(target)) return done;
+  const source = join19(dependencyRoot, "node_modules");
+  const target = join19(probeTree, "node_modules");
+  if (!existsSync13(source) || existsSync13(target)) return done;
   mkdirSync25(target);
   const linkType = process.platform === "win32" ? "junction" : "dir";
-  for (const entry of readdirSync6(source, { withFileTypes: true })) {
+  for (const entry of readdirSync7(source, { withFileTypes: true })) {
     if (entry.name === ".vite" || entry.name === ".vite-temp") continue;
-    const sourceEntry = join18(source, entry.name);
-    const targetEntry = join18(target, entry.name);
+    const sourceEntry = join19(source, entry.name);
+    const targetEntry = join19(target, entry.name);
     let sourceStats;
     try {
       sourceStats = lstatSync5(sourceEntry);
@@ -17628,7 +18316,7 @@ function exposeDependencies(probeTree, dependencyRoot) {
     }
     if (sourceStats.isSymbolicLink()) {
       try {
-        if (!statSync13(sourceEntry).isDirectory()) continue;
+        if (!statSync14(sourceEntry).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -17639,14 +18327,14 @@ function exposeDependencies(probeTree, dependencyRoot) {
       let pkgs;
       try {
         mkdirSync25(targetEntry);
-        pkgs = readdirSync6(sourceEntry);
+        pkgs = readdirSync7(sourceEntry);
       } catch {
         done.failed++;
         continue;
       }
       for (const pkg of pkgs) {
         try {
-          symlinkSync(join18(sourceEntry, pkg), join18(targetEntry, pkg), linkType);
+          symlinkSync(join19(sourceEntry, pkg), join19(targetEntry, pkg), linkType);
           done.linked++;
         } catch {
           done.failed++;
@@ -17792,10 +18480,10 @@ function newSideLength(header) {
 __name(newSideLength, "newSideLength");
 function runOneHunkProbe(probeTree, hunk, probes, deadlineAt, now = Date.now) {
   const { patch: _patch, ...meta } = hunk;
-  const abs = join18(probeTree, hunk.file);
+  const abs = join19(probeTree, hunk.file);
   let original;
   try {
-    original = readFileSync28(abs, "utf8");
+    original = readFileSync29(abs, "utf8");
   } catch (e) {
     return {
       ...meta,
@@ -17821,16 +18509,16 @@ function runOneHunkProbe(probeTree, hunk, probes, deadlineAt, now = Date.now) {
     const detail = verdict === "killed" ? "the suite went red with this hunk reverted \u2014 a test covers this change" : verdict === "survived" ? "every affected test still PASSED with this hunk reverted \u2014 no test in this diff fails when the change is undone" : "the tree with this hunk reverted produced no clean verdict (likely a compile or import error) \u2014 not evidence either way";
     return { ...meta, verdict, detail };
   } finally {
-    mkdirSync25(dirname21(abs), { recursive: true });
+    mkdirSync25(dirname22(abs), { recursive: true });
     writeFileSync24(abs, original, "utf8");
   }
 }
 __name(runOneHunkProbe, "runOneHunkProbe");
 function runControlMutant(probeTree, probeFile, deadlineAt, now = Date.now) {
-  const abs = join18(probeTree, probeFile);
+  const abs = join19(probeTree, probeFile);
   let original;
   try {
-    original = readFileSync28(abs, "utf8");
+    original = readFileSync29(abs, "utf8");
   } catch {
     return null;
   }
@@ -17853,8 +18541,8 @@ __qcIt('QWEN-REVIEW-POSITIVE-CONTROL', () => {
 }
 __name(runControlMutant, "runControlMutant");
 function runOneMutant(probeTree, mutant, probes, deadlineAt, now = Date.now, dependencyRoot = probeTree) {
-  const abs = join18(probeTree, mutant.file);
-  const original = readFileSync28(abs, "utf8");
+  const abs = join19(probeTree, mutant.file);
+  const original = readFileSync29(abs, "utf8");
   const lines = original.split("\n");
   if ((lines[mutant.line - 1] ?? "").trim() !== mutant.statement) {
     return {
@@ -17921,9 +18609,9 @@ async function runTestEfficacy(args) {
   const now = args.now ?? Date.now;
   const startedAt = now();
   const { report, worktree, base, out } = args;
-  const plan = JSON.parse(readFileSync28(report, "utf8"));
+  const plan = JSON.parse(readFileSync29(report, "utf8"));
   const rootPkg = JSON.parse(
-    readFileSync28(`${worktree}/package.json`, "utf8")
+    readFileSync29(`${worktree}/package.json`, "utf8")
   );
   const globs = rootPkg.workspaces ?? [];
   const { unreachable, probes, revert } = planTestEfficacy(
@@ -17931,9 +18619,9 @@ async function runTestEfficacy(args) {
     globs
   );
   for (const p of revert) {
-    const norm = join18(worktree, p);
-    const root = join18(worktree, ".");
-    if (isAbsolute5(p) || norm !== root && !norm.startsWith(root + sep6)) {
+    const norm = join19(worktree, p);
+    const root = join19(worktree, ".");
+    if (isAbsolute5(p) || norm !== root && !norm.startsWith(root + sep7)) {
       throw new Error(
         `refusing to run: revert path escapes the worktree: ${JSON.stringify(p)}`
       );
@@ -18204,7 +18892,7 @@ async function runTestEfficacy(args) {
         } catch (e) {
           removeError = e;
         }
-        if (existsSync12(probeTree)) {
+        if (existsSync13(probeTree)) {
           cleanupFailure = probeCleanupFailureDetail(
             probeTree,
             removeError,
@@ -18303,7 +18991,7 @@ async function runTestEfficacy(args) {
     findings,
     cleanupFailure
   };
-  mkdirSync25(dirname21(out), { recursive: true });
+  mkdirSync25(dirname22(out), { recursive: true });
   writeFileSync24(out, JSON.stringify(result, null, 2), "utf8");
   writeStdoutLine(
     `Wrote test-efficacy report to ${out} (${unreachable.length} unreachable, ${results.length} probed, ${mutantResults.length} mutant(s), ${hunkResults.length} hunk probe(s), ${findings.length} finding(s))`
@@ -18381,8 +19069,8 @@ var testEfficacyCommand = {
 
 // packages/cli/src/commands/review/test-plan.ts
 init_esbuild_shims();
-import { existsSync as existsSync13, mkdirSync as mkdirSync26, readFileSync as readFileSync29, writeFileSync as writeFileSync25 } from "node:fs";
-import { dirname as dirname22, join as join19, normalize, resolve as resolve23 } from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync26, readFileSync as readFileSync30, writeFileSync as writeFileSync25 } from "node:fs";
+import { dirname as dirname23, join as join20, normalize, resolve as resolve24 } from "node:path";
 var PLAN_NAME_RE = /(test\s*plan|\btesting\b|how\s+(?:has\s+this|to)\s+(?:been\s+)?test(?:ed)?|测试计划|测试方案|测试步骤)/i;
 var HEADING_LINE_RE = /^(#{1,6})(?:[ \t](.*))?$/;
 var BOLD_LINE_RE = /^\*\*([^*\n]+)\*\*:?\s*$/;
@@ -18585,7 +19273,7 @@ function rulePath(text, worktree, changed) {
     };
   }
   const ignored = isGitIgnored(worktree, path3);
-  if (existsSync13(join19(worktree, path3))) {
+  if (existsSync14(join20(worktree, path3))) {
     return {
       kind: "path",
       text,
@@ -18656,7 +19344,7 @@ function ruleCommand(text, worktree, buildTest) {
   let rootScripts = [];
   try {
     const rootPkg = JSON.parse(
-      readFileSync29(join19(worktree, "package.json"), "utf8")
+      readFileSync30(join20(worktree, "package.json"), "utf8")
     );
     rootScripts = Object.keys(rootPkg.scripts ?? {});
   } catch {
@@ -18670,7 +19358,7 @@ function ruleCommand(text, worktree, buildTest) {
   for (const dir of skipped) {
     try {
       const pkg = JSON.parse(
-        readFileSync29(join19(worktree, dir, "package.json"), "utf8")
+        readFileSync30(join20(worktree, dir, "package.json"), "utf8")
       );
       for (const s of Object.keys(pkg?.scripts ?? {})) defined.add(s);
     } catch {
@@ -18765,7 +19453,7 @@ __name(fetchPrBody, "fetchPrBody");
 function runTestPlan(args, fetchBody = fetchPrBody) {
   let plan;
   try {
-    plan = JSON.parse(readFileSync29(args.plan, "utf8"));
+    plan = JSON.parse(readFileSync30(args.plan, "utf8"));
   } catch (err) {
     throw new Error(
       `test-plan: cannot read the plan ${args.plan}: ${err.message}`
@@ -18792,7 +19480,7 @@ function runTestPlan(args, fetchBody = fetchPrBody) {
       note: "the PR description has no Test Plan section"
     };
   }
-  const worktree = resolve23(args.worktree);
+  const worktree = resolve24(args.worktree);
   const changed = new Set(
     (plan.files ?? []).map((f) => normalize(String(f.path)))
   );
@@ -18800,7 +19488,7 @@ function runTestPlan(args, fetchBody = fetchPrBody) {
   if (args.buildTest) {
     try {
       buildTest = JSON.parse(
-        readFileSync29(args.buildTest, "utf8")
+        readFileSync30(args.buildTest, "utf8")
       );
     } catch {
       buildTest = null;
@@ -18857,8 +19545,8 @@ var testPlanCommand = {
     try {
       const report = runTestPlan(args);
       if (args.out) {
-        mkdirSync26(dirname22(resolve23(args.out)), { recursive: true });
-        writeFileSync25(resolve23(args.out), JSON.stringify(report, null, 2));
+        mkdirSync26(dirname23(resolve24(args.out)), { recursive: true });
+        writeFileSync25(resolve24(args.out), JSON.stringify(report, null, 2));
       }
       writeStdoutLine(JSON.stringify(report, null, 2));
       writeStderrLine(`test-plan: ${report.note}`);
@@ -18872,8 +19560,8 @@ var testPlanCommand = {
 // packages/cli/src/commands/review/cleanup.ts
 init_esbuild_shims();
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync30, readdirSync as readdirSync7, rmSync as rmSync10 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync31, readdirSync as readdirSync8, rmSync as rmSync10 } from "node:fs";
+import { join as join21 } from "node:path";
 var AUTOMATION_MARKER = "<!-- qwen-";
 function isAutomationComment(body) {
   return (body ?? "").trimStart().startsWith(AUTOMATION_MARKER);
@@ -18904,7 +19592,7 @@ var OWNER_REPO_RE = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
 function readAuditWindow(target, expectedPrNumber) {
   let raw;
   try {
-    raw = readFileSync30(tmpFile(target, "fetch.json"), "utf8");
+    raw = readFileSync31(tmpFile(target, "fetch.json"), "utf8");
   } catch (err) {
     const code = err.code;
     return code === "ENOENT" ? { skip: "no fetch report" } : {
@@ -18951,7 +19639,7 @@ function readSubmitReceipt(target) {
   try {
     return new Set(
       parseReceiptIds(
-        readFileSync30(tmpFile(target, "submit-receipt.json"), "utf8")
+        readFileSync31(tmpFile(target, "submit-receipt.json"), "utf8")
       )
     );
   } catch {
@@ -19078,7 +19766,7 @@ function runCleanup(target) {
   const prefix = tmpPrefix(target);
   let tmpEntries = [];
   try {
-    tmpEntries = existsSync14(REVIEW_TMP_DIR) ? readdirSync7(REVIEW_TMP_DIR) : [];
+    tmpEntries = existsSync15(REVIEW_TMP_DIR) ? readdirSync8(REVIEW_TMP_DIR) : [];
   } catch (err) {
     writeStderrLine(
       `Failed to read ${REVIEW_TMP_DIR}: ${err.message}`
@@ -19086,7 +19774,7 @@ function runCleanup(target) {
   }
   for (const file of tmpEntries) {
     if (!file.startsWith(prefix)) continue;
-    const full = join20(REVIEW_TMP_DIR, file);
+    const full = join21(REVIEW_TMP_DIR, file);
     try {
       rmSync10(full, { recursive: true, force: true });
       writeStdoutLine(`Removed temp file: ${full}`);
@@ -19119,10 +19807,10 @@ var cleanupCommand = {
 
 // packages/cli/src/commands/review/cost-ledger.ts
 init_esbuild_shims();
-import { mkdirSync as mkdirSync27, readFileSync as readFileSync31, statSync as statSync14, writeFileSync as writeFileSync26 } from "node:fs";
-import { dirname as dirname23, join as join21, resolve as resolve24 } from "node:path";
+import { mkdirSync as mkdirSync27, readFileSync as readFileSync32, statSync as statSync15, writeFileSync as writeFileSync26 } from "node:fs";
+import { dirname as dirname24, join as join22, resolve as resolve25 } from "node:path";
 function readUsage(file, floorMs) {
-  const raw = readFileSync31(file, "utf8");
+  const raw = readFileSync32(file, "utf8");
   const events = [];
   let launch = "";
   for (const line of raw.split("\n")) {
@@ -19240,8 +19928,8 @@ function planFloorMs(planPath) {
   let raw;
   let floorMs;
   try {
-    raw = readFileSync31(planPath, "utf8");
-    floorMs = statSync14(planPath).mtimeMs;
+    raw = readFileSync32(planPath, "utf8");
+    floorMs = statSync15(planPath).mtimeMs;
   } catch (err) {
     throw new Error(
       `could not read the plan report ${planPath}: ${err.message}`
@@ -19263,7 +19951,7 @@ __name(planFloorMs, "planFloorMs");
 function computeLedger(planPath, env = process.env) {
   const floorMs = planFloorMs(planPath);
   const { projectDir, sessionId, dir } = transcriptPaths(env);
-  const chatFile = join21(projectDir, "chats", `${sessionId}.jsonl`);
+  const chatFile = join22(projectDir, "chats", `${sessionId}.jsonl`);
   let mainEvents;
   try {
     mainEvents = readUsage(chatFile, floorMs).events;
@@ -19288,10 +19976,10 @@ function computeLedger(planPath, env = process.env) {
   const agents = [];
   const agentEvents = [];
   for (const f of files) {
-    const full = join21(dir, f);
+    const full = join22(dir, f);
     let mtimeMs;
     try {
-      mtimeMs = statSync14(full).mtimeMs;
+      mtimeMs = statSync15(full).mtimeMs;
     } catch {
       continue;
     }
@@ -19399,7 +20087,7 @@ function runCostLedger(args) {
     }
     if (args.out !== void 0 && args.out.length > 0) {
       try {
-        mkdirSync27(dirname23(resolve24(args.out)), { recursive: true });
+        mkdirSync27(dirname24(resolve25(args.out)), { recursive: true });
         writeFileSync26(args.out, JSON.stringify(ledger, null, 2));
       } catch (err) {
         writeStderrLineSafe(
@@ -19433,8 +20121,8 @@ var costLedgerCommand = {
 // packages/cli/src/commands/review/run.ts
 init_esbuild_shims();
 import { spawn, execFileSync as execFileSync6 } from "node:child_process";
-import { readdirSync as readdirSync8, readFileSync as readFileSync32, realpathSync as realpathSync5, statSync as statSync15 } from "node:fs";
-import { dirname as dirname24, join as join22, resolve as resolve25 } from "node:path";
+import { readdirSync as readdirSync9, readFileSync as readFileSync33, realpathSync as realpathSync6, statSync as statSync16 } from "node:fs";
+import { dirname as dirname25, join as join23, resolve as resolve26 } from "node:path";
 var COMPOSED_PATTERN = /^qwen-review-.*composed\.json$/;
 var COMPOSED_POLL_MS = 250;
 var SIGNAL_EXIT_CODES = {
@@ -19462,16 +20150,16 @@ function newestArtifactSince(dir, pattern, startMs) {
   let best = null;
   let names;
   try {
-    names = readdirSync8(dir);
+    names = readdirSync9(dir);
   } catch {
     return null;
   }
   for (const name of names) {
     if (!pattern.test(name)) continue;
-    const path3 = join22(dir, name);
+    const path3 = join23(dir, name);
     let mtime;
     try {
-      mtime = statSync15(path3).mtimeMs;
+      mtime = statSync16(path3).mtimeMs;
     } catch {
       continue;
     }
@@ -19489,7 +20177,7 @@ function exitCodeFor(completed, event2, failOn) {
 __name(exitCodeFor, "exitCodeFor");
 function readComposed(path3) {
   try {
-    const parsed = JSON.parse(readFileSync32(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync33(path3, "utf8"));
     return typeof parsed.event === "string" ? parsed : null;
   } catch {
     return null;
@@ -19520,7 +20208,7 @@ function childEnv() {
     return env;
   }
   try {
-    if (dirname24(realpathSync5(inherited)) === dirname24(realpathSync5(ownEntry))) {
+    if (dirname25(realpathSync6(inherited)) === dirname25(realpathSync6(ownEntry))) {
       return env;
     }
   } catch {
@@ -19642,8 +20330,8 @@ async function runReview(args) {
     downgraded: composed?.downgraded ?? false,
     downgradedFrom: composed?.downgradedFrom ?? null,
     remediation: composed?.remediation ?? [],
-    composedPath: composedPath ? resolve25(composedPath) : null,
-    reportPath: reportPath ? resolve25(reportPath) : null,
+    composedPath: composedPath ? resolve26(composedPath) : null,
+    reportPath: reportPath ? resolve26(reportPath) : null,
     childExitCode,
     childSignal,
     timedOut,
@@ -19657,7 +20345,7 @@ async function runReview(args) {
       writeStdoutLine(result.verdictLine ?? `Event: ${result.event}`);
       if (result.reportPath) writeStdoutLine(`Report: ${result.reportPath}`);
     } else {
-      const detail = composedPath !== null ? `a composed verdict was found at ${resolve25(composedPath)} but could not be parsed` : "no composed verdict was produced";
+      const detail = composedPath !== null ? `a composed verdict was found at ${resolve26(composedPath)} but could not be parsed` : "no composed verdict was produced";
       writeStdoutLine(
         timedOut ? "Review did not complete: timed out." : `Review did not complete: ${detail}${childExitCode !== null ? ` (CLI exit ${childExitCode})` : ""}${childSignal !== null ? ` (killed by ${childSignal})` : ""}.`
       );
@@ -19723,33 +20411,33 @@ var runCommand = {
 // packages/cli/src/commands/review/save-artifact.ts
 init_esbuild_shims();
 import {
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   lstatSync as lstatSync6,
   mkdirSync as mkdirSync28,
-  readFileSync as readFileSync33,
-  statSync as statSync16
+  readFileSync as readFileSync34,
+  statSync as statSync17
 } from "node:fs";
 import {
-  dirname as dirname25,
+  dirname as dirname26,
   isAbsolute as isAbsolute6,
-  join as join23,
-  relative as relative5,
-  resolve as resolve26,
-  sep as sep7,
+  join as join24,
+  relative as relative6,
+  resolve as resolve27,
+  sep as sep8,
   toNamespacedPath
 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 function workspaceRoot(explicit) {
-  return resolve26(explicit ?? process.cwd());
+  return resolve27(explicit ?? process.cwd());
 }
 __name(workspaceRoot, "workspaceRoot");
 function isWithin(parent, child) {
-  const rel = relative5(parent, child);
-  return rel === "" || !isAbsolute6(rel) && rel !== ".." && !rel.startsWith(`..${sep7}`);
+  const rel = relative6(parent, child);
+  return rel === "" || !isAbsolute6(rel) && rel !== ".." && !rel.startsWith(`..${sep8}`);
 }
 __name(isWithin, "isWithin");
 function workspacePath(root, value, label2) {
-  const absolute = resolve26(root, value);
+  const absolute = resolve27(root, value);
   if (!isWithin(root, absolute)) {
     throw new Error(
       `${label2} must be inside the workspace: ${JSON.stringify(value)}.`
@@ -19759,11 +20447,11 @@ function workspacePath(root, value, label2) {
 }
 __name(workspacePath, "workspacePath");
 function rejectSymlinkPath(root, path3, label2) {
-  const rel = relative5(root, path3);
+  const rel = relative6(root, path3);
   let current = root;
-  for (const segment of rel.split(sep7)) {
-    current = join23(current, segment);
-    if (existsSync15(current) && lstatSync6(current).isSymbolicLink()) {
+  for (const segment of rel.split(sep8)) {
+    current = join24(current, segment);
+    if (existsSync16(current) && lstatSync6(current).isSymbolicLink()) {
       throw new Error(`${label2} must not traverse a symbolic link.`);
     }
   }
@@ -19771,15 +20459,15 @@ function rejectSymlinkPath(root, path3, label2) {
 __name(rejectSymlinkPath, "rejectSymlinkPath");
 function sameFile2(left, right) {
   if (left === right) return true;
-  if (!existsSync15(left) || !existsSync15(right)) return false;
-  const leftStat = statSync16(left);
-  const rightStat = statSync16(right);
+  if (!existsSync16(left) || !existsSync16(right)) return false;
+  const leftStat = statSync17(left);
+  const rightStat = statSync17(right);
   return leftStat.dev === rightStat.dev && leftStat.ino === rightStat.ino;
 }
 __name(sameFile2, "sameFile");
 function readText(path3, label2) {
   try {
-    return readFileSync33(path3, "utf8");
+    return readFileSync34(path3, "utf8");
   } catch (error) {
     throw new Error(
       `Could not read the ${label2} file at ${JSON.stringify(path3)}: ${error instanceof Error ? error.message : String(error)}`
@@ -19905,7 +20593,7 @@ function saveReviewArtifact(args) {
   const composedPath = workspacePath(root, args.composed, "Composed input");
   const reportPath = workspacePath(root, args.report, "Markdown report");
   const outputPath = workspacePath(root, args.out, "Output");
-  const reviewsRoot = resolve26(root, REVIEWS_DIR);
+  const reviewsRoot = resolve27(root, REVIEWS_DIR);
   if (!isWithin(reviewsRoot, reportPath) || reportPath === reviewsRoot) {
     throw new Error(
       `Markdown report must be a file under ${JSON.stringify(REVIEWS_DIR)}: ${JSON.stringify(args.report)}.`
@@ -19946,7 +20634,7 @@ function saveReviewArtifact(args) {
   const verdict = validateVerdict(readJson2(composedPath, "composed verdict"));
   let reportIsFile;
   try {
-    reportIsFile = statSync16(reportPath).isFile();
+    reportIsFile = statSync17(reportPath).isFile();
   } catch {
   }
   if (reportIsFile === false) {
@@ -19955,7 +20643,7 @@ function saveReviewArtifact(args) {
     );
   }
   readText(reportPath, "Markdown report");
-  const markdownReportPath = relative5(root, reportPath).split(sep7).join("/");
+  const markdownReportPath = relative6(root, reportPath).split(sep8).join("/");
   const document = {
     schemaVersion: 1,
     target: args.target,
@@ -19966,7 +20654,7 @@ function saveReviewArtifact(args) {
     outcomesRecorded: findings.outcomesRecorded,
     markdownReportPath
   };
-  mkdirSync28(dirname25(outputPath), { recursive: true });
+  mkdirSync28(dirname26(outputPath), { recursive: true });
   atomicWriteFileSync(
     toNamespacedPath(outputPath),
     `${JSON.stringify(document, null, 2)}
@@ -19975,7 +20663,7 @@ function saveReviewArtifact(args) {
   );
   return {
     path: outputPath,
-    workspacePath: relative5(root, outputPath).split(sep7).join("/")
+    workspacePath: relative6(root, outputPath).split(sep8).join("/")
   };
 }
 __name(saveReviewArtifact, "saveReviewArtifact");
@@ -20022,9 +20710,9 @@ var saveArtifactCommand = {
 var reviewCommand = {
   command: "review",
   describe: "Run a review non-interactively (`run`), plus the internal helpers used by the /review skill (PR worktree setup, context fetch, rules loading, presubmit checks, cleanup)",
-  builder: /* @__PURE__ */ __name((yargs) => yargs.command(runCommand).command(parseArgsCommand).command(fetchPrCommand).command(captureLocalCommand).command(planDiffCommand).command(repoContextCommand).command(prContextCommand).command(commentStatusCommand).command(loadRulesCommand).command(agentPromptCommand).command(buildTestCommand).command(baseTreeCommand).command(testDeltaCommand).command(driveCommand).command(mockProviderCommand).command(extractStepCommand).command(scriptLintCommand).command(resolveAnchorsCommand).command(checkCoverageCommand).command(costLedgerCommand).command(presubmitCommand).command(testEfficacyCommand).command(testPlanCommand).command(findingsCommand).command(publishAssetsCommand).command(composeReviewCommand).command(saveArtifactCommand).command(submitCommand).command(cleanupCommand).demandCommand(
+  builder: /* @__PURE__ */ __name((yargs) => yargs.command(runCommand).command(parseArgsCommand).command(matchRemoteCommand).command(fetchPrCommand).command(captureLocalCommand).command(planDiffCommand).command(repoContextCommand).command(prContextCommand).command(commentStatusCommand).command(loadRulesCommand).command(agentPromptCommand).command(buildTestCommand).command(baseTreeCommand).command(testDeltaCommand).command(driveCommand).command(mockProviderCommand).command(extractStepCommand).command(scriptLintCommand).command(resolveAnchorsCommand).command(checkCoverageCommand).command(costLedgerCommand).command(presubmitCommand).command(testEfficacyCommand).command(testPlanCommand).command(findingsCommand).command(publishAssetsCommand).command(composeReviewCommand).command(saveArtifactCommand).command(submitCommand).command(cleanupCommand).demandCommand(
     1,
-    "Specify a subcommand: run, parse-args, fetch-pr, capture-local, plan-diff, repo-context, pr-context, comment-status, load-rules, agent-prompt, build-test, base-tree, test-delta, drive, mock-provider, extract-step, script-lint, resolve-anchors, check-coverage, cost-ledger, presubmit, test-efficacy, test-plan, findings, publish-assets, compose-review, save-artifact, submit, or cleanup."
+    "Specify a subcommand: run, parse-args, match-remote, fetch-pr, capture-local, plan-diff, repo-context, pr-context, comment-status, load-rules, agent-prompt, build-test, base-tree, test-delta, drive, mock-provider, extract-step, script-lint, resolve-anchors, check-coverage, cost-ledger, presubmit, test-efficacy, test-plan, findings, publish-assets, compose-review, save-artifact, submit, or cleanup."
   ).version(false), "builder"),
   handler: /* @__PURE__ */ __name(() => {
   }, "handler")
@@ -20224,10 +20912,10 @@ var updateCommand3 = {
       stdioHelpers,
       { updateEventEmitter }
     ] = await Promise.all([
-      import("./settings-KULVPCQC.js"),
-      import("./updateCheck-QRZ3DVT5.js"),
-      import("./installationInfo-J6QDHNTK.js"),
-      import("./standalone-update-7CXPGAQ4.js"),
+      import("./settings-V7BR3RKP.js"),
+      import("./updateCheck-YZ2CRCFC.js"),
+      import("./installationInfo-VGBXMYLY.js"),
+      import("./standalone-update-QGIKHATD.js"),
       import("./stdioHelpers-7A2EE64Z.js"),
       import("./updateEventEmitter-5MKC7BLQ.js")
     ]);
@@ -20658,8 +21346,8 @@ async function parseArguments() {
       default: false
     }).option("channel", {
       type: "string",
-      choices: ["VSCode", "ACP", "SDK", "CI", "desktop"],
-      description: "Channel identifier (VSCode, ACP, SDK, CI, desktop)"
+      choices: ["VSCode", "ACP", "SDK", "CI", "desktop", "daemon"],
+      description: "Channel identifier (VSCode, ACP, SDK, CI, desktop, daemon)"
     }).option("allowed-mcp-server-names", {
       type: "array",
       string: true,
@@ -20907,7 +21595,7 @@ async function parseArguments() {
     }
   }
   if ((result["acp"] || result["experimentalAcp"]) && !result["channel"]) {
-    result["channel"] = "ACP";
+    result["channel"] = resolveAcpChannelFallback();
   }
   return result;
 }
@@ -21394,7 +22082,7 @@ async function loadCliConfig(settings, argv, cwd = process.cwd(), overrideExtens
     disabledSlashCommands: disabledSlashCommands.length > 0 ? disabledSlashCommands : void 0,
     disabledSkillNamesProvider: bareMode || safeMode ? void 0 : disabledSkillNamesProvider,
     terminalImageRenderSupportProvider: interactive ? async () => {
-      const { getTerminalImageRenderSupport } = await import("./terminal-image-renderer-R5HHAFJN.js");
+      const { getTerminalImageRenderSupport } = await import("./terminal-image-renderer-TLDNACQY.js");
       return getTerminalImageRenderSupport();
     } : void 0,
     disabledSkillLevels: bareMode || safeMode || !Array.isArray(settings.skills?.disabledLevels) ? void 0 : settings.skills.disabledLevels.filter(isSkillLevel),