@qwen-code/qwen-code 0.21.3 → 0.21.4

package/chunks/{chunk-QPSYIV2O.js → chunk-2T3RYG4L.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   serveCommand
-} from "./chunk-BSKUTHLO.js";
+} from "./chunk-2ON2O4MD.js";
 import {
   listCommand
-} from "./chunk-MTR4JWQJ.js";
+} from "./chunk-P5UJMCVS.js";
 import {
   getErrorMessage as getErrorMessage2
-} from "./chunk-EGYJRIDF.js";
+} from "./chunk-EJXATV5R.js";
 import {
   ObservedChannelContactStore
 } from "./chunk-DYA25Y7U.js";
@@ -46,22 +46,22 @@ import {
   registerToolCallDispatch,
   selectFirstModel,
   sessionsPath
-} from "./chunk-2LZCLQIS.js";
+} from "./chunk-5XGI4IPK.js";
 import {
   getExtensionManager,
   requestChoicePluginNonInteractive,
   requestConsentNonInteractive,
   requestConsentOrFail,
   resolveExtensionCommandScope
-} from "./chunk-D2GPKXCQ.js";
+} from "./chunk-O4IWFYUW.js";
 import {
   collectProviderModelsForProtocol,
   getAuthTypeFromEnv,
   resolveCliGenerationConfig
-} from "./chunk-5VYFXHY2.js";
+} from "./chunk-IMGNGOGC.js";
 import {
   parseChannelConfig
-} from "./chunk-LGT3YMLN.js";
+} from "./chunk-LEZFUYPM.js";
 import {
   findCliEntryPath
 } from "./chunk-V6WHFGST.js";
@@ -128,29 +128,29 @@ import {
   assembleMcpServers,
   getPendingGatedMcpServers,
   mcpCommand
-} from "./chunk-2MI7ZTRT.js";
+} from "./chunk-6ME3PVMM.js";
 import {
   loadSettings
-} from "./chunk-22YFMJBW.js";
+} from "./chunk-KB6VSG2U.js";
 import {
   detectSystemLanguage,
   getCurrentLanguage,
   initializeI18n,
   resolveLanguageSetting,
   t
-} from "./chunk-KXWERR6P.js";
+} from "./chunk-FV4TUUDE.js";
 import {
   loadEnvironment
-} from "./chunk-6NE5NTHJ.js";
+} from "./chunk-4PZ7SPD5.js";
 import {
   getCliVersion
-} from "./chunk-BKXTHMOZ.js";
+} from "./chunk-HBCKZF2A.js";
 import {
   getPackageJson
 } from "./chunk-VJNBRRZG.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-M5LIY7Y6.js";
+} from "./chunk-URVJ4AZC.js";
 import {
   require_strip_json_comments
 } from "./chunk-ALGGS7UH.js";
@@ -191,7 +191,7 @@ import {
   unquoteCStylePath,
   updateChannelMemoryEntry,
   updateSetting
-} from "./chunk-UQDFEU47.js";
+} from "./chunk-E2SYUEIA.js";
 import {
   nextFireTime,
   parseCron
@@ -206,14 +206,14 @@ import {
 import {
   getAllGeminiMdFilenames,
   setGeminiMdFilename
-} from "./chunk-4K3RV3OA.js";
+} from "./chunk-JDJ7SC4E.js";
 import {
   SchemaValidator,
   ToolNames
 } from "./chunk-CFDR3GNL.js";
 import {
   DEFAULT_QWEN_EMBEDDING_MODEL
-} from "./chunk-H35Q5CEG.js";
+} from "./chunk-TXZDRD36.js";
 import {
   isTlsVerificationDisabled
 } from "./chunk-BFHXDAR7.js";
@@ -358,9 +358,9 @@ var require_command_exists = __commonJS({
       cleanInput = /* @__PURE__ */ __name(function(s) {
         var isPathName = /[\\]/.test(s);
         if (isPathName) {
-          var dirname19 = '"' + path3.dirname(s) + '"';
-          var basename5 = '"' + path3.basename(s) + '"';
-          return dirname19 + ":" + basename5;
+          var dirname23 = '"' + path3.dirname(s) + '"';
+          var basename6 = '"' + path3.basename(s) + '"';
+          return dirname23 + ":" + basename6;
         }
         return '"' + s + '"';
       }, "cleanInput");
@@ -368,10 +368,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(resolve20, reject) {
+        return new Promise(function(resolve23, reject) {
           commandExists2(commandName, function(error, output) {
             if (output) {
-              resolve20(commandName);
+              resolve23(commandName);
             } else {
               reject(error);
             }
@@ -2255,8 +2255,8 @@ function createBridgeReadinessGate() {
     current: /* @__PURE__ */ __name(() => pending, "current"),
     block: /* @__PURE__ */ __name(() => {
       if (pending) return;
-      pending = new Promise((resolve20) => {
-        releasePending = resolve20;
+      pending = new Promise((resolve23) => {
+        releasePending = resolve23;
       });
     }, "block"),
     release: /* @__PURE__ */ __name(() => {
@@ -2338,7 +2338,7 @@ function createBridgeRecovery(options) {
         writeStderrLine(
           `[Channel] Bridge crashed (${recentCrashCount}/${MAX_CRASH_RESTARTS} in window). Restarting in ${RESTART_DELAY_MS / 1e3}s...`
         );
-        await new Promise((resolve20) => setTimeout(resolve20, RESTART_DELAY_MS));
+        await new Promise((resolve23) => setTimeout(resolve23, RESTART_DELAY_MS));
         const bridge = new AcpBridge(bridgeOpts);
         setBridge(bridge);
         attachDisconnectHandler(bridge);
@@ -3206,12 +3206,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((resolve20, reject) => {
+  return await new Promise((resolve23, reject) => {
     const onAbort = /* @__PURE__ */ __name(() => {
       reject(startupAbortError());
     }, "onAbort");
     signal.addEventListener("abort", onAbort, { once: true });
-    promise.then(resolve20, reject).finally(() => {
+    promise.then(resolve23, reject).finally(() => {
       signal.removeEventListener("abort", onAbort);
     });
   });
@@ -3619,7 +3619,7 @@ function reportStartupToSupervisor(message, signal, subscribeMessage = (listener
   if (!send) {
     return Promise.reject(new Error("Channel worker IPC is unavailable."));
   }
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve23, reject) => {
     let settled = false;
     let unsubscribeMessage = /* @__PURE__ */ __name(() => {
     }, "unsubscribeMessage");
@@ -3633,7 +3633,7 @@ function reportStartupToSupervisor(message, signal, subscribeMessage = (listener
       settled = true;
       cleanup();
       if (error) reject(error);
-      else resolve20();
+      else resolve23();
     }, "finish");
     const onMessage = /* @__PURE__ */ __name((value) => {
       if (isChannelStartupReportAckMessage(value)) {
@@ -3881,8 +3881,8 @@ var daemonWorkerCommand = {
       let shuttingDown = false;
       let exitCode = 0;
       let finish;
-      const finished = new Promise((resolve20) => {
-        finish = resolve20;
+      const finished = new Promise((resolve23) => {
+        finish = resolve23;
       });
       const shutdown = /* @__PURE__ */ __name(async (reason) => {
         if (shuttingDown) {
@@ -3910,8 +3910,8 @@ var daemonWorkerCommand = {
                   ...activeChannelDeliveries.values(),
                   ...activeWebhookTasks.values()
                 ]),
-                new Promise((resolve20) => {
-                  const timer = setTimeout(resolve20, WORKER_SHUTDOWN_DRAIN_MS);
+                new Promise((resolve23) => {
+                  const timer = setTimeout(resolve23, WORKER_SHUTDOWN_DRAIN_MS);
                   timer.unref();
                 })
               ]);
@@ -6127,6 +6127,22 @@ A finding an A/B settled carries \`Source: [probe]\` like any other run-produced
 
 It writes the \`run:\` script **verbatim** as an executable and reports what the runner would have supplied: the effective \`env:\` with all three levels merged and each key's level named, every \`\${{ \u2026 }}\` site listed **unevaluated** \u2014 that list is precisely what you have to stub, because the command refuses to invent values for it \u2014 the resolved \`shell\` and \`working-directory\`, and the commands the script invokes. Stubbing and input are yours: shim \`gh\`/\`curl\` onto \`PATH\`, export the env, run it, observe. **Combined with \`base-tree\`, a workflow A/B is two invocations** \u2014 extract the same step from both trees, feed both the same input, diff what each would have done. That is how the strongest workflow finding in this pipeline's history was produced: the real composer step from both arms, a stubbed \`gh\`, and a byte-for-byte comparison against a comment the workflow had actually posted. Three limits worth knowing before you spend the step: a \`uses:\` step has no \`run:\` and is refused rather than simulated; a step NAME that two steps in the job share is refused as ambiguous rather than resolved to the first, so pass the index (which is what an A/B wants anyway \u2014 the two trees must select the same step, and a name that moved between them is exactly how they stop doing that); and the \`invokes\` list is a labelled heuristic \u2014 the verbatim script beside it is the authority.
 
+**When the claim is about what the product DOES at runtime, drive it \u2014 two commands make that mechanical.** A finding about behaviour ("this hangs when the provider 429s", "the retry never fires", "the daemon answers before it is ready") is settled by running the built product and watching, and the two halves that used to be hand-written every time are now commands.
+
+\`\`\`bash
+"\${QWEN_CODE_CLI:-qwen}" review mock-provider --responder <a module you write> \\
+  --log <plan dir>/mock.jsonl --ttl 600 --out <plan dir>/mock.json &
+until [ -s <plan dir>/mock.json ]; do sleep 0.1; done  # its port is in that report
+"\${QWEN_CODE_CLI:-qwen}" review drive --cwd <the worktree> --script <what to run> \\
+  --ready <a command polled until it exits 0> --timeout 300 --out <plan dir>/drive.json
+\`\`\`
+
+\`mock-provider\` serves \`/v1/chat/completions\` (OpenAI) and \`/v1/messages\` (Anthropic) on an OS-assigned port it reports back, and appends every request to a JSONL log; your responder module exports \`respond(req)\` returning \`{text}\`, \`{tool, args}\` or \`{status, body}\`, and never has to get SSE framing right. **It serves for the whole \`--ttl\` and returns only when that expires** \u2014 so background it and wait, as above; run sequentially it is already shut down by the time the next line starts. Its report is written once the port is bound, which is what makes the file's appearance a readiness signal rather than a guess, and the TTL is the only thing that ends it \u2014 set it to bound the drive, not to match it. **The log is the A/B evidence** \u2014 drive the same script against the PR worktree and the \`base-tree\` path, then diff the two request sequences; a difference is evidence, a reading is not.
+
+\`drive\` owns the three things that used to be guesswork, and its \`outcome\` is what you rule on, never the captured text alone: \`completed\` carries the script's own \`exitCode\` and is the only value that licenses a behavioural claim; \`not-ready\` means the readiness probe never passed, so **nothing was driven and nothing observed is evidence either way**; \`timed-out\` and \`overflowed\` mean the capture is PARTIAL \u2014 a partial capture is not evidence that the run produced nothing; \`unavailable\` (no tmux) is an environment gap and explicitly not a finding. Pass \`--ready\` for anything that binds a port: without it the drive starts immediately, and an empty capture reads as "the feature does not work" when it means "the daemon had not finished starting".
+
+For anything that is not one of those two wires \u2014 the project's own HTTP service, an MCP server, an OAuth endpoint \u2014 stand it up yourself and let \`drive\` own the lifecycle.
+
 **When the claim is about GITHUB's behaviour, neither tree can settle it \u2014 only GitHub can.** A claim like "this encoding renders identically and can never ping", "GitHub strips this tag", "this markdown shape closes the fold" is about the comment pipeline's parser, sanitizer allowlist and notification path, none of which exist in this environment \u2014 a local markdown library is a model of GitHub, and judging a sanitizer claim against a model of the authority is exactly the parser-divergence failure under review. Measured live: an \`@\` \u2192 \`&#64;\` defusal read as sound in every local trace, and GitHub's real renderer registered the mention and fired the notification. So:
 
 - **If the environment variable \`QWEN_REVIEW_SCRATCH_REPO\` is set** (an \`owner/repo\` the user designated for disposable test posts), you may adjudicate on the real renderer: post the payload as an issue comment there \u2014 \`gh api repos/$QWEN_REVIEW_SCRATCH_REPO/issues/<n>/comments -f body=@<file>\` against an issue you created there for this purpose \u2014 read it back with \`-H "Accept: application/vnd.github.html+json"\`, and rule on the returned HTML (and, for mention claims, the timeline events). The observation is the verdict; quote it. This is the ONLY write destination other than \`submit\`'s that any part of this review may touch, it is user-designated, and nothing about the PR under review, its code, or its authors may appear in what you post there \u2014 post the minimal payload shape, not the report.
@@ -6142,6 +6158,13 @@ Return, for each finding, one verdict:
 
 **For anything non-Critical, when uncertain, downgrade to low confidence rather than rejecting.** Reserve outright rejection for a finding that clearly does not match the code (it describes behaviour the code does not have) or matches an Exclusion Criterion. Low confidence is for "likely real, needs human judgement", not for "I have no idea" \u2014 a vague suspicion with no concrete evidence in the code can still be rejected.
 
+**Your job is to falsify, not to fail-to-verify \u2014 and the two feel identical from inside a trace that went nowhere.** Rejection is a claim that you hold **direct counter-evidence**: the quoted contradicting code, the observed probe output, the matched Exclusion Criterion (the one exception stays as stated above: a finding that names nothing checkable at all is rejectable for that reason). Two states reliably masquerade as grounds to reject, and neither is (the split is measured practice from a reflection filter that ran over production reviews at millions-of-comments scale, whose single operating rule was this asymmetry):
+
+- **"I could not verify it."** A trace that fails to confirm a claim is information about your trace, not about the claim \u2014 the trigger may need state you did not construct, a platform you are not on, a timing window your read-through cannot open. If the trace neither confirms nor contradicts, the verdict is \`confirmed (low confidence)\` with what-would-settle-it named. "Could not reproduce the reasoning" is already listed above as insufficient to reject a Critical; it is equally insufficient for a Suggestion whose evidence is merely out of your reach.
+- **"Its evidence is somewhere I did not look."** A finding may rest on evidence the finder gathered and you have not \u2014 a caller grepped in a file the diff never touches, issue evidence fetched from GitHub, a behaviour observed in a run. The evidence being absent from *your* view is not evidence of absence: you have the same tools the finder had, so **go read the claimed source first** \u2014 the named file, the quoted issue text in the launch message, the cited output. Reject only if what you find there contradicts the claim. If the source is genuinely unreachable from this environment (a lightweight diff-only review, an external service), the floor is the low-confidence downgrade, never rejection.
+
+The asymmetry cuts both ways: confirming also requires the trace, and a finding that merely *sounds* right confirms nothing. What it forbids is only the shortcut in the rejecting direction, because that direction is the irreversible one.
+
 **Do not reject an issue-fidelity / root-cause-ownership finding merely because the code compiles, runs, or has a passing test.** A working sanitizer with a green "malformed-shape" test does not disprove an issue-grounded claim that the root cause belongs upstream. Verify such a finding against the issue evidence quoted in the message that launched you; if that evidence is absent or genuinely inconclusive, downgrade rather than reject.`
   },
   "reverse-audit": {
@@ -6245,8 +6268,8 @@ function publicRoleLabelZh(req) {
   return req.file ? `${base}\uFF08${req.file}\uFF09` : base;
 }
 __name(publicRoleLabelZh, "publicRoleLabelZh");
-function label(rec, chunk) {
-  if (chunk !== null) return `chunk ${chunk}`;
+function label(rec, chunk2) {
+  if (chunk2 !== null) return `chunk ${chunk2}`;
   const first = rec.launchPrompt.split("\n")[0]?.trim() ?? "";
   if (first) return first.length > 60 ? `${first.slice(0, 57)}...` : first;
   return rec.agentName || rec.agentId;
@@ -6301,26 +6324,26 @@ function coverageFromTranscripts(planPath, env = process.env) {
     }
     return false;
   }, "keySatisfied");
-  const superseded = /* @__PURE__ */ __name((rec, chunk) => chunk !== null ? chunkSatisfied(chunk, rec) : keySatisfied(rec), "superseded");
+  const superseded = /* @__PURE__ */ __name((rec, chunk2) => chunk2 !== null ? chunkSatisfied(chunk2, rec) : keySatisfied(rec), "superseded");
   for (const rec of records) {
-    const chunk = assignedChunk(rec);
-    const name = label(rec, chunk);
+    const chunk2 = assignedChunk(rec);
+    const name = label(rec, chunk2);
     const given = wasGivenTheDiff(rec, plan.diffPathAbsolute);
-    if (chunk !== null && !given) {
-      if (!superseded(rec, chunk)) blindAgents.push(name);
+    if (chunk2 !== null && !given) {
+      if (!superseded(rec, chunk2)) blindAgents.push(name);
       continue;
     }
     if (rec.successfulToolCalls === 0) {
-      if (!superseded(rec, chunk)) idleAgents.push(name);
+      if (!superseded(rec, chunk2)) idleAgents.push(name);
       continue;
     }
     if (!given) continue;
     let rewrittenThisRecord = false;
-    if (chunk !== null) {
-      const b = builtOf(`chunk-${chunk}`);
+    if (chunk2 !== null) {
+      const b = builtOf(`chunk-${chunk2}`);
       if (b === void 0) {
         rewrittenThisRecord = true;
-        if (!nothingBuiltAtAll && !superseded(rec, chunk)) {
+        if (!nothingBuiltAtAll && !superseded(rec, chunk2)) {
           rewrittenPrompts.push(
             disclose(
               name,
@@ -6333,7 +6356,7 @@ function coverageFromTranscripts(planPath, env = process.env) {
         }
       } else if (!wasDeliveredVerbatim(rec.launchPrompt, b)) {
         rewrittenThisRecord = true;
-        if (!superseded(rec, chunk)) {
+        if (!superseded(rec, chunk2)) {
           rewrittenPrompts.push(
             disclose(
               name,
@@ -6346,7 +6369,7 @@ function coverageFromTranscripts(planPath, env = process.env) {
     }
     const told = pointedAt(rec.launchPrompt, plan);
     if (told.length > 0 && rec.diffToolCalls === 0) {
-      if (!rewrittenThisRecord && !superseded(rec, chunk)) {
+      if (!rewrittenThisRecord && !superseded(rec, chunk2)) {
         unopenedAgents.push(name);
       }
       continue;
@@ -6354,8 +6377,8 @@ function coverageFromTranscripts(planPath, env = process.env) {
     const ranges = merge([...told, ...rec.diffReads]);
     if (ranges.length === 0) continue;
     const u = UNCOVERABLE_RE.exec(rec.finalText);
-    if (u && chunk !== null && Number(u[1]) === chunk) {
-      uncoverable.add(chunk);
+    if (u && chunk2 !== null && Number(u[1]) === chunk2) {
+      uncoverable.add(chunk2);
       continue;
     }
     for (const c of plan.chunks) {
@@ -6751,6 +6774,10 @@ 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",
@@ -7821,7 +7848,7 @@ __name(verdictLine, "verdictLine");
 
 // packages/cli/src/commands/review/findings.ts
 init_esbuild_shims();
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6 } from "node:fs";
+import { existsSync as existsSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6 } from "node:fs";
 import { dirname as dirname5, resolve as resolve5 } from "node:path";
 var SEVERITIES = ["Critical", "Suggestion", "Nice to have"];
 var CONFIDENCES = ["high", "low"];
@@ -7845,6 +7872,18 @@ function asString(o, key) {
   return typeof v === "string" && v.trim() !== "" ? v : void 0;
 }
 __name(asString, "asString");
+function stringArray(o, key, index) {
+  const v = o[key];
+  if (v == null) return void 0;
+  if (!Array.isArray(v) || v.some((x) => typeof x !== "string" || x.trim() === "")) {
+    fail(
+      index,
+      `"${key}" must be an array of non-empty strings, got ${JSON.stringify(v)}.`
+    );
+  }
+  return v.length > 0 ? v : void 0;
+}
+__name(stringArray, "stringArray");
 function oneOf(value, allowed) {
   return typeof value === "string" && allowed.includes(value) ? value : void 0;
 }
@@ -7939,7 +7978,11 @@ function validateFindings(raw) {
         `has outcome ${JSON.stringify(o["outcome"])}; expected one of ${OUTCOMES.map((s) => JSON.stringify(s)).join(", ")}.`
       );
     }
+    const assetFiles = stringArray(o, "assetFiles", i) ?? stringArray(o, "asset_files", i);
+    const assets = stringArray(o, "assets", i);
     const outcomeNote = asString(o, "outcomeNote") ?? asString(o, "outcome_note");
+    const heldRaw = o.heldByMeasurement;
+    const heldFile = heldRaw && typeof heldRaw === "object" ? asString(heldRaw, "file") : void 0;
     const shortSummary = asString(o, "shortSummary") ?? asString(o, "short_summary");
     return {
       id,
@@ -7954,6 +7997,9 @@ function validateFindings(raw) {
       } : {},
       ...asString(o, "category") ? { category: asString(o, "category") } : {},
       locations: parseLocations(o, i),
+      ...assetFiles ? { assetFiles } : {},
+      ...assets ? { assets } : {},
+      ...heldFile ? { heldByMeasurement: { file: heldFile } } : {},
       ...outcome ? { outcome } : {},
       ...outcome && outcomeNote ? { outcomeNote } : {}
     };
@@ -7970,6 +8016,89 @@ function validateFindings(raw) {
   return findings;
 }
 __name(validateFindings, "validateFindings");
+function namesPath(text, probe) {
+  const isNameChar = /* @__PURE__ */ __name((c) => c !== void 0 && /[A-Za-z0-9._-]/.test(c), "isNameChar");
+  const isBoundary = /* @__PURE__ */ __name((c) => c === void 0 || !isNameChar(c) && c !== "/", "isBoundary");
+  let from = 0;
+  for (; ; ) {
+    const at = text.indexOf(probe, from);
+    if (at < 0) return false;
+    const after = text[at + probe.length];
+    const extendsName = after !== void 0 && (/[A-Za-z0-9_-]/.test(after) || after === "." && /[A-Za-z0-9]/.test(text[at + probe.length + 1] ?? ""));
+    if (isBoundary(at === 0 ? void 0 : text[at - 1]) && !extendsName) {
+      return true;
+    }
+    from = at + 1;
+  }
+}
+__name(namesPath, "namesPath");
+function holdCriticalsFailingOnBase(findings, sharedFailingFiles) {
+  const held = [];
+  const readjudicated = [];
+  const out = findings.map((f) => {
+    if (f.severity !== "Critical") return f;
+    const haystack = [f.summary, f.failureScenario].join("\n");
+    const hit = sharedFailingFiles.find((p) => p && namesPath(haystack, p));
+    if (!hit) return f;
+    if (f.heldByMeasurement?.file === hit) {
+      readjudicated.push({ id: f.id, file: hit });
+      return f;
+    }
+    held.push({ id: f.id, file: hit });
+    return {
+      ...f,
+      severity: "Suggestion",
+      heldByMeasurement: { file: hit },
+      failureScenario: `${f.failureScenario}
+
+Held back from Critical by measurement: \`test-delta\` reran the failing test command on the merge base and ${hit} failed there too, so this is not a passing test the PR turns red. If the PR makes an already-red test fail for a NEW reason, say which test, quote both sides, and file it at Critical again: a finding that already carries this measurement and is raised anyway is left where you put it.`
+    };
+  });
+  return { findings: out, held, readjudicated };
+}
+__name(holdCriticalsFailingOnBase, "holdCriticalsFailingOnBase");
+var WORKSPACE_IN_COMMAND_RE = /--workspace="([^"]+)"/;
+function repoRelative(path3, workspace) {
+  const at = path3.indexOf("::");
+  const bare = at < 0 ? path3 : path3.slice(at + 2);
+  if (at >= 0 && !workspace) return void 0;
+  if (!workspace || bare.startsWith(`${workspace}/`)) return bare;
+  return `${workspace}/${bare}`;
+}
+__name(repoRelative, "repoRelative");
+function sharedFailingFilesOf(raw) {
+  if (!raw || typeof raw !== "object")
+    return { shared: [], unidentifiable: [] };
+  const shared = /* @__PURE__ */ new Set();
+  const netNew = /* @__PURE__ */ new Set();
+  const unidentifiable = /* @__PURE__ */ new Set();
+  const take = /* @__PURE__ */ __name((into, v, workspace) => {
+    if (!Array.isArray(v)) return;
+    for (const e of v) {
+      if (typeof e !== "string" || !e) continue;
+      const qualified = repoRelative(e, workspace);
+      if (qualified === void 0) {
+        if (into === shared) unidentifiable.add(e);
+      } else into.add(qualified);
+    }
+  }, "take");
+  const entries = raw.entries;
+  const rows = Array.isArray(entries) ? entries : [];
+  if (rows.length > 0) {
+    for (const e of rows) {
+      if (!e || typeof e !== "object") continue;
+      const command = e.command;
+      const workspace = typeof command === "string" ? WORKSPACE_IN_COMMAND_RE.exec(command)?.[1] ?? void 0 : void 0;
+      take(shared, e.shared, workspace);
+      take(netNew, e.netNew, workspace);
+    }
+  }
+  return {
+    shared: [...shared].filter((f) => !netNew.has(f)),
+    unidentifiable: [...unidentifiable]
+  };
+}
+__name(sharedFailingFilesOf, "sharedFailingFilesOf");
 function sortFindings(findings) {
   return [...findings].sort((a, b) => {
     const bySeverity = SEVERITIES.indexOf(a.severity) - SEVERITIES.indexOf(b.severity);
@@ -8072,6 +8201,7 @@ function buildReport(findings) {
       total: sorted.length,
       bySeverity,
       byConfidence,
+      held: sorted.filter((f) => f.heldByMeasurement !== void 0).length,
       ...byOutcome ? { byOutcome } : {}
     },
     outcomesRecorded
@@ -8121,12 +8251,15 @@ var findingsCommand = {
   }).option("outcomes", {
     type: "string",
     describe: "JSON array of {id, outcome, note?} recording what --fix did to each finding. Must cover every finding."
+  }).option("test-delta", {
+    type: "string",
+    describe: "The test-delta artifact. A Critical naming a test file that also failed on the merge base is held back to Suggestion, carrying the measurement that demoted it."
   }).option("print", {
     type: "boolean",
     describe: "Also print one line per finding to stdout"
   }), "builder"),
   handler: /* @__PURE__ */ __name((argv) => {
-    const { input, out, outcomes, print } = argv;
+    const { input, out, outcomes, print, testDelta } = argv;
     let findings = validateFindings(readJson(input, "findings"));
     if (outcomes !== void 0) {
       findings = applyOutcomes(
@@ -8134,6 +8267,30 @@ var findingsCommand = {
         validateOutcomes(readJson(outcomes, "outcomes"))
       );
     }
+    let held = [];
+    let readjudicated = [];
+    if (testDelta !== void 0) {
+      let measurement;
+      if (existsSync3(resolve5(testDelta))) {
+        try {
+          measurement = readJson(testDelta, "test-delta");
+        } catch (err) {
+          writeStderrLine(
+            `findings: no holds applied \u2014 ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      const { shared, unidentifiable } = sharedFailingFilesOf(measurement);
+      for (const f of unidentifiable) {
+        writeStderrLine(
+          `findings: ignored the measured file ${f} \u2014 it carries a vitest project key and no workspace to resolve it against, so which project it names cannot be established`
+        );
+      }
+      ({ findings, held, readjudicated } = holdCriticalsFailingOnBase(
+        findings,
+        shared
+      ));
+    }
     const report = buildReport(findings);
     const target = resolve5(out);
     mkdirSync6(dirname5(target), { recursive: true });
@@ -8143,6 +8300,16 @@ var findingsCommand = {
     writeStderrLine(
       `findings: ${report.counts.total} total \u2014 ${bySeverity["Critical"]} Critical, ${bySeverity["Suggestion"]} Suggestion, ${bySeverity["Nice to have"]} Nice to have; ${byConfidence["low"]} low-confidence. Wrote ${target}`
     );
+    for (const h of held) {
+      writeStderrLine(
+        `findings: ${h.id} held back from Critical \u2014 test-delta measured ${h.file} as failing on the merge base too`
+      );
+    }
+    for (const r of readjudicated) {
+      writeStderrLine(
+        `findings: ${r.id} left at Critical \u2014 it already carries the ${r.file} measurement and was raised again anyway`
+      );
+    }
     if (report.counts.byOutcome) {
       const o = report.counts.byOutcome;
       writeStderrLine(
@@ -8164,7 +8331,7 @@ 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 existsSync3, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync4, rmSync as rmSync3 } from "node:fs";
 var GIT_TIMEOUT_MS2 = 12e4;
 function gitOpts() {
   return {
@@ -8210,7 +8377,7 @@ function worktreeReleaseResult(existed, stillThere, removeError) {
 }
 __name(worktreeReleaseResult, "worktreeReleaseResult");
 function releaseWorktree(worktreePath2) {
-  const existed = existsSync3(worktreePath2);
+  const existed = existsSync4(worktreePath2);
   let removeError;
   if (existed) {
     gitOpt("worktree", "remove", worktreePath2, "--force");
@@ -8221,7 +8388,7 @@ function releaseWorktree(worktreePath2) {
     }
   }
   gitOpt("worktree", "prune");
-  return worktreeReleaseResult(existed, existsSync3(worktreePath2), removeError);
+  return worktreeReleaseResult(existed, existsSync4(worktreePath2), removeError);
 }
 __name(releaseWorktree, "releaseWorktree");
 function gitRaw(...args) {
@@ -10087,8 +10254,8 @@ var loadRulesCommand = {
 // packages/cli/src/commands/review/presubmit.ts
 init_esbuild_shims();
 import { writeFileSync as writeFileSync13, readFileSync as readFileSync13 } from "node:fs";
-function verdictStamp(run3) {
-  return run3.completed_at ?? run3.started_at ?? "";
+function verdictStamp(run4) {
+  return run4.completed_at ?? run4.started_at ?? "";
 }
 __name(verdictStamp, "verdictStamp");
 var FAIL_CONCLUSIONS = /* @__PURE__ */ new Set([
@@ -10110,11 +10277,11 @@ var PENDING_STATES = /* @__PURE__ */ new Set([
   "requested"
 ]);
 var NOT_RUN_CONCLUSIONS = /* @__PURE__ */ new Set(["skipped", "neutral", "stale"]);
-function isCurrentActionsRunCheck(run3) {
+function isCurrentActionsRunCheck(run4) {
   const runId = process.env["GITHUB_RUN_ID"];
   if (!runId) return false;
   const runUrlMarker = `/actions/runs/${runId}/`;
-  return [run3.details_url, run3.html_url].some(
+  return [run4.details_url, run4.html_url].some(
     (url) => typeof url === "string" && url.includes(runUrlMarker)
   );
 }
@@ -10179,33 +10346,33 @@ function classifyCi(checkRuns, statuses) {
   const failedCheckNames = [];
   let hasPending = false;
   const relevantCheckRuns = checkRuns.filter(
-    (run3) => !isCurrentActionsRunCheck(run3)
+    (run4) => !isCurrentActionsRunCheck(run4)
   );
   const executedNames = /* @__PURE__ */ new Set();
   const notRunNames = /* @__PURE__ */ new Set();
-  for (const run3 of relevantCheckRuns) {
-    if (run3.status !== "completed") continue;
-    if (!run3.conclusion || NOT_RUN_CONCLUSIONS.has(run3.conclusion)) {
-      notRunNames.add(run3.name);
+  for (const run4 of relevantCheckRuns) {
+    if (run4.status !== "completed") continue;
+    if (!run4.conclusion || NOT_RUN_CONCLUSIONS.has(run4.conclusion)) {
+      notRunNames.add(run4.name);
     } else {
-      executedNames.add(run3.name);
+      executedNames.add(run4.name);
     }
   }
   const skippedCheckNames = [...notRunNames].filter((n) => !executedNames.has(n)).sort();
   const latestVerdicts = /* @__PURE__ */ new Map();
-  for (const run3 of relevantCheckRuns) {
-    if (run3.status !== "completed") {
-      if (PENDING_STATES.has(run3.status)) hasPending = true;
+  for (const run4 of relevantCheckRuns) {
+    if (run4.status !== "completed") {
+      if (PENDING_STATES.has(run4.status)) hasPending = true;
       continue;
     }
-    if (!run3.conclusion || NOT_RUN_CONCLUSIONS.has(run3.conclusion)) continue;
-    const prev = latestVerdicts.get(run3.name);
-    if (!prev || verdictStamp(run3) > verdictStamp(prev)) {
-      latestVerdicts.set(run3.name, run3);
+    if (!run4.conclusion || NOT_RUN_CONCLUSIONS.has(run4.conclusion)) continue;
+    const prev = latestVerdicts.get(run4.name);
+    if (!prev || verdictStamp(run4) > verdictStamp(prev)) {
+      latestVerdicts.set(run4.name, run4);
     }
   }
-  for (const [name, run3] of latestVerdicts) {
-    if (FAIL_CONCLUSIONS.has(run3.conclusion)) {
+  for (const [name, run4] of latestVerdicts) {
+    if (FAIL_CONCLUSIONS.has(run4.conclusion)) {
       failedCheckNames.push(name);
     }
   }
@@ -10461,120 +10628,690 @@ var presubmitCommand = {
   }, "handler")
 };
 
-// packages/cli/src/commands/review/resolve-anchors.ts
+// packages/cli/src/commands/review/publish-assets.ts
 init_esbuild_shims();
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync14, mkdirSync as mkdirSync13 } from "node:fs";
-import { dirname as dirname11, resolve as resolve10 } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+import { readFileSync as readFileSync15, statSync as statSync5, writeFileSync as writeFileSync14, mkdirSync as mkdirSync14 } from "node:fs";
+import { basename as basename5, dirname as dirname11, resolve as resolve10 } from "node:path";
 
-// packages/cli/src/commands/review/lib/anchors.ts
+// packages/cli/src/commands/review/lib/authorization.ts
 init_esbuild_shims();
-function collectNewSideLines(diffText, file) {
-  const lines2 = diffText.split("\n");
-  const out = [];
-  for (const hunk of file.hunks) {
-    if (hunk.newCount === 0) continue;
-    let newCursor = hunk.newStart;
-    for (let n = hunk.diffStart + 1; n <= hunk.diffEnd; n++) {
-      const raw = lines2[n - 1];
-      if (raw === void 0) break;
-      if (raw.startsWith("+")) {
-        out.push({ newLine: newCursor, text: raw.slice(1), added: true });
-        newCursor++;
-      } else if (raw.startsWith("-")) {
-      } else if (raw.startsWith(" ") || raw === "") {
-        out.push({
-          newLine: newCursor,
-          text: raw.startsWith(" ") ? raw.slice(1) : "",
-          added: false
-        });
-        newCursor++;
-      }
-    }
-  }
-  return out;
+import { readFileSync as readFileSync14 } from "node:fs";
+
+// packages/cli/src/services/skill-args-file.ts
+init_esbuild_shims();
+import {
+  mkdirSync as mkdirSync13,
+  openSync as openSync2,
+  writeSync,
+  closeSync as closeSync2,
+  rmSync as rmSync4,
+  lstatSync as lstatSync3,
+  existsSync as existsSync5,
+  constants
+} from "node:fs";
+import { join as join11 } from "node:path";
+var debugLogger3 = createDebugLogger("SKILL_ARGS_FILE");
+var SKILL_ARGS_DIR = join11(".qwen", "tmp");
+function safe(s) {
+  return s.replace(/[^A-Za-z0-9._-]/g, "_");
 }
-__name(collectNewSideLines, "collectNewSideLines");
-function normalizeExact(s) {
-  return s.replace(/\s+$/, "");
+__name(safe, "safe");
+function currentSessionId() {
+  return sessionIdContext.getStore()?.trim() || process.env["QWEN_CODE_SESSION_ID"]?.trim() || "";
 }
-__name(normalizeExact, "normalizeExact");
-function normalizeLoose(s) {
-  return s.trim();
+__name(currentSessionId, "currentSessionId");
+function skillArgsDir(sessionId = currentSessionId()) {
+  return sessionId ? join11(SKILL_ARGS_DIR, `s-${safe(sessionId)}`) : SKILL_ARGS_DIR;
 }
-__name(normalizeLoose, "normalizeLoose");
-function anchorVariants(anchor) {
-  const lines2 = anchor.replace(/\r\n/g, "\n").split("\n");
-  while (lines2.length > 0 && lines2[0].trim() === "") lines2.shift();
-  while (lines2.length > 0 && lines2[lines2.length - 1].trim() === "") lines2.pop();
-  if (lines2.length === 0) return [];
-  const variants = [lines2];
-  const meaningful = lines2.filter((l) => l.trim() !== "");
-  if (meaningful.length > 0 && meaningful.every((l) => /^\+/.test(l))) {
-    variants.push(lines2.map((l) => l.startsWith("+") ? l.slice(1) : l));
-  }
-  const NO_NEWLINE = /^\$/;
-  const marked = lines2.filter((l) => l !== "" && !NO_NEWLINE.test(l));
-  if (marked.length > 0 && marked.every((l) => /^[+\- ]/.test(l)) && marked.some((l) => l.startsWith("+"))) {
-    variants.push(
-      lines2.filter((l) => !l.startsWith("-") && !NO_NEWLINE.test(l)).map((l) => l.slice(1))
-    );
-  }
-  return variants;
+__name(skillArgsDir, "skillArgsDir");
+function skillArgsPath(skillName, sessionId = currentSessionId()) {
+  return join11(
+    skillArgsDir(sessionId),
+    `qwen-skill-args-${safe(skillName)}.txt`
+  );
 }
-__name(anchorVariants, "anchorVariants");
-function matchRuns(hay, needle, norm) {
-  const starts = [];
-  if (needle.length === 0 || hay.length < needle.length) return starts;
-  const normNeedle = needle.map(norm);
-  for (let i = 0; i + normNeedle.length <= hay.length; i++) {
-    let ok = true;
-    for (let j = 0; j < normNeedle.length; j++) {
-      const cell = hay[i + j];
-      if (norm(cell.text) !== normNeedle[j]) {
-        ok = false;
-        break;
-      }
-      if (j > 0 && cell.newLine !== hay[i + j - 1].newLine + 1) {
-        ok = false;
-        break;
+__name(skillArgsPath, "skillArgsPath");
+function writeSkillArgs(skillName, args) {
+  const path3 = skillArgsPath(skillName);
+  try {
+    const dir = skillArgsDir();
+    mkdirSync13(dir, { recursive: true });
+    if (lstatSync3(dir).isSymbolicLink()) {
+      debugLogger3.warn(
+        `Skill args directory ${dir} is a symlink; refusing to write through it.`
+      );
+      return null;
+    }
+    if (lstatSync3(path3, { throwIfNoEntry: false })?.isSymbolicLink()) {
+      debugLogger3.warn(
+        `Skill args file ${path3} is a symlink; refusing to write through it.`
+      );
+      return null;
+    }
+    const fd = openSync2(
+      path3,
+      constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | constants.O_NOFOLLOW,
+      384
+    );
+    try {
+      const buf = Buffer.from(args, "utf8");
+      let off = 0;
+      while (off < buf.length) {
+        off += writeSync(fd, buf, off, buf.length - off);
       }
+    } finally {
+      closeSync2(fd);
     }
-    if (ok) starts.push(i);
+    return path3;
+  } catch (err) {
+    debugLogger3.warn(
+      `Could not write skill args to ${path3}: ${err.message}`
+    );
+    return null;
   }
-  return starts;
 }
-__name(matchRuns, "matchRuns");
-function candidatesFor(hay, needle, norm) {
-  return matchRuns(hay, needle, norm).map((i) => {
-    const run3 = hay.slice(i, i + needle.length);
+__name(writeSkillArgs, "writeSkillArgs");
+function clearSkillArgs(skillName) {
+  const path3 = skillArgsPath(skillName);
+  try {
+    rmSync4(path3, { force: true });
+  } catch (err) {
+    debugLogger3.warn(
+      `Could not clear skill args for ${skillName}: ${err.message}`
+    );
+    return false;
+  }
+  if (existsSync5(path3)) {
+    debugLogger3.warn(`Skill args for ${skillName} survived removal at ${path3}`);
+    return false;
+  }
+  return true;
+}
+__name(clearSkillArgs, "clearSkillArgs");
+function staleArgsWarning() {
+  return `
+
+<skill-args-stale>A previous invocation's argument record could not be removed, so it is still on disk and still names whatever it named. This invocation supplied NO arguments. Do not treat that stale record as this run's authorisation: this run has none, and must not post.</skill-args-stale>
+`;
+}
+__name(staleArgsWarning, "staleArgsWarning");
+function skillArgsNote(path3, args) {
+  return `
+
+Your invocation arguments have been written verbatim to a session-private file. Its exact path is below \u2014 use it wherever these instructions say to read the args file (e.g. \`< '${path3}'\`), and do not retype the arguments, which is how they get mistyped.
+<skill-args-file>${path3}</skill-args-file>
+<skill-args>${args}</skill-args>
+`;
+}
+__name(skillArgsNote, "skillArgsNote");
+
+// packages/cli/src/commands/review/lib/authorization.ts
+function defaultSkillArgsPath() {
+  return skillArgsPath("review");
+}
+__name(defaultSkillArgsPath, "defaultSkillArgsPath");
+function reviewWriteAuthorization(req) {
+  if (req.userAuthorized) {
+    return { ok: true, why: "the user asked for this review to be published" };
+  }
+  const sessionScoped = defaultSkillArgsPath();
+  const path3 = currentSessionId() === "" && req.skillArgs ? req.skillArgs : sessionScoped;
+  let raw;
+  try {
+    raw = readFileSync14(path3, "utf8");
+  } catch {
     return {
-      startLine: run3[0].newLine,
-      line: run3[run3.length - 1].newLine,
-      added: run3.some((l) => l.added)
+      ok: false,
+      why: `no review arguments were recorded at ${path3}, so this run cannot show that \`--comment\` was requested`
     };
-  });
-}
-__name(candidatesFor, "candidatesFor");
-function pick(cands, claimedLine) {
-  if (cands.length === 1) return cands[0];
-  if (claimedLine !== void 0) {
-    const dist = /* @__PURE__ */ __name((c) => Math.abs(c.startLine - claimedLine), "dist");
-    let best = Infinity;
-    for (const c of cands) best = Math.min(best, dist(c));
-    const nearest = cands.filter((c) => dist(c) === best);
-    return nearest.length === 1 ? nearest[0] : null;
   }
-  const added = cands.filter((c) => c.added);
-  return added.length === 1 ? added[0] : null;
-}
-__name(pick, "pick");
-function resolveAnchor(newSideLines, anchor, claimedLine) {
-  const variants = anchorVariants(anchor);
-  if (variants.length === 0) {
-    return { status: "unmatched", reason: "anchor is empty" };
+  const verdict = parseReviewArgs(raw);
+  if (!verdict.comment.effective) {
+    return {
+      ok: false,
+      why: `\`--comment\` was not in the review arguments (${JSON.stringify(raw.trim())})`
+    };
   }
-  for (const [vi, needle] of variants.entries()) {
-    const norms = vi === 0 ? [
+  const t2 = verdict.target;
+  const authorisedPr = t2.type === "pr-number" || t2.type === "pr-url" ? t2.number : void 0;
+  if (authorisedPr === void 0) {
+    return {
+      ok: false,
+      why: `the review arguments (${JSON.stringify(raw.trim())}) do not name a pull request, so they cannot authorise posting to one`
+    };
+  }
+  if (authorisedPr !== req.pr) {
+    return {
+      ok: false,
+      why: `the review arguments authorise pull request #${authorisedPr}, but this submission targets #${req.pr}`
+    };
+  }
+  if (t2.type === "pr-url") {
+    if (req.repo !== void 0) {
+      const authorisedRepo = `${t2.owner}/${t2.repo}`;
+      if (authorisedRepo.toLowerCase() !== req.repo.toLowerCase()) {
+        return {
+          ok: false,
+          why: `the review arguments authorise ${authorisedRepo}, but this submission targets ${req.repo}`
+        };
+      }
+    }
+    const writeHost = (req.host ?? "github.com").toLowerCase();
+    if (t2.host.toLowerCase() !== writeHost) {
+      return {
+        ok: false,
+        why: `the review arguments authorise ${t2.host}, but this submission targets ${req.host ?? "github.com"}`
+      };
+    }
+  }
+  return {
+    ok: true,
+    why: `\`--comment\` was in the review arguments for #${authorisedPr}`
+  };
+}
+__name(reviewWriteAuthorization, "reviewWriteAuthorization");
+
+// packages/cli/src/commands/review/lib/assets.ts
+init_esbuild_shims();
+var ASSET_EXTENSIONS = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "webp"]);
+var MAX_ASSET_BYTES = 10 * 1024 * 1024;
+var MAX_TOTAL_ASSET_BYTES = 40 * 1024 * 1024;
+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, "_");
+  return `${pr}-review/${sha256Hex.slice(0, 12)}-${safe2}`;
+}
+__name(remoteAssetPath, "remoteAssetPath");
+function rawAssetUrl(opts) {
+  const host = opts.host && opts.host.trim() !== "" ? opts.host : "github.com";
+  return `https://${host}/${opts.repo}/raw/${opts.commitSha}/${opts.remotePath}`;
+}
+__name(rawAssetUrl, "rawAssetUrl");
+function parseAssetsRepo(value) {
+  const v = (value ?? "").trim();
+  if (v === "") {
+    return {
+      error: "QWEN_REVIEW_ASSETS_REPO is not set. Designate an assets repository (owner/repo you can push to \u2014 the repo under review for maintainers, a fork or scratch repo otherwise) to publish review evidence images."
+    };
+  }
+  const parts = v.split("/");
+  const segmentOk = /* @__PURE__ */ __name((p) => /^[A-Za-z0-9_.-]+$/.test(p) && p !== "." && p !== "..", "segmentOk");
+  if (parts.length !== 2 || !parts.every(segmentOk)) {
+    return {
+      error: `QWEN_REVIEW_ASSETS_REPO must be owner/repo, got ${JSON.stringify(v)}.`
+    };
+  }
+  return { repo: v };
+}
+__name(parseAssetsRepo, "parseAssetsRepo");
+function validateAssetFile(basename6, bytes) {
+  const ext = basename6.includes(".") ? basename6.slice(basename6.lastIndexOf(".") + 1).toLowerCase() : "";
+  if (!ASSET_EXTENSIONS.has(ext)) {
+    return {
+      ok: false,
+      reason: `${basename6}: extension ${JSON.stringify(ext)} is not an allowed evidence image type (${[...ASSET_EXTENSIONS].join(", ")})`
+    };
+  }
+  if (bytes <= 0) {
+    return { ok: false, reason: `${basename6}: empty file` };
+  }
+  if (bytes > MAX_ASSET_BYTES) {
+    return {
+      ok: false,
+      reason: `${basename6}: ${bytes} bytes exceeds the per-file cap of ${MAX_ASSET_BYTES} bytes`
+    };
+  }
+  return { ok: true };
+}
+__name(validateAssetFile, "validateAssetFile");
+function validateAssetBatch(files) {
+  let total = 0;
+  for (const f of files) {
+    const one = validateAssetFile(f.basename, f.bytes);
+    if (!one.ok) return one;
+    total += f.bytes;
+    if (total > MAX_TOTAL_ASSET_BYTES) {
+      return {
+        ok: false,
+        reason: `total size exceeds ${MAX_TOTAL_ASSET_BYTES} bytes`
+      };
+    }
+  }
+  return { ok: true };
+}
+__name(validateAssetBatch, "validateAssetBatch");
+
+// packages/cli/src/commands/review/publish-assets.ts
+function putContent(repo, branch, remotePath, contentBase64, pr) {
+  const api = `repos/${repo}/contents/${remotePath}`;
+  const message = `review evidence for PR #${pr}`;
+  const payload = /* @__PURE__ */ __name((sha) => JSON.stringify({
+    message,
+    content: contentBase64,
+    branch,
+    ...sha ? { sha } : {}
+  }), "payload");
+  try {
+    ghWithInputRetried(payload(), "api", "-X", "PUT", api, "--input", "-");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!/HTTP 422|"sha"|sha wasn't supplied|already exists/i.test(msg)) {
+      throw err;
+    }
+    let existing;
+    try {
+      existing = gh(
+        "api",
+        `${api}?ref=${encodeURIComponent(branch)}`,
+        "--jq",
+        ".sha"
+      ).trim();
+    } catch {
+      throw err;
+    }
+    if (existing === "" || existing === "null") {
+      throw err;
+    }
+    ghWithInputRetried(
+      payload(existing),
+      "api",
+      "-X",
+      "PUT",
+      api,
+      "--input",
+      "-"
+    );
+  }
+}
+__name(putContent, "putContent");
+function ensureBranch(repo, branch) {
+  try {
+    gh("api", `repos/${repo}/git/ref/heads/${branch}`);
+    return;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!/HTTP 404|Not Found/i.test(msg)) throw err;
+  }
+  const defaultBranch = gh("api", `repos/${repo}`, "--jq", ".default_branch");
+  let baseSha;
+  try {
+    baseSha = gh(
+      "api",
+      `repos/${repo}/git/ref/heads/${defaultBranch.trim()}`,
+      "--jq",
+      ".object.sha"
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/HTTP 404|Not Found/i.test(msg)) {
+      throw new Error(
+        `assets repository ${repo} appears to be empty (its default branch ${defaultBranch.trim()} has no commits). Push an initial commit to it once; publish-assets creates and reuses its own branch from there.`
+      );
+    }
+    throw err;
+  }
+  const base = baseSha.trim();
+  if (base === "" || base === "null") {
+    throw new Error(
+      `could not resolve the head of ${repo}@${defaultBranch.trim()} \u2014 the ref lookup returned nothing to branch from.`
+    );
+  }
+  try {
+    ghWithInputRetried(
+      JSON.stringify({ ref: `refs/heads/${branch}`, sha: base }),
+      "api",
+      "-X",
+      "POST",
+      `repos/${repo}/git/refs`,
+      "--input",
+      "-"
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!/already exists/i.test(msg)) throw err;
+  }
+}
+__name(ensureBranch, "ensureBranch");
+function runPublishAssets(args) {
+  const refuse = /* @__PURE__ */ __name((reason) => {
+    writeStderrLine(`publish-assets: refused \u2014 ${reason}`);
+    writeStdoutLine(JSON.stringify({ published: false }));
+    process.exitCode = 3;
+  }, "refuse");
+  if (!Number.isInteger(args.pr) || args.pr <= 0) {
+    refuse(`--pr must be a positive integer, got ${String(args.pr)}.`);
+    return;
+  }
+  const repoResult = parseAssetsRepo(process.env["QWEN_REVIEW_ASSETS_REPO"]);
+  if ("error" in repoResult) {
+    refuse(repoResult.error);
+    return;
+  }
+  const repo = repoResult.repo;
+  const effectiveHost = args.host ?? (process.env["GH_HOST"]?.trim() || void 0);
+  const auth = reviewWriteAuthorization({
+    userAuthorized: args.userAuthorized,
+    skillArgs: args.skillArgs,
+    pr: args.pr,
+    // Bind the REVIEWED repo when the caller names it, never the assets repo:
+    // the designation itself is the consent for the destination, and binding a
+    // URL-shaped authorisation against a fork-hosted assets repo refused
+    // legitimately authorised runs. Without --reviewed-repo the gate binds the
+    // PR number (and host) alone.
+    repo: args.reviewedRepo,
+    host: effectiveHost
+  });
+  if (!auth.ok) {
+    refuse(
+      `not authorised \u2014 ${auth.why}. Evidence images are published only for a run that is authorised to post the review itself; the findings and their local file paths remain in the terminal output and the saved report.`
+    );
+    return;
+  }
+  if (effectiveHost) {
+    try {
+      setGhHost(effectiveHost);
+    } catch (err) {
+      refuse(
+        `${err instanceof Error ? err.message : String(err)} (from ${args.host !== void 0 ? "--host" : "the GH_HOST environment variable"})`
+      );
+      return;
+    }
+  }
+  let findings;
+  const fileList = [...args.files ?? []];
+  if (args.findings) {
+    try {
+      const artifact = JSON.parse(readFileSync15(resolve10(args.findings), "utf8"));
+      findings = validateFindings(
+        Array.isArray(artifact) ? artifact : artifact.findings
+      );
+    } catch (err) {
+      refuse(
+        `cannot use the findings artifact at ${JSON.stringify(args.findings)}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return;
+    }
+    for (const f of findings) {
+      for (const a of f.assetFiles ?? []) fileList.push(a);
+    }
+  }
+  const unique = [...new Set(fileList)];
+  if (unique.length === 0) {
+    if (args.findings) {
+      writeStderrLine(
+        "publish-assets: no finding carries assetFiles \u2014 nothing to publish."
+      );
+      writeStdoutLine(JSON.stringify({ published: false, count: 0 }));
+      return;
+    }
+    refuse("no files to publish.");
+    return;
+  }
+  const stats = [];
+  for (const file of unique) {
+    const abs = resolve10(file);
+    try {
+      const st = statSync5(abs);
+      if (!st.isFile()) throw new Error("not a regular file");
+      stats.push({ file, abs, basename: basename5(abs), bytes: st.size });
+    } catch (err) {
+      refuse(
+        `cannot read ${JSON.stringify(file)}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return;
+    }
+  }
+  const batch = validateAssetBatch(stats);
+  if (!batch.ok) {
+    refuse(batch.reason);
+    return;
+  }
+  const prepared = [];
+  for (const st of stats) {
+    let content;
+    try {
+      content = readFileSync15(st.abs);
+    } catch (err) {
+      refuse(
+        `cannot read ${JSON.stringify(st.file)}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return;
+    }
+    const sha256 = createHash2("sha256").update(content).digest("hex");
+    prepared.push({
+      file: st.file,
+      bytes: st.bytes,
+      sha256,
+      remotePath: remoteAssetPath(args.pr, st.basename, sha256),
+      contentBase64: content.toString("base64")
+    });
+  }
+  const branch = assetsBranch(args.pr);
+  ensureBranch(repo, branch);
+  for (const p of prepared) {
+    putContent(repo, branch, p.remotePath, p.contentBase64, args.pr);
+  }
+  const headSha = gh(
+    "api",
+    `repos/${repo}/git/ref/heads/${branch}`,
+    "--jq",
+    ".object.sha"
+  ).trim();
+  const published = prepared.map((p) => ({
+    file: p.file,
+    remotePath: p.remotePath,
+    url: rawAssetUrl({
+      host: effectiveHost,
+      repo,
+      commitSha: headSha,
+      remotePath: p.remotePath
+    }),
+    bytes: p.bytes,
+    sha256: p.sha256
+  }));
+  const manifest = {
+    repo,
+    branch,
+    commitSha: headSha,
+    pr: args.pr,
+    published
+  };
+  const outPath = resolve10(args.out);
+  mkdirSync14(dirname11(outPath), { recursive: true });
+  writeFileSync14(outPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  if (findings && !args.findingsOut) {
+    writeStderrLine(
+      "publish-assets: --findings given without --findings-out \u2014 the URLs are in the manifest only; the artifact keeps local paths."
+    );
+  }
+  if (findings && args.findingsOut) {
+    const urlByFile = new Map(published.map((p) => [p.file, p.url]));
+    const updated = findings.map((f) => {
+      const urls = (f.assetFiles ?? []).map((a) => urlByFile.get(a)).filter((u) => u !== void 0);
+      return urls.length > 0 ? { ...f, assets: urls } : f;
+    });
+    const report = buildReport(updated);
+    const fOut = resolve10(args.findingsOut);
+    mkdirSync14(dirname11(fOut), { recursive: true });
+    writeFileSync14(fOut, `${JSON.stringify(report, null, 2)}
+`, "utf8");
+  }
+  writeStderrLine(
+    `publish-assets: ${published.length} file(s) \u2192 ${repo}@${branch} (commit ${headSha.slice(0, 9)})`
+  );
+  writeStdoutLine(JSON.stringify({ published: true, count: published.length }));
+}
+__name(runPublishAssets, "runPublishAssets");
+var publishAssetsCommand = {
+  command: "publish-assets",
+  describe: "Publish review evidence images to the user-designated assets repository (QWEN_REVIEW_ASSETS_REPO) and emit commit-pinned URLs \u2014 gated on the same authorisation as submit",
+  builder: /* @__PURE__ */ __name((yargs) => yargs.option("pr", {
+    type: "number",
+    demandOption: true,
+    describe: "The pull request this evidence belongs to"
+  }).option("reviewed-repo", {
+    type: "string",
+    describe: "The owner/repo the reviewed PR lives in \u2014 strengthens the authorisation binding for URL-shaped review arguments; omit to bind by PR number alone"
+  }).option("files", {
+    type: "string",
+    array: true,
+    describe: "Evidence image files to publish"
+  }).option("findings", {
+    type: "string",
+    describe: "Findings artifact whose per-finding assetFiles should be published"
+  }).option("findings-out", {
+    type: "string",
+    implies: "findings",
+    describe: "Where to write the findings artifact with published URLs woven into each finding (requires --findings)"
+  }).option("out", {
+    type: "string",
+    demandOption: true,
+    describe: "Where to write the publish manifest"
+  }).option("host", {
+    type: "string",
+    describe: "GitHub Enterprise host (defaults to github.com)"
+  }).option("user-authorized", {
+    type: "boolean",
+    default: false,
+    describe: "Pass ONLY when the user asked, in a message they typed this session, for this review to be published"
+  }).option("skill-args", {
+    type: "string",
+    describe: "Test seam: path to the recorded review arguments (ignored when a session id is present)"
+  }), "builder"),
+  handler: /* @__PURE__ */ __name((argv) => {
+    runPublishAssets({
+      pr: argv["pr"],
+      reviewedRepo: argv["reviewed-repo"],
+      files: argv["files"],
+      findings: argv["findings"],
+      findingsOut: argv["findings-out"],
+      out: argv["out"],
+      host: argv["host"],
+      userAuthorized: Boolean(argv["user-authorized"]),
+      skillArgs: argv["skill-args"]
+    });
+  }, "handler")
+};
+
+// packages/cli/src/commands/review/resolve-anchors.ts
+init_esbuild_shims();
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync15, mkdirSync as mkdirSync15 } from "node:fs";
+import { dirname as dirname12, resolve as resolve11 } from "node:path";
+
+// packages/cli/src/commands/review/lib/anchors.ts
+init_esbuild_shims();
+function collectNewSideLines(diffText, file) {
+  const lines2 = diffText.split("\n");
+  const out = [];
+  for (const hunk of file.hunks) {
+    if (hunk.newCount === 0) continue;
+    let newCursor = hunk.newStart;
+    for (let n = hunk.diffStart + 1; n <= hunk.diffEnd; n++) {
+      const raw = lines2[n - 1];
+      if (raw === void 0) break;
+      if (raw.startsWith("+")) {
+        out.push({ newLine: newCursor, text: raw.slice(1), added: true });
+        newCursor++;
+      } else if (raw.startsWith("-")) {
+      } else if (raw.startsWith(" ") || raw === "") {
+        out.push({
+          newLine: newCursor,
+          text: raw.startsWith(" ") ? raw.slice(1) : "",
+          added: false
+        });
+        newCursor++;
+      }
+    }
+  }
+  return out;
+}
+__name(collectNewSideLines, "collectNewSideLines");
+function normalizeExact(s) {
+  return s.replace(/\s+$/, "");
+}
+__name(normalizeExact, "normalizeExact");
+function normalizeLoose(s) {
+  return s.trim();
+}
+__name(normalizeLoose, "normalizeLoose");
+function anchorVariants(anchor) {
+  const lines2 = anchor.replace(/\r\n/g, "\n").split("\n");
+  while (lines2.length > 0 && lines2[0].trim() === "") lines2.shift();
+  while (lines2.length > 0 && lines2[lines2.length - 1].trim() === "") lines2.pop();
+  if (lines2.length === 0) return [];
+  const variants = [lines2];
+  const meaningful = lines2.filter((l) => l.trim() !== "");
+  if (meaningful.length > 0 && meaningful.every((l) => /^\+/.test(l))) {
+    variants.push(lines2.map((l) => l.startsWith("+") ? l.slice(1) : l));
+  }
+  const NO_NEWLINE = /^\$/;
+  const marked = lines2.filter((l) => l !== "" && !NO_NEWLINE.test(l));
+  if (marked.length > 0 && marked.every((l) => /^[+\- ]/.test(l)) && marked.some((l) => l.startsWith("+"))) {
+    variants.push(
+      lines2.filter((l) => !l.startsWith("-") && !NO_NEWLINE.test(l)).map((l) => l.slice(1))
+    );
+  }
+  return variants;
+}
+__name(anchorVariants, "anchorVariants");
+function matchRuns(hay, needle, norm) {
+  const starts = [];
+  if (needle.length === 0 || hay.length < needle.length) return starts;
+  const normNeedle = needle.map(norm);
+  for (let i = 0; i + normNeedle.length <= hay.length; i++) {
+    let ok = true;
+    for (let j = 0; j < normNeedle.length; j++) {
+      const cell = hay[i + j];
+      if (norm(cell.text) !== normNeedle[j]) {
+        ok = false;
+        break;
+      }
+      if (j > 0 && cell.newLine !== hay[i + j - 1].newLine + 1) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) starts.push(i);
+  }
+  return starts;
+}
+__name(matchRuns, "matchRuns");
+function candidatesFor(hay, needle, norm) {
+  return matchRuns(hay, needle, norm).map((i) => {
+    const run4 = hay.slice(i, i + needle.length);
+    return {
+      startLine: run4[0].newLine,
+      line: run4[run4.length - 1].newLine,
+      added: run4.some((l) => l.added)
+    };
+  });
+}
+__name(candidatesFor, "candidatesFor");
+function pick(cands, claimedLine) {
+  if (cands.length === 1) return cands[0];
+  if (claimedLine !== void 0) {
+    const dist = /* @__PURE__ */ __name((c) => Math.abs(c.startLine - claimedLine), "dist");
+    let best = Infinity;
+    for (const c of cands) best = Math.min(best, dist(c));
+    const nearest = cands.filter((c) => dist(c) === best);
+    return nearest.length === 1 ? nearest[0] : null;
+  }
+  const added = cands.filter((c) => c.added);
+  return added.length === 1 ? added[0] : null;
+}
+__name(pick, "pick");
+function resolveAnchor(newSideLines, anchor, claimedLine) {
+  const variants = anchorVariants(anchor);
+  if (variants.length === 0) {
+    return { status: "unmatched", reason: "anchor is empty" };
+  }
+  for (const [vi, needle] of variants.entries()) {
+    const norms = vi === 0 ? [
       [true, normalizeExact],
       [false, normalizeLoose]
     ] : [[true, normalizeExact]];
@@ -10688,7 +11425,7 @@ __name(validateRequests, "validateRequests");
 function runResolveAnchors(args) {
   let diffText;
   try {
-    diffText = readFileSync14(args.diff, "utf8");
+    diffText = readFileSync16(args.diff, "utf8");
   } catch (err) {
     throw new Error(
       `Cannot read diff file ${args.diff}: ${err.message}`
@@ -10696,7 +11433,7 @@ function runResolveAnchors(args) {
   }
   let rawText;
   try {
-    rawText = readFileSync14(args.input, "utf8");
+    rawText = readFileSync16(args.input, "utf8");
   } catch (err) {
     throw new Error(
       `Cannot read findings file ${args.input}: ${err.message}`
@@ -10727,8 +11464,8 @@ function runResolveAnchors(args) {
       loose: resolved.filter((r) => r.tier?.startsWith("loose")).length
     }
   };
-  mkdirSync13(dirname11(resolve10(args.out)), { recursive: true });
-  writeFileSync14(args.out, JSON.stringify(report, null, 2), "utf8");
+  mkdirSync15(dirname12(resolve11(args.out)), { recursive: true });
+  writeFileSync15(args.out, JSON.stringify(report, null, 2), "utf8");
   writeStdoutLine(`Wrote resolved anchors to ${args.out}`);
   const s = report.stats;
   writeStderrLine(
@@ -10775,8 +11512,8 @@ var resolveAnchorsCommand = {
 
 // packages/cli/src/commands/review/check-coverage.ts
 init_esbuild_shims();
-import { writeFileSync as writeFileSync15, mkdirSync as mkdirSync14 } from "node:fs";
-import { dirname as dirname12, resolve as resolve11 } from "node:path";
+import { writeFileSync as writeFileSync16, mkdirSync as mkdirSync16 } from "node:fs";
+import { dirname as dirname13, resolve as resolve12 } from "node:path";
 function runCheckCoverage(args) {
   let report;
   try {
@@ -10792,8 +11529,8 @@ This is an environment problem, not a finding about the agents. Coverage cannot
     }
     throw err;
   }
-  mkdirSync14(dirname12(resolve11(args.out)), { recursive: true });
-  writeFileSync15(args.out, JSON.stringify(report, null, 2));
+  mkdirSync16(dirname13(resolve12(args.out)), { recursive: true });
+  writeFileSync16(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;
   const worked = report.agents - report.blindAgents.length - report.idleAgents.length;
@@ -10886,9 +11623,9 @@ var checkCoverageCommand = {
 
 // packages/cli/src/commands/review/agent-prompt.ts
 init_esbuild_shims();
-import { createHash as createHash2 } from "node:crypto";
-import { readFileSync as readFileSync15 } from "node:fs";
-import { dirname as dirname13, join as join11, resolve as resolve12 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import { readFileSync as readFileSync17 } from "node:fs";
+import { dirname as dirname14, join as join12, resolve as resolve13 } from "node:path";
 
 // packages/cli/src/commands/review/lib/path-rules.ts
 init_esbuild_shims();
@@ -10918,14 +11655,85 @@ var GITHUB_ACTIONS = {
 
 **Favour precision over recall here.** A false alarm on a workflow costs more reviewer trust than a missed minor nit, because a YAML finding is the easiest kind for an author to dismiss. Every finding needs the concrete trigger and the concrete outcome, like any other.`
 };
-var PATH_RULES = [GITHUB_ACTIONS];
+var JAVA = {
+  title: "Java / JVM performance",
+  matches: /* @__PURE__ */ __name((p) => /\.java$/i.test(p), "matches"),
+  checklist: `A Java change's most expensive regressions are decided by the JVM, not by anything a reader can see in the source: HotSpot chooses what to inline, what to scalar-replace, and what to compile at all \u2014 and a one-line change can flip each of those on a hot path. The general performance lens (N+1, repeated work, data structures) sees none of it.
+
+**You are reviewing this diff, not auditing this file.** A JVM-cost weakness the code already had, on a line this change does not touch, is out of scope \u2014 the same rule as everywhere else. What is in scope: a line this diff **adds or changes**, and a cheap path this diff **makes hot** (a new caller in a request loop, a call moved inside a loop). Test sources (\`src/test/**\`), \`package-info\`/\`module-info\`, and generated sources are out of scope for the hot-path items \u2014 nothing there is hot.
+
+**Correctness traps dressed as concurrency or performance code (Critical):**
+
+- **A \`SimpleDateFormat\` shared across threads.** It is not thread-safe: concurrent \`parse\`/\`format\` corrupts its calendar state and returns silently wrong values or throws. If the diff adds a shared (static or instance field) \`SimpleDateFormat\`, or makes an existing one reachable from more than one thread, that is wrong, not slow. The fix is \`java.time.format.DateTimeFormatter\` (immutable) or a \`ThreadLocal\`.
+- **A compound action on \`ConcurrentHashMap\` built from two calls.** \`get\`-then-\`put\`, \`containsKey\`-then-\`put\`, check-then-act of any shape: the map's thread safety covers each call, not the pair, and the race loses an update or runs the guarded work twice. Say what the race corrupts \u2014 that is the finding. Fix with \`putIfAbsent\`, \`computeIfAbsent\`, or \`merge\`.
+- **Double-checked locking without \`volatile\` on the field.** The reading thread can observe a partially constructed object. If the diff adds or touches the idiom, the field must be \`volatile\` (or replaced with the holder idiom).
+
+**JVM-cost defects provable from the source (Suggestion \u2014 a cost, not a wrongness):**
+
+- **A regex compiled per call.** \`Pattern.compile(...)\` in a method body or loop, and the \`String\` conveniences that hide it \u2014 \`matches\`, \`replaceAll\`, \`replaceFirst\`, and \`split\` with a real regex (a one- or two-character \`split\` argument takes a fast path only when it is not a regex construct \u2014 \`split(".")\` does not, since \`.\` is a metacharacter; the escaped two-character form \`split("\\\\.")\` does) \u2014 recompile the pattern on every invocation. On a per-request or per-record path that is real CPU. Fix: \`private static final Pattern\`.
+- **\`+=\` on a \`String\` inside a loop.** Each iteration rebuilds and copies the whole accumulated prefix; the loop is O(n\xB2) in the final length. Fix: one \`StringBuilder\` outside the loop.
+- **Boxing on a hot path.** A \`Long\`/\`Integer\` loop accumulator, a \`Map<Long, \u2026>\` over dense \`int\` keys, \`.boxed()\` in a counted stream: every box past the small-integer cache is an allocation plus a pointer chase per iteration. Fix: primitives, or the primitive streams/collections.
+- **A capturing lambda or method reference inside a hot loop.** A non-capturing lambda is a singleton; one that closes over a local allocates per iteration. If the diff moves a capturing lambda into a loop, hoist it or restructure it to capture nothing.
+- **A log message built whether or not it is logged.** \`log.debug("result: " + value)\` pays the concatenation with the level off, and even \`log.debug("{}", expensive())\` still pays \`expensive()\`. Fix: parameterized messages, and guard expensive arguments with \`isDebugEnabled()\` or a supplier-based logging API.
+- **A collection sized after the fact.** A \`HashMap\`/\`ArrayList\` the code then fills with a known N pays repeated rehash/grow-copy chains; presize it (a \`HashMap\` needs \`N/0.75 + 1\` to avoid rehashing at all \u2014 \`HashMap.newHashMap(n)\`, JDK 19+, does that arithmetic for you).
+- **Legacy synchronized types in new code.** \`Vector\`, \`Hashtable\`, \`StringBuffer\` put a monitor on every call; the unsynchronized equivalents are the default for a reason.
+- **An exception used as control flow.** Validating by catching \`NumberFormatException\`, looping until \`EOFException\`: \`fillInStackTrace\` costs more than the work being guarded. Validate instead.
+- **Reflection rediscovered per call.** \`getMethod\`/\`getField\` on every invocation of a hot path; cache the \`Method\`/\`Field\` \u2014 or a \`MethodHandle\` \u2014 once.
+
+**JIT inlining \u2014 the regression no dimension can see, and you cannot prove from source:**
+
+HotSpot's C2 compiler gates inlining on the **bytecode size of the callee** among other criteria. These are the size caps in its normal policy (a project's own \`-XX:\` flags, or a different JVM, change them \u2014 check before citing):
+
+| callee bytecode size | C2 normal-policy size cap |
+| --- | --- |
+| \u2264 6 (\`MaxTrivialSize\`) | under the trivial cap \u2014 size alone does not block it |
+| \u2264 35 (\`MaxInlineSize\`) | under the normal cap \u2014 size alone does not block it |
+| \u2264 325 (\`FreqInlineSize\`) | under the hot cap \u2014 size blocks it unless the call site is hot |
+| > 325 | over the hot cap \u2014 size blocks it at every call site |
+| > 8000 (\`HugeMethodLimit\`, a develop flag gated by the product \`DontCompileHugeMethods\`) | over the huge-method limit \u2014 size blocks even JIT compilation |
+
+A size cap is a gate, not an outcome: passing one is necessary but not sufficient. Independent of size, C2 also declines a call site that was **never executed**, has **low call site frequency**, exceeds the inlining **depth or recursion limits**, or hits the **node-count** cutoff \u2014 so a method under a cap can still be left un-inlined, and a static size measurement proves only that a threshold was crossed, not that the method *was* inlined before and *is not* now.
+
+Two more ways a diff can flip it: an already-compiled callee whose **native** size passes \`InlineSmallCode\` (x86_64 default: 2500 on JDK 17+, 2000 on JDK 8\u201316; 1000 only with \`-XX:-TieredCompilation\`) stops being inlined to protect the code cache, and a call site that gains a **third** receiver implementation goes megamorphic \u2014 vtable dispatch, and no inlining **unless one receiver still dominates the profile** (\`TypeProfileMajorReceiverPercent\`, 90% by default), in which case C2 inlines that receiver behind a guard with an uncommon trap for the rest. So the diff-shapes that matter: a small method on a hot path the change **grows** (added validation, logging, a branch), a new layer in a hot call chain, a new implementation registered for an interface invoked in a hot loop. A cold method over 325 bytes is **not** a finding \u2014 inlining only matters where the call is hot.
+
+**Measure it; do not estimate bytecode from source.** Two tiers, in order of cost:
+
+1. **Static \u2014 available when the class compiles, which for a leaf class is always and for a connected one needs its dependencies.** Allocate a private scratch dir first \u2014 \`SCRATCH=$(mktemp -d)\`, never a fixed path like \`/tmp/scratch\`: other agents are compiling concurrently, and two of them writing different revisions of the same class into one directory read each other's \`.class\` files and measure the wrong bytecode (on Windows, \`mkdir %TEMP%\\review-%RANDOM%\` gives the same uniqueness). Then \`javac -proc:none -nowarn -d "$SCRATCH" X.java\` \u2014 \`-proc:none\` is not optional: annotation processors on the classpath (Lombok, Dagger, one the PR itself added) run at compile time with your privileges, so a \`javac\` without it is itself an untrusted-code execution. It is also a fidelity flag: on a project whose processor contributes code to the measured class (Lombok's generated members, Dagger's injected fields), the compiled class is missing those members and \`javap\` reports a size that is simply wrong \u2014 if the project runs a processor that touches this class, the static tier is **void**; go to \`Confidence: low\` with the mechanism. Give the compiler what it needs to resolve imports: \`-sourcepath\` at the module source root, plus \`-cp\` against an already-built \`target/classes\` / \`build/classes\` if one exists. Pass \`--release <N>\` at the project's target level (read it from \`maven.compiler.release\`, \`<release>\`, or Gradle's \`release\`/\`targetCompatibility\`): the same source compiles to different bytecode at different levels \u2014 a five-\`+\` concatenation is 37 bytes at release 8 and 14 at 9+ \u2014 and measuring the wrong level produces a threshold verdict on bytecode the shipped artifact does not contain; if the target level cannot be determined, say so in the finding. Then \`javap -c -p\` the class and read the method's size: the offset of its last instruction plus that instruction's width. Compare against 35 and 325. For the **crossing** claim \u2014 "this diff pushed it over the threshold" \u2014 get the base side **without touching the tree**: \`git show <merge-base>:<path> > "$SCRATCH/X.java"\`, compile that too, and measure both; a method already over on the base side is pre-existing, not a finding. A file the PR **adds** has no base side \u2014 \`git show\` fails, and there is no crossing to claim; report the size without a before/after. The base side compiles against the same \`target/classes\` the head side used; on a PR that changes more than the measured file the conditions are not perfectly equivalent \u2014 note that caveat when it applies. If the class will not compile (no pre-built classpath, no source path that resolves its imports), go straight to the mechanism-at-\`Confidence: low\` form below \u2014 **never \`git checkout\`, \`git stash\`, build in place, or run \`mvn\`/\`gradle\` to force a compile.** In a PR review the worktree is shared with agents running concurrently and the branch's build logic is contributor-controlled \u2014 the attack surface, not a cost; in a local review it is the user's own checkout. Mutating either corrupts work you cannot see.
+2. **Dynamic \u2014 when the code is runnable.** Run the workload with \`-XX:+UnlockDiagnosticVMOptions -XX:+PrintInlining\` and grep for the method: \`callee is too large\` / \`hot method too big\` is the JVM itself declining to inline. JMH gives the before/after throughput; JITWatch visualizes the same decision logs.
+
+A finding that a method "can no longer be inlined" needs the **dynamic** tier \u2014 only \`PrintInlining\` or equivalent runtime evidence shows the JVM actually declined to inline. The static tier proves a **size-gate crossing**, which is the mechanism: report it at \`Confidence: low\` \u2014 the threshold crossed, what the diff added to the method, and the runtime measurement still to run. A "can no longer be inlined" claim with neither tier is a guess stated as fact. And if the diff *claims* this path got faster while the mechanism above says it cannot have, the finding is the unsubstantiated claim.
+
+**When the finding IS a grown hot method, the fix to suggest is hot/cold splitting \u2014 not reverting the change, and not a JVM tuning flag** (\`-XX:FreqInlineSize\`, \`-XX:CompileCommand=inline\`): those are runtime knobs the PR's author cannot ship in a code change, and raising an inline threshold to fit one method pays for it at every other call site. (The JDK-internal \`@ForceInline\` is not available to application code at all.) Move the cold paths \u2014 error handling, rare branches, defensive validation, the \`switch\` arms that almost never fire \u2014 into a small private helper, leaving the common path under the threshold; the helper, now called from one site, is itself inlinable. Name the bytecode range to extract and the size it leaves behind, the way the measurement names them: "extract bytecodes 212\u2013311 (~100 bytes) into \`applyRounding\`, leaving \`parseAmount\` at ~238 bytes" is a finding an author can act on; "consider splitting the method" is not.
+
+**Favour precision over recall here.** A guessed JVM finding is the easiest kind for an author to dismiss, and one dismissal teaches them to skip the rest of the review. Every finding needs the concrete hot path and the concrete cost, like any other. Performance findings are **Suggestions** \u2014 slow is a cost, not incorrect behaviour \u2014 **except where the cost is itself the wrongness**: unbounded allocation, quadratic work, or unbounded cache growth on attacker-reachable input is a denial-of-service hole, which the severity ladder grades Critical, not a Suggestion. Name the reachable input that triggers it; "this loop is slow" with no attacker-reachable trigger stays a Suggestion.`
+};
+var PATH_RULES = [GITHUB_ACTIONS, JAVA];
+function isOutOfScope(p) {
+  return /src\/(test|integrationTest|integTest|androidTest|testFixtures)\//i.test(
+    p
+  ) || /(?:^|\/)(?:package-info|module-info)\.java$/i.test(p) || /(?:^|\/)(?:target|build)\/(?:generated-sources|generated-test-sources|generated)\//i.test(
+    p
+  );
+}
+__name(isOutOfScope, "isOutOfScope");
+function describePaths(which) {
+  const CAP = 10;
+  const prod = which.filter((p) => !isOutOfScope(p));
+  const rest = which.filter((p) => isOutOfScope(p));
+  const ordered = [...prod, ...rest];
+  if (ordered.length <= CAP) {
+    return ordered.join(", ");
+  }
+  return `${ordered.slice(0, CAP).join(", ")}, \u2026and ${ordered.length - CAP} more`;
+}
+__name(describePaths, "describePaths");
 function pathRulesFor(paths) {
   const hit = PATH_RULES.filter((r) => paths.some((p) => r.matches(p)));
   if (hit.length === 0) return "";
   const parts = ["## Rules for the files in front of you", ""];
   for (const r of hit) {
     const which = paths.filter((p) => r.matches(p));
-    parts.push(`### ${r.title} \u2014 ${which.join(", ")}`, "", r.checklist, "");
+    parts.push(`### ${r.title} \u2014 ${describePaths(which)}`, "", r.checklist, "");
   }
   return parts.join("\n").trimEnd();
 }
@@ -10990,32 +11798,32 @@ function chunkFrom(report, id) {
     throw new Error("agent-prompt: the plan has no `chunks[]`.");
   }
   const chunks = report.chunks;
-  const chunk = chunks.find((c) => c?.id === id);
-  if (!chunk) {
+  const chunk2 = chunks.find((c) => c?.id === id);
+  if (!chunk2) {
     throw new Error(
       `agent-prompt: the plan has no chunk ${id} (it has ${chunks.length}: ${chunks.map((c) => c?.id).join(", ")}).`
     );
   }
-  if (!Number.isSafeInteger(chunk.startLine) || !Number.isSafeInteger(chunk.endLine) || chunk.startLine < 1 || chunk.endLine < chunk.startLine) {
+  if (!Number.isSafeInteger(chunk2.startLine) || !Number.isSafeInteger(chunk2.endLine) || chunk2.startLine < 1 || chunk2.endLine < chunk2.startLine) {
     throw new Error(
-      `agent-prompt: chunk ${id} has no usable line range (startLine=${chunk.startLine}, endLine=${chunk.endLine}).`
+      `agent-prompt: chunk ${id} has no usable line range (startLine=${chunk2.startLine}, endLine=${chunk2.endLine}).`
     );
   }
-  return { diffPath, chunk, total: chunks.length };
+  return { diffPath, chunk: chunk2, total: chunks.length };
 }
 __name(chunkFrom, "chunkFrom");
 function buildChunkAgentPrompt(report, id, rules) {
-  const { chunk, total } = chunkFrom(report, id);
-  const files = (Array.isArray(chunk.files) ? chunk.files : []).filter(
+  const { chunk: chunk2, total } = chunkFrom(report, id);
+  const files = (Array.isArray(chunk2.files) ? chunk2.files : []).filter(
     (f) => !!f && typeof f.path === "string" && f.path.length > 0
   ).map(
     (f) => `- ${inertPath(f.path)} (new-side lines ${f.newStart}-${f.newEnd})`
   ).join("\n");
-  const unreachable = chunk.maxLineChars > READ_FILE_CHAR_CAP;
+  const unreachable = chunk2.maxLineChars > READ_FILE_CHAR_CAP;
   const parts = [
-    `You are reviewing chunk ${chunk.id} of ${total} of a code diff.`,
+    `You are reviewing chunk ${chunk2.id} of ${total} of a code diff.`,
     "",
-    `Your territory: lines ${chunk.startLine}-${chunk.endLine} of the diff (${chunk.lines} lines, ${chunk.chars} characters). The surrounding chunks belong to other agents \u2014 do not review them.`,
+    `Your territory: lines ${chunk2.startLine}-${chunk2.endLine} of the diff (${chunk2.lines} lines, ${chunk2.chars} characters). The surrounding chunks belong to other agents \u2014 do not review them.`,
     "",
     "It covers these source files:",
     files || "- (none recorded)",
@@ -11025,11 +11833,11 @@ function buildChunkAgentPrompt(report, id, rules) {
   if (unreachable) {
     parts.push(
       "",
-      `**This chunk contains a single line of ${chunk.maxLineChars} characters** \u2014 longer than one read returns, and paging cannot reach its tail (every page starts at a line boundary). Do not claim to have reviewed it. Return exactly:`,
+      `**This chunk contains a single line of ${chunk2.maxLineChars} characters** \u2014 longer than one read returns, and paging cannot reach its tail (every page starts at a line boundary). Do not claim to have reviewed it. Return exactly:`,
       "",
-      `    Uncoverable: chunk ${chunk.id} \u2014 line exceeds the read limit`
+      `    Uncoverable: chunk ${chunk2.id} \u2014 line exceeds the read limit`
     );
-  } else if (chunk.oversized) {
+  } else if (chunk2.oversized) {
     parts.push(
       "",
       "**This chunk is oversized** \u2014 it is a single hunk with no safe place to cut, and it may exceed one read. Expect to page."
@@ -11049,7 +11857,7 @@ function buildChunkAgentPrompt(report, id, rules) {
     "",
     EXCLUSIONS
   );
-  const chunkPaths = (Array.isArray(chunk.files) ? chunk.files : []).map((f) => f?.path).filter((p) => typeof p === "string");
+  const chunkPaths = (Array.isArray(chunk2.files) ? chunk2.files : []).map((f) => f?.path).filter((p) => typeof p === "string");
   const pathRules = pathRulesFor(chunkPaths);
   if (pathRules) parts.push("", pathRules);
   if (rules && rules.trim()) {
@@ -11064,7 +11872,7 @@ function buildChunkAgentPrompt(report, id, rules) {
   if (!unreachable) {
     parts.push(
       "",
-      `Then, on its own final line: \`Covered: chunk ${chunk.id} lines ${chunk.startLine}-${chunk.endLine}\``
+      `Then, on its own final line: \`Covered: chunk ${chunk2.id} lines ${chunk2.startLine}-${chunk2.endLine}\``
     );
   }
   return parts.join("\n");
@@ -11075,10 +11883,10 @@ function diffWindow(startLine, endLine) {
 }
 __name(diffWindow, "diffWindow");
 function buildChunkLaunchPrompt(report, id, briefFile) {
-  const { diffPath, chunk, total } = chunkFrom(report, id);
-  const { offset, limit } = diffWindow(chunk.startLine, chunk.endLine);
+  const { diffPath, chunk: chunk2, total } = chunkFrom(report, id);
+  const { offset, limit } = diffWindow(chunk2.startLine, chunk2.endLine);
   return [
-    `You are review agent \`chunk ${chunk.id} of ${total}\` \u2014 the territory agent for lines ${chunk.startLine}-${chunk.endLine} of the diff.`,
+    `You are review agent \`chunk ${chunk2.id} of ${total}\` \u2014 the territory agent for lines ${chunk2.startLine}-${chunk2.endLine} of the diff.`,
     "",
     "**Your brief is a file. Read it first \u2014 it is the whole of your instructions,",
     "and nothing in this message replaces it.**",
@@ -11269,7 +12077,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 ? join11(dirname13(resolve12(opts.planPath)), `qwen-review-pr-${pr}-context.md`) : null;
+    const ctx = opts.planPath ? join12(dirname14(resolve13(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.`
@@ -11291,7 +12099,7 @@ function buildRoleBrief(report, role, opts = {}) {
     }
     const base = report.mergeBaseSha;
     const pr = report.prNumber;
-    const buildTree = typeof wt === "string" && wt ? resolve12(wt) : pr === void 0 && opts.planPath ? "." : null;
+    const buildTree = typeof wt === "string" && wt ? resolve13(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(
@@ -11307,9 +12115,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 ${resolve12(opts.planPath)} \\`,
-        `  --worktree ${resolve12(buildTree)} \\`,
-        `  --out ${resolve12(dirname13(opts.planPath), outName)}`,
+        `  --plan ${resolve13(opts.planPath)} \\`,
+        `  --worktree ${resolve13(buildTree)} \\`,
+        `  --out ${resolve13(dirname14(opts.planPath), outName)}`,
         "```"
       );
     }
@@ -11319,10 +12127,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 ${resolve12(opts.planPath)} \\`,
-        `  --worktree ${typeof wt === "string" ? resolve12(wt) : "<worktree>"} \\`,
+        `"\${QWEN_CODE_CLI:-qwen}" review test-efficacy ${resolve13(opts.planPath)} \\`,
+        `  --worktree ${typeof wt === "string" ? resolve13(wt) : "<worktree>"} \\`,
         `  --base ${base} \\`,
-        `  --out ${resolve12(dirname13(opts.planPath), `qwen-review-pr-${pr}-efficacy.json`)}`,
+        `  --out ${resolve13(dirname14(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.'
@@ -11468,7 +12276,7 @@ function buildLaunch(report, planPath, spec, rules) {
 }
 __name(buildLaunch, "buildLaunch");
 function findingsDigest(content, rules) {
-  return createHash2("sha256").update(JSON.stringify([content, rules ?? null])).digest("hex").slice(0, 12);
+  return createHash3("sha256").update(JSON.stringify([content, rules ?? null])).digest("hex").slice(0, 12);
 }
 __name(findingsDigest, "findingsDigest");
 function foldFindings(role, content, prompt) {
@@ -11674,7 +12482,7 @@ function runAgentPrompt(args) {
   }
   let report;
   try {
-    report = JSON.parse(readFileSync15(args.plan, "utf8"));
+    report = JSON.parse(readFileSync17(args.plan, "utf8"));
   } catch (err) {
     throw new Error(
       `agent-prompt: cannot read the plan ${args.plan}: ${err.message}`
@@ -11683,7 +12491,7 @@ function runAgentPrompt(args) {
   let rules;
   if (args.rules) {
     try {
-      rules = readFileSync15(args.rules, "utf8");
+      rules = readFileSync17(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.`
@@ -11698,7 +12506,7 @@ function runAgentPrompt(args) {
   if (hasFindings && args.role) {
     const role = args.role;
     try {
-      findingsContent = readFileSync15(args.findings, "utf8");
+      findingsContent = readFileSync17(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).`
@@ -11807,18 +12615,18 @@ var agentPromptCommand = {
 init_esbuild_shims();
 import { spawnSync as spawnSync2 } from "node:child_process";
 import {
-  existsSync as existsSync5,
-  readFileSync as readFileSync17,
-  rmSync as rmSync4,
+  existsSync as existsSync7,
+  readFileSync as readFileSync19,
+  rmSync as rmSync5,
   statfsSync,
-  writeFileSync as writeFileSync16
+  writeFileSync as writeFileSync17
 } from "node:fs";
-import { join as join13, resolve as resolve13 } from "node:path";
+import { join as join14, resolve as resolve14 } from "node:path";
 
 // packages/cli/src/commands/review/lib/workspaces.ts
 init_esbuild_shims();
-import { existsSync as existsSync4, readFileSync as readFileSync16, readdirSync as readdirSync4 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync18, readdirSync as readdirSync4 } from "node:fs";
+import { join as join13 } from "node:path";
 function isWorkspaceMember(filePath, workspaceGlobs) {
   return workspaceDirFor(filePath, workspaceGlobs) !== null;
 }
@@ -11856,7 +12664,7 @@ __name(hasUnmodeledWorkspaceGlob, "hasUnmodeledWorkspaceGlob");
 function readWorkspaceGlobs(root) {
   try {
     const pkg = JSON.parse(
-      readFileSync16(join12(root, "package.json"), "utf8")
+      readFileSync18(join13(root, "package.json"), "utf8")
     );
     const ws = pkg.workspaces;
     const globs = Array.isArray(ws) ? ws : Array.isArray(ws?.packages) ? ws.packages : [];
@@ -11869,7 +12677,7 @@ __name(readWorkspaceGlobs, "readWorkspaceGlobs");
 function readRootPackage(root) {
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync16(join12(root, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync18(join13(root, "package.json"), "utf8"));
   } catch {
     return null;
   }
@@ -11893,7 +12701,7 @@ function readWorkspacePackages(root) {
       const base = g.slice(0, -2);
       let entries;
       try {
-        entries = readdirSync4(join12(root, base), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+        entries = readdirSync4(join13(root, base), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
       } catch {
         continue;
       }
@@ -11905,11 +12713,11 @@ function readWorkspacePackages(root) {
   const pkgs = [];
   for (const dir of dirs) {
     if (workspaceDirFor(`${dir}/package.json`, globs) !== dir) continue;
-    const manifest = join12(root, dir, "package.json");
-    if (!existsSync4(manifest)) continue;
+    const manifest = join13(root, dir, "package.json");
+    if (!existsSync6(manifest)) continue;
     let pkg;
     try {
-      pkg = JSON.parse(readFileSync16(manifest, "utf8"));
+      pkg = JSON.parse(readFileSync18(manifest, "utf8"));
     } catch {
       continue;
     }
@@ -12082,7 +12890,7 @@ __name(unresolvedWorkspaceDeps, "unresolvedWorkspaceDeps");
 function changedFilesFrom(planPath) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync17(planPath, "utf8"));
+    parsed = JSON.parse(readFileSync19(planPath, "utf8"));
   } catch (err) {
     throw new Error(
       `build-test: cannot read the plan ${planPath}: ${err.message}`
@@ -12099,7 +12907,7 @@ function changedFilesFrom(planPath) {
 }
 __name(changedFilesFrom, "changedFilesFrom");
 function runBuildTest(args) {
-  const root = resolve13(args.worktree);
+  const root = resolve14(args.worktree);
   const perCommandMs = args.timeout * 1e3;
   const exec = args.exec ?? run;
   const changed = changedFilesFrom(args.plan);
@@ -12165,15 +12973,15 @@ function runBuildTest(args) {
     timedOut: [],
     note: ""
   };
-  const npmLock = existsSync5(join13(root, "package-lock.json"));
-  const installComplete = /* @__PURE__ */ __name(() => existsSync5(join13(root, "node_modules", ".package-lock.json")), "installComplete");
-  if (args.install && !npmLock && !existsSync5(join13(root, "node_modules"))) {
+  const npmLock = existsSync7(join14(root, "package-lock.json"));
+  const installComplete = /* @__PURE__ */ __name(() => existsSync7(join14(root, "node_modules", ".package-lock.json")), "installComplete");
+  if (args.install && !npmLock && !existsSync7(join14(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]) => existsSync5(join13(root, f)));
+    ].find(([f]) => existsSync7(join14(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."
     );
@@ -12191,7 +12999,7 @@ function runBuildTest(args) {
     if (install.timedOut) results.timedOut.push(install.command);
     if (install.timedOut) {
       try {
-        rmSync4(join13(root, "node_modules"), {
+        rmSync5(join14(root, "node_modules"), {
           recursive: true,
           force: true,
           maxRetries: 3
@@ -12314,7 +13122,7 @@ var buildTestCommand = {
     try {
       const report = runBuildTest(args);
       if (args.out) {
-        writeFileSync16(args.out, JSON.stringify(report, null, 2));
+        writeFileSync17(args.out, JSON.stringify(report, null, 2));
       }
       writeStdoutLine(JSON.stringify(report, null, 2));
     } catch (err) {
@@ -12328,25 +13136,25 @@ var buildTestCommand = {
 init_esbuild_shims();
 import { spawnSync as spawnSync4 } from "node:child_process";
 import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync15,
-  readFileSync as readFileSync18,
-  rmSync as rmSync6,
-  statSync as statSync5,
-  writeFileSync as writeFileSync17
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync17,
+  readFileSync as readFileSync20,
+  rmSync as rmSync7,
+  statSync as statSync6,
+  writeFileSync as writeFileSync18
 } from "node:fs";
-import { dirname as dirname14, join as join14, resolve as resolve14 } from "node:path";
+import { dirname as dirname15, join as join15, resolve as resolve15 } from "node:path";
 
 // packages/cli/src/commands/review/lib/worktree.ts
 init_esbuild_shims();
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { rmSync as rmSync5 } from "node:fs";
+import { rmSync as rmSync6 } from "node:fs";
 function discardWorktree(cwd, tree) {
   const sweep = spawnSync3("git", ["worktree", "remove", "--force", tree], {
     cwd,
     encoding: "utf8"
   });
-  rmSync5(tree, { recursive: true, force: true });
+  rmSync6(tree, { recursive: true, force: true });
   return sweep;
 }
 __name(discardWorktree, "discardWorktree");
@@ -12382,7 +13190,7 @@ function runBaseTree(args) {
   }), "unavailable");
   let plan;
   try {
-    plan = JSON.parse(readFileSync18(args.plan, "utf8"));
+    plan = JSON.parse(readFileSync20(args.plan, "utf8"));
   } catch (err) {
     return unavailable(
       `cannot read the plan ${args.plan}: ${err.message}`
@@ -12399,15 +13207,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 = resolve14(args.worktree);
-  if (!existsSync6(worktree)) {
+  const worktree = resolve15(args.worktree);
+  if (!existsSync8(worktree)) {
     return unavailable(`the review worktree ${worktree} does not exist`);
   }
   const tree = baseWorktreePath(worktree);
-  const marker = /* @__PURE__ */ __name(() => join14(tree, ".qwen-review-base-ok"), "marker");
-  const failedMarker = /* @__PURE__ */ __name(() => join14(tree, ".qwen-review-base-failed"), "failedMarker");
+  const marker = /* @__PURE__ */ __name(() => join15(tree, ".qwen-review-base-ok"), "marker");
+  const failedMarker = /* @__PURE__ */ __name(() => join15(tree, ".qwen-review-base-failed"), "failedMarker");
   try {
-    if (existsSync6(tree) && readFileSync18(marker(), "utf8").trim() === baseSha && gitOut(tree, "rev-parse", "HEAD") === baseSha) {
+    if (existsSync8(tree) && readFileSync20(marker(), "utf8").trim() === baseSha && gitOut(tree, "rev-parse", "HEAD") === baseSha) {
       return {
         available: true,
         path: tree,
@@ -12419,7 +13227,7 @@ function runBaseTree(args) {
   } catch {
   }
   try {
-    if (existsSync6(tree) && readFileSync18(failedMarker(), "utf8").trim() === baseSha) {
+    if (existsSync8(tree) && readFileSync20(failedMarker(), "utf8").trim() === baseSha) {
       return {
         available: false,
         path: tree,
@@ -12432,14 +13240,14 @@ function runBaseTree(args) {
   }
   const lock = `${tree}.lock`;
   try {
-    const age = Date.now() - statSync5(lock).mtimeMs;
+    const age = Date.now() - statSync6(lock).mtimeMs;
     if (age > 30 * 60 * 1e3) {
-      rmSync6(lock, { recursive: true, force: true });
+      rmSync7(lock, { recursive: true, force: true });
     }
   } catch {
   }
   try {
-    mkdirSync15(lock);
+    mkdirSync17(lock);
   } catch (err) {
     if (err.code !== "EEXIST") {
       return unavailable(
@@ -12453,7 +13261,7 @@ function runBaseTree(args) {
   try {
     return buildBaseTree(baseSha);
   } finally {
-    rmSync6(lock, { recursive: true, force: true });
+    rmSync7(lock, { recursive: true, force: true });
   }
   function buildBaseTree(baseSha2) {
     let sweep;
@@ -12477,7 +13285,7 @@ function runBaseTree(args) {
     });
     if (!build.ok || build.toolchain !== "npm" || build.build.length === 0) {
       try {
-        writeFileSync17(failedMarker(), `${baseSha2}
+        writeFileSync18(failedMarker(), `${baseSha2}
 `);
       } catch {
       }
@@ -12490,7 +13298,7 @@ function runBaseTree(args) {
       };
     }
     try {
-      writeFileSync17(marker(), `${baseSha2}
+      writeFileSync18(marker(), `${baseSha2}
 `);
     } catch {
     }
@@ -12530,8 +13338,8 @@ var baseTreeCommand = {
     try {
       const report = runBaseTree(args);
       if (args.out) {
-        mkdirSync15(dirname14(resolve14(args.out)), { recursive: true });
-        writeFileSync17(resolve14(args.out), JSON.stringify(report, null, 2));
+        mkdirSync17(dirname15(resolve15(args.out)), { recursive: true });
+        writeFileSync18(resolve15(args.out), JSON.stringify(report, null, 2));
       }
       writeStdoutLine(JSON.stringify(report, null, 2));
       writeStderrLine(`base-tree: ${report.note}`);
@@ -12545,8 +13353,8 @@ var baseTreeCommand = {
 // packages/cli/src/commands/review/test-delta.ts
 init_esbuild_shims();
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync7, mkdirSync as mkdirSync16, readFileSync as readFileSync19, writeFileSync as writeFileSync18 } from "node:fs";
-import { dirname as dirname15, resolve as resolve15 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync18, readFileSync as readFileSync21, writeFileSync as writeFileSync19 } from "node:fs";
+import { dirname as dirname16, resolve as resolve16 } 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/;
@@ -12609,7 +13417,7 @@ var TOTAL_BUDGET_MS = 54e4;
 var DEFAULT_TIMEOUT_S = 300;
 function runTestDelta(args) {
   const exec = args.exec ?? run2;
-  const baseline = resolve15(args.baseline);
+  const baseline = resolve16(args.baseline);
   const empty = /* @__PURE__ */ __name((note) => ({
     entries: [],
     netNew: [],
@@ -12619,13 +13427,13 @@ function runTestDelta(args) {
   }), "empty");
   let report;
   try {
-    report = JSON.parse(readFileSync19(args.report, "utf8"));
+    report = JSON.parse(readFileSync21(args.report, "utf8"));
   } catch (err) {
     return empty(
       `cannot read the build-test report ${args.report}: ${err.message}`
     );
   }
-  if (!existsSync7(baseline)) {
+  if (!existsSync9(baseline)) {
     return empty(
       `the base tree ${baseline} does not exist \u2014 run \`qwen review base-tree\` first`
     );
@@ -12730,50 +13538,737 @@ function runTestDelta(args) {
     );
   }
   return {
-    entries,
-    netNew,
-    shared,
-    skippedForBudget,
-    note: parts.join(". ") || "nothing to report"
+    entries,
+    netNew,
+    shared,
+    skippedForBudget,
+    note: parts.join(". ") || "nothing to report"
+  };
+}
+__name(runTestDelta, "runTestDelta");
+var testDeltaCommand = {
+  command: "test-delta",
+  describe: "Rerun the PR side's failed test commands on the base tree and report which failing files are the PR's own (net-new) vs pre-existing (shared)",
+  builder: /* @__PURE__ */ __name((yargs) => yargs.option("report", {
+    type: "string",
+    demandOption: true,
+    describe: "Agent 7's build-test report (its failed commands and outputs)"
+  }).option("baseline", {
+    type: "string",
+    demandOption: true,
+    describe: "The BUILT base tree from `qwen review base-tree`"
+  }).option("pr-worktree", {
+    type: "string",
+    describe: "The PR worktree the report's failures were produced in \u2014 its root is stripped so both sides compare as repo-relative paths"
+  }).option("out", { type: "string", describe: "Write the JSON report here" }).option("timeout", {
+    type: "number",
+    default: 300,
+    describe: "Per-command deadline in seconds, as build-test"
+  }), "builder"),
+  handler: /* @__PURE__ */ __name((argv) => {
+    const args = argv;
+    const report = runTestDelta(args);
+    if (args.out) {
+      mkdirSync18(dirname16(resolve16(args.out)), { recursive: true });
+      writeFileSync19(resolve16(args.out), JSON.stringify(report, null, 2));
+    }
+    writeStdoutLine(JSON.stringify(report, null, 2));
+    writeStderrLine(`test-delta: ${report.note}`);
+  }, "handler")
+};
+
+// packages/cli/src/commands/review/drive.ts
+init_esbuild_shims();
+import { spawnSync as spawnSync6 } from "node:child_process";
+import {
+  mkdirSync as mkdirSync19,
+  writeFileSync as writeFileSync20,
+  readFileSync as readFileSync22,
+  existsSync as existsSync10,
+  rmSync as rmSync8,
+  statSync as statSync7
+} from "node:fs";
+import { dirname as dirname17, join as join16, resolve as resolve17 } 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) {
+  return `'${v.split("'").join(`'\\''`)}'`;
+}
+__name(shellQuote, "shellQuote");
+var CAPTURE_MAX = 2e5;
+var LOG_MAX_BYTES = 8 * 1024 * 1024;
+var POLL_MS = 250;
+function logBytes(p) {
+  try {
+    return statSync7(p).size;
+  } catch {
+    return 0;
+  }
+}
+__name(logBytes, "logBytes");
+function waitMs(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+__name(waitMs, "waitMs");
+function run3(cmd, args, input) {
+  const r = spawnSync6(cmd, args, {
+    encoding: "utf8",
+    input,
+    timeout: 3e4,
+    maxBuffer: 64 * 1024 * 1024,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return {
+    status: r.status ?? null,
+    stdout: r.stdout ?? "",
+    stderr: r.stderr ?? ""
+  };
+}
+__name(run3, "run");
+var DRIVE_SENTINEL = "__QWEN_REVIEW_DRIVE_DONE__";
+function wrapScript(script, sentinelPath, sentinel = DRIVE_SENTINEL) {
+  return `trap '__qwen_rc=$?; echo "${sentinel} rc=\${__qwen_rc}" > ${shellQuote(sentinelPath)}' EXIT
+set +e
+${script}
+`;
+}
+__name(wrapScript, "wrapScript");
+function sentinelExitCode(capture, sentinel = DRIVE_SENTINEL) {
+  const re = new RegExp(`${sentinel} rc=(\\d+)`, "g");
+  let last = null;
+  for (let m = re.exec(capture); m; m = re.exec(capture)) last = m;
+  return last ? Number(last[1]) : null;
+}
+__name(sentinelExitCode, "sentinelExitCode");
+function trimCapture(s) {
+  if (s.length <= CAPTURE_MAX) return { text: s, truncated: false };
+  return {
+    text: `... [${s.length - CAPTURE_MAX} characters omitted from the head] ...
+${s.slice(-CAPTURE_MAX)}`,
+    truncated: true
+  };
+}
+__name(trimCapture, "trimCapture");
+function runDrive(args) {
+  const exec = args.exec ?? run3;
+  const server = args.server;
+  if (!SERVER_NAME_RE.test(server)) {
+    return {
+      outcome: "unavailable",
+      observed: false,
+      exitCode: null,
+      readyAfterMs: null,
+      droveForMs: 0,
+      output: "",
+      truncated: false,
+      killedStale: false,
+      note: `--server ${JSON.stringify(server)} is not a name this command will own: it becomes both a path under the temp dir and a word in the shell line tmux runs, so it is restricted to letters, digits, dot, dash and underscore (max 64). Nothing was started.`
+    };
+  }
+  const tmux = /* @__PURE__ */ __name((...a) => exec("tmux", ["-L", server, ...a]), "tmux");
+  if (exec("tmux", ["-V"]).status !== 0) {
+    return {
+      outcome: "unavailable",
+      observed: false,
+      exitCode: null,
+      readyAfterMs: null,
+      droveForMs: 0,
+      output: "",
+      truncated: false,
+      killedStale: false,
+      note: "tmux is not available, so nothing could be driven \u2014 an environment gap, not a finding about the diff"
+    };
+  }
+  const killedStale = tmux("kill-server").status === 0;
+  const started = Date.now();
+  let readyAfterMs = null;
+  if (args.ready) {
+    const deadline = started + args.readyTimeout * 1e3;
+    for (; ; ) {
+      if (exec("bash", ["-lc", args.ready]).status === 0) {
+        readyAfterMs = Date.now() - started;
+        break;
+      }
+      if (Date.now() >= deadline) {
+        tmux("kill-server");
+        return {
+          outcome: "not-ready",
+          observed: false,
+          exitCode: null,
+          readyAfterMs: null,
+          droveForMs: 0,
+          output: "",
+          truncated: false,
+          killedStale,
+          note: `readiness probe never succeeded within ${args.readyTimeout}s (\`${args.ready}\`) \u2014 nothing was driven, so nothing here is evidence about the diff. A slower machine needs a larger --ready-timeout; a probe that can never pass needs a different probe.`
+        };
+      }
+      waitMs(POLL_MS);
+    }
+  }
+  const dir = join16(tmpdir2(), `qwen-review-drive-${server}`);
+  mkdirSync19(dir, { recursive: true });
+  const scriptPath = join16(dir, "drive.sh");
+  const logPath = args.logPath ?? join16(dir, "drive.log");
+  const sentinelPath = join16(dir, "drive.rc");
+  rmSync8(sentinelPath, { force: true });
+  writeFileSync20(scriptPath, wrapScript(args.script, sentinelPath), "utf8");
+  const droveFrom = Date.now();
+  let output = "";
+  let exitCode = null;
+  let outcome = "timed-out";
+  try {
+    const create = tmux(
+      "new-session",
+      "-d",
+      "-c",
+      args.cwd,
+      "bash",
+      "-lc",
+      `bash ${shellQuote(scriptPath)} > ${shellQuote(logPath)} 2>&1`
+    );
+    if (create.status !== 0) {
+      return {
+        outcome: "unavailable",
+        observed: false,
+        exitCode: null,
+        readyAfterMs,
+        droveForMs: 0,
+        output: "",
+        truncated: false,
+        killedStale,
+        note: `tmux could not start a session: ${create.stderr.trim() || "no error text"} \u2014 an environment gap, not a finding`
+      };
+    }
+    const deadline = droveFrom + args.timeout * 1e3;
+    for (; ; ) {
+      output = existsSync10(logPath) ? readFileSync22(logPath, "utf8") : "";
+      exitCode = existsSync10(sentinelPath) ? sentinelExitCode(readFileSync22(sentinelPath, "utf8")) : null;
+      if (exitCode !== null) {
+        outcome = "completed";
+        break;
+      }
+      if (logBytes(logPath) > LOG_MAX_BYTES) {
+        outcome = "overflowed";
+        break;
+      }
+      if (Date.now() >= deadline) break;
+      waitMs(POLL_MS);
+    }
+  } finally {
+    tmux("kill-server");
+    if (!args.logPath) rmSync8(dir, { recursive: true, force: true });
+  }
+  const { text, truncated } = trimCapture(output);
+  const droveForMs = Date.now() - droveFrom;
+  const note = outcome === "overflowed" ? `the drive wrote more than ${Math.round(LOG_MAX_BYTES / 1024 / 1024)} MiB and was stopped \u2014 no exit code is reported because it never gave one, and a run this command had to stop is not evidence about the diff either way. Quieten the script, or have it manage its own output file.` : outcome === "completed" ? `drove for ${Math.round(droveForMs / 1e3)}s and reached its sentinel with exit ${exitCode}${readyAfterMs === null ? "" : ` (ready after ${Math.round(readyAfterMs / 1e3)}s)`}${truncated ? "; the capture was trimmed at the head, so early output is missing" : ""}` : `the drive did not finish within ${args.timeout}s \u2014 the capture below is PARTIAL, and a partial capture is not evidence that the run produced nothing. Raise --timeout, or give the script a smaller job.`;
+  return {
+    outcome,
+    observed: outcome === "completed",
+    exitCode,
+    readyAfterMs,
+    droveForMs,
+    output: text,
+    truncated,
+    killedStale,
+    note
+  };
+}
+__name(runDrive, "runDrive");
+var driveCommand = {
+  command: "drive",
+  describe: "Start something, wait until it is really up, drive it, and capture what it did \u2014 readiness polled rather than slept on, completion proven by a sentinel, cleanup guaranteed",
+  builder: /* @__PURE__ */ __name((yargs) => yargs.option("script", {
+    type: "string",
+    demandOption: true,
+    describe: "Shell script to drive (its exit code is captured)"
+  }).option("cwd", {
+    type: "string",
+    demandOption: true,
+    describe: "Working directory \u2014 usually the PR or base worktree"
+  }).option("ready", {
+    type: "string",
+    describe: "Command polled until it exits 0 before driving (omit only when nothing needs to come up first)"
+  }).option("ready-timeout", {
+    type: "number",
+    default: 60,
+    describe: "Seconds to wait for readiness"
+  }).option("timeout", {
+    type: "number",
+    default: 300,
+    describe: "Seconds to wait for the script to reach its sentinel"
+  }).option("server", {
+    type: "string",
+    default: `qr-${process.pid}`,
+    describe: "tmux server name \u2014 namespaced so runs cannot capture each other"
+  }).option("out", {
+    type: "string",
+    describe: "Write the JSON report here"
+  }), "builder"),
+  handler: /* @__PURE__ */ __name((argv) => {
+    try {
+      const args = argv;
+      const report = runDrive(args);
+      if (args.out) {
+        mkdirSync19(dirname17(resolve17(args.out)), { recursive: true });
+        writeFileSync20(resolve17(args.out), JSON.stringify(report, null, 2));
+      }
+      writeStdoutLine(JSON.stringify(report, null, 2));
+      writeStderrLine(`drive: ${report.note}`);
+      if (!report.observed) process.exitCode = 1;
+    } catch (err) {
+      writeStderrLine(err.message);
+      process.exitCode = 1;
+    }
+  }, "handler")
+};
+
+// packages/cli/src/commands/review/mock-provider.ts
+init_esbuild_shims();
+import {
+  createServer
+} from "node:http";
+import { appendFileSync, mkdirSync as mkdirSync20, writeFileSync as writeFileSync21 } from "node:fs";
+import { dirname as dirname18, resolve as resolve18 } from "node:path";
+import { pathToFileURL } from "node:url";
+function messagesText(body) {
+  const msgs = Array.isArray(body?.["messages"]) ? body["messages"] : [];
+  const one = /* @__PURE__ */ __name((m) => {
+    const c = m?.content;
+    if (typeof c === "string") return c;
+    if (Array.isArray(c))
+      return c.map((p) => String(p?.text ?? "")).join("");
+    return "";
+  }, "one");
+  return msgs.map(one).join("\n");
+}
+__name(messagesText, "messagesText");
+var enc = /* @__PURE__ */ __name((o) => `data: ${JSON.stringify(o)}
+
+`, "enc");
+var BODY_MAX_BYTES = 4 * 1024 * 1024;
+var RECORD_TEXT_MAX = 8 * 1024;
+function replyProblem(r) {
+  if (r === null || typeof r !== "object")
+    return `responder returned ${r === void 0 ? "undefined" : JSON.stringify(r)}; it must return {text} | {tool, args?} | {status, body?}`;
+  const o = r;
+  if ("status" in o) {
+    const st = o["status"];
+    if (!(typeof st === "number" && Number.isInteger(st) && st >= 100 && st <= 599))
+      return `responder returned a non-HTTP status ${JSON.stringify(st)}`;
+    try {
+      JSON.stringify(o["body"] ?? {});
+    } catch {
+      return "responder returned a status body that cannot be serialised (a circular reference?)";
+    }
+    return null;
+  }
+  if ("tool" in o) {
+    if (typeof o["tool"] !== "string" || o["tool"] === "")
+      return `responder returned an empty or non-string tool name ${JSON.stringify(o["tool"])}`;
+    try {
+      JSON.stringify(o["args"] ?? {});
+    } catch {
+      return "responder returned tool args that cannot be serialised (a circular reference?)";
+    }
+    return null;
+  }
+  if ("text" in o)
+    return typeof o["text"] === "string" ? null : `responder returned a non-string text ${JSON.stringify(o["text"])}`;
+  return `responder returned an object with none of text/tool/status: ${JSON.stringify(o).slice(0, 80)}`;
+}
+__name(replyProblem, "replyProblem");
+function forRecord(v) {
+  return v.length <= RECORD_TEXT_MAX ? v : `${v.slice(0, RECORD_TEXT_MAX)}\u2026[${v.length - RECORD_TEXT_MAX} more characters]`;
+}
+__name(forRecord, "forRecord");
+function forRecordReq(r) {
+  return {
+    method: r.method,
+    path: r.path,
+    wire: r.wire,
+    n: r.n,
+    stream: r.stream,
+    text: forRecord(r.text),
+    bodyKeys: r.body ? Object.keys(r.body) : []
+  };
+}
+__name(forRecordReq, "forRecordReq");
+function chunk(delta, finish = null) {
+  return {
+    id: "chatcmpl-qwen-review-mock",
+    object: "chat.completion.chunk",
+    created: Math.floor(Date.now() / 1e3),
+    model: "qwen-review-mock",
+    choices: [{ index: 0, delta, finish_reason: finish }]
+  };
+}
+__name(chunk, "chunk");
+function chunksFor(reply) {
+  const out = [
+    chunk({ role: "assistant", content: "" })
+  ];
+  if ("tool" in reply) {
+    out.push(
+      chunk({
+        tool_calls: [
+          {
+            index: 0,
+            id: `call_${reply.tool}_1`,
+            type: "function",
+            function: {
+              name: reply.tool,
+              arguments: JSON.stringify(reply.args ?? {})
+            }
+          }
+        ]
+      }),
+      chunk({}, "tool_calls")
+    );
+    return out;
+  }
+  if ("text" in reply) {
+    for (const piece of reply.text.match(/[\s\S]{1,40}/g) ?? [])
+      out.push(chunk({ content: piece }));
+  }
+  out.push(chunk({}, "stop"));
+  return out;
+}
+__name(chunksFor, "chunksFor");
+function completionFor(reply) {
+  const message = "tool" in reply ? {
+    role: "assistant",
+    content: null,
+    tool_calls: [
+      {
+        index: 0,
+        id: `call_${reply.tool}_1`,
+        type: "function",
+        function: {
+          name: reply.tool,
+          arguments: JSON.stringify(reply.args ?? {})
+        }
+      }
+    ]
+  } : { role: "assistant", content: "text" in reply ? reply.text : "" };
+  return {
+    id: "chatcmpl-qwen-review-mock",
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model: "qwen-review-mock",
+    choices: [
+      {
+        index: 0,
+        message,
+        finish_reason: "tool" in reply ? "tool_calls" : "stop"
+      }
+    ],
+    // 69% of the corpus carried one, and a client that reads token counts
+    // behaves differently without it — an absent usage block is a behaviour
+    // difference the mock introduced, not one the diff did.
+    usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+  };
+}
+__name(completionFor, "completionFor");
+function sseEvent(type, data) {
+  return `event: ${type}
+data: ${JSON.stringify({ type, ...data })}
+
+`;
+}
+__name(sseEvent, "sseEvent");
+function anthropicStream(reply) {
+  const usage = {
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_creation_input_tokens: 0,
+    cache_read_input_tokens: 0
+  };
+  let out = sseEvent("message_start", {
+    message: {
+      id: "msg_qwen_review_mock",
+      type: "message",
+      role: "assistant",
+      model: "qwen-review-mock",
+      content: [],
+      stop_reason: null,
+      usage
+    }
+  });
+  if ("tool" in reply) {
+    out += sseEvent("content_block_start", {
+      index: 0,
+      content_block: {
+        type: "tool_use",
+        id: `toolu_${reply.tool}_1`,
+        name: reply.tool,
+        input: {}
+      }
+    });
+    out += sseEvent("content_block_delta", {
+      index: 0,
+      delta: {
+        type: "input_json_delta",
+        partial_json: JSON.stringify(reply.args ?? {})
+      }
+    });
+    out += sseEvent("content_block_stop", { index: 0 });
+    out += sseEvent("message_delta", {
+      delta: { stop_reason: "tool_use", stop_sequence: null },
+      usage: { output_tokens: 0 }
+    });
+  } else {
+    const text = "text" in reply ? reply.text : "";
+    out += sseEvent("content_block_start", {
+      index: 0,
+      content_block: { type: "text", text: "" }
+    });
+    for (const piece of text.match(/[\s\S]{1,40}/g) ?? [])
+      out += sseEvent("content_block_delta", {
+        index: 0,
+        delta: { type: "text_delta", text: piece }
+      });
+    out += sseEvent("content_block_stop", { index: 0 });
+    out += sseEvent("message_delta", {
+      delta: { stop_reason: "end_turn", stop_sequence: null },
+      usage: { output_tokens: 0 }
+    });
+  }
+  return out + sseEvent("message_stop", {});
+}
+__name(anthropicStream, "anthropicStream");
+function anthropicMessage(reply) {
+  const content = "tool" in reply ? [
+    {
+      type: "tool_use",
+      id: `toolu_${reply.tool}_1`,
+      name: reply.tool,
+      input: reply.args ?? {}
+    }
+  ] : [{ type: "text", text: "text" in reply ? reply.text : "" }];
+  return {
+    id: "msg_qwen_review_mock",
+    type: "message",
+    role: "assistant",
+    model: "qwen-review-mock",
+    content,
+    stop_reason: "tool" in reply ? "tool_use" : "end_turn",
+    stop_sequence: null,
+    usage: {
+      input_tokens: 0,
+      output_tokens: 0,
+      cache_creation_input_tokens: 0,
+      cache_read_input_tokens: 0
+    }
+  };
+}
+__name(anthropicMessage, "anthropicMessage");
+function anthropicText(body) {
+  const sys = body?.["system"];
+  const sysText = typeof sys === "string" ? sys : Array.isArray(sys) ? sys.map((b) => String(b?.text ?? "")).join("") : "";
+  const rest = messagesText(body);
+  return sysText && rest ? `${sysText}
+${rest}` : sysText || rest;
+}
+__name(anthropicText, "anthropicText");
+var DEFAULT_REPLY = { text: "ok" };
+async function startMockProvider(args, respondOverride) {
+  let respond = respondOverride ?? (() => DEFAULT_REPLY);
+  if (!respondOverride && args.responder) {
+    const mod = await import(pathToFileURL(resolve18(args.responder)).href);
+    const fn = mod.respond ?? mod.default;
+    if (typeof fn !== "function") {
+      throw new Error(
+        `mock-provider: ${args.responder} exports no \`respond\` function \u2014 a responder module must export \`respond(req)\` (or a default export of the same shape)`
+      );
+    }
+    respond = fn;
+  }
+  const logPath = resolve18(args.log);
+  mkdirSync20(dirname18(logPath), { recursive: true });
+  writeFileSync21(logPath, "");
+  let n = 0;
+  const record = /* @__PURE__ */ __name((entry) => appendFileSync(logPath, `${JSON.stringify(entry)}
+`), "record");
+  const server = createServer((req, res) => {
+    const parts = [];
+    let size = 0;
+    let tooBig = false;
+    req.on("data", (d) => {
+      size += d.length;
+      if (size > BODY_MAX_BYTES) {
+        tooBig = true;
+        parts.length = 0;
+        return;
+      }
+      parts.push(d);
+    });
+    req.on("end", () => {
+      if (tooBig) {
+        appendFileSync(
+          logPath,
+          `${JSON.stringify({ t: Date.now(), method: req.method, path: req.url, refused: "body-too-large", bytes: size })}
+`
+        );
+        res.writeHead(413, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            error: `request body exceeded ${BODY_MAX_BYTES} bytes; refused rather than truncated, because a truncated body is a different request`
+          })
+        );
+        return;
+      }
+      void (async () => {
+        const raw = Buffer.concat(parts).toString("utf8");
+        let body = null;
+        try {
+          body = raw ? JSON.parse(raw) : null;
+        } catch {
+          body = null;
+        }
+        const path3 = req.url ?? "/";
+        const isModels = path3.startsWith("/v1/models");
+        const chat = path3.includes("/chat/completions") || path3.includes("/v1/messages");
+        const willAsk = !isModels && chat && (req.method ?? "GET") === "POST" && body !== null;
+        const wire = path3.includes("/v1/messages") ? "anthropic" : "openai";
+        if (willAsk) n += 1;
+        const mreq = {
+          method: req.method ?? "GET",
+          path: path3,
+          body,
+          wire,
+          text: wire === "anthropic" ? anthropicText(body) : messagesText(body),
+          stream: body?.["stream"] === true,
+          // Null for anything the responder was never asked about, so the
+          // record cannot be read as "the responder saw this".
+          n: willAsk ? n : null
+        };
+        if (!isModels) {
+          const why = !chat ? `this mock serves /v1/chat/completions and /v1/messages only; ${path3} is not one of them` : mreq.method !== "POST" ? `${mreq.method} is not how either chat endpoint is called; use POST` : body === null ? "the request body was empty or not JSON, so there is nothing to answer" : null;
+          if (why) {
+            record({ t: Date.now(), ...forRecordReq(mreq), refused: why });
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: why }));
+            return;
+          }
+        }
+        if (isModels) {
+          record({ t: Date.now(), ...forRecordReq(mreq), reply: "models" });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(
+            JSON.stringify({
+              object: "list",
+              data: [{ id: "qwen-review-mock", object: "model" }]
+            })
+          );
+          return;
+        }
+        let reply;
+        try {
+          reply = await respond(mreq);
+          const problem = replyProblem(reply);
+          if (problem) throw new Error(problem);
+        } catch (err) {
+          reply = {
+            status: 500,
+            body: { error: String(err.message) }
+          };
+        }
+        record({ t: Date.now(), ...forRecordReq(mreq), reply });
+        if ("status" in reply) {
+          res.writeHead(reply.status, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(reply.body ?? {}));
+          return;
+        }
+        if (!mreq.stream) {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(
+            JSON.stringify(
+              wire === "anthropic" ? anthropicMessage(reply) : completionFor(reply)
+            )
+          );
+          return;
+        }
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        });
+        if (wire === "anthropic") {
+          res.write(anthropicStream(reply));
+        } else {
+          for (const c of chunksFor(reply)) res.write(enc(c));
+          res.write("data: [DONE]\n\n");
+        }
+        res.end();
+      })();
+    });
+  });
+  await new Promise((ok) => server.listen(0, "127.0.0.1", ok));
+  const addr = server.address();
+  const port = typeof addr === "object" && addr ? addr.port : 0;
+  return {
+    report: {
+      port,
+      baseUrl: `http://127.0.0.1:${port}/v1`,
+      logPath,
+      note: `mock provider on port ${port}; every request is appended to ${logPath} as JSONL \u2014 diff those between two trees and the difference is evidence`
+    },
+    close: /* @__PURE__ */ __name(() => new Promise((ok) => {
+      server.close(() => ok());
+    }), "close")
   };
 }
-__name(runTestDelta, "runTestDelta");
-var testDeltaCommand = {
-  command: "test-delta",
-  describe: "Rerun the PR side's failed test commands on the base tree and report which failing files are the PR's own (net-new) vs pre-existing (shared)",
-  builder: /* @__PURE__ */ __name((yargs) => yargs.option("report", {
+__name(startMockProvider, "startMockProvider");
+var mockProviderCommand = {
+  command: "mock-provider",
+  describe: "Serve OpenAI (/v1/chat/completions) and Anthropic (/v1/messages) endpoints for the review to drive the real product against, recording every request as JSONL \u2014 the protocol is provided, the answers are yours; for any other kind of upstream, start it yourself and use `drive`",
+  builder: /* @__PURE__ */ __name((yargs) => yargs.option("responder", {
     type: "string",
-    demandOption: true,
-    describe: "Agent 7's build-test report (its failed commands and outputs)"
-  }).option("baseline", {
+    describe: "Module exporting `respond(req)` returning {text} | {tool,args} | {status,body}"
+  }).option("log", {
     type: "string",
     demandOption: true,
-    describe: "The BUILT base tree from `qwen review base-tree`"
-  }).option("pr-worktree", {
-    type: "string",
-    describe: "The PR worktree the report's failures were produced in \u2014 its root is stripped so both sides compare as repo-relative paths"
-  }).option("out", { type: "string", describe: "Write the JSON report here" }).option("timeout", {
+    describe: "Where to append the JSONL request record"
+  }).option("ttl", {
     type: "number",
-    default: 300,
-    describe: "Per-command deadline in seconds, as build-test"
+    default: 600,
+    describe: "Seconds to serve before shutting down on its own"
+  }).option("out", {
+    type: "string",
+    describe: "Write the JSON report here"
   }), "builder"),
-  handler: /* @__PURE__ */ __name((argv) => {
-    const args = argv;
-    const report = runTestDelta(args);
-    if (args.out) {
-      mkdirSync16(dirname15(resolve15(args.out)), { recursive: true });
-      writeFileSync18(resolve15(args.out), JSON.stringify(report, null, 2));
+  // `async`, and the returned promise is what keeps the process alive. A
+  // fire-and-forget `void (async () => …)()` here produced a command that
+  // printed nothing at all and exited: yargs returned, node found no pending
+  // work it could see, and the server it had just bound went with it. Measured
+  // — both streams empty, exit 0, a mock that was never reachable.
+  handler: /* @__PURE__ */ __name(async (argv) => {
+    try {
+      const args = argv;
+      const { report, close } = await startMockProvider(args);
+      if (args.out) {
+        mkdirSync20(dirname18(resolve18(args.out)), { recursive: true });
+        writeFileSync21(resolve18(args.out), JSON.stringify(report, null, 2));
+      }
+      writeStdoutLine(JSON.stringify(report, null, 2));
+      writeStderrLine(`mock-provider: ${report.note}`);
+      await new Promise((done) => {
+        setTimeout(done, Math.max(1, args.ttl) * 1e3);
+      });
+      await close();
+    } catch (err) {
+      writeStderrLine(err.message);
+      process.exitCode = 1;
     }
-    writeStdoutLine(JSON.stringify(report, null, 2));
-    writeStderrLine(`test-delta: ${report.note}`);
   }, "handler")
 };
 
 // packages/cli/src/commands/review/extract-step.ts
 init_esbuild_shims();
 var import_yaml = __toESM(require_dist(), 1);
-import { mkdirSync as mkdirSync17, readFileSync as readFileSync20, writeFileSync as writeFileSync19, chmodSync } from "node:fs";
-import { dirname as dirname16, resolve as resolve16 } from "node:path";
+import { mkdirSync as mkdirSync21, readFileSync as readFileSync23, writeFileSync as writeFileSync22, chmodSync } from "node:fs";
+import { dirname as dirname19, resolve as resolve19 } from "node:path";
 function expressionsOf(...texts) {
   const seen = /* @__PURE__ */ new Set();
   for (const t2 of texts) {
@@ -12986,8 +14481,8 @@ function nearestScoped(...values) {
 __name(nearestScoped, "nearestScoped");
 function runDefaultsOf(container) {
   const defaults = container?.defaults;
-  const run3 = defaults && typeof defaults === "object" ? defaults.run : void 0;
-  return run3 && typeof run3 === "object" ? run3 : {};
+  const run4 = defaults && typeof defaults === "object" ? defaults.run : void 0;
+  return run4 && typeof run4 === "object" ? run4 : {};
 }
 __name(runDefaultsOf, "runDefaultsOf");
 function envValue(v) {
@@ -13017,10 +14512,10 @@ function nearestFirst(env, sources) {
 }
 __name(nearestFirst, "nearestFirst");
 function runExtractStep(args) {
-  const wfPath = resolve16(args.workflow);
+  const wfPath = resolve19(args.workflow);
   let text;
   try {
-    text = readFileSync20(wfPath, "utf8");
+    text = readFileSync23(wfPath, "utf8");
   } catch (err) {
     throw new Error(
       `extract-step: cannot read ${args.workflow}: ${err.message}`
@@ -13086,8 +14581,8 @@ function runExtractStep(args) {
   const workingDirectory = workingDir?.value;
   const script = step.run;
   const stepLabel = String(step.name ?? step.id ?? index);
-  const outPath = resolve16(args.out);
-  mkdirSync17(dirname16(outPath), { recursive: true });
+  const outPath = resolve19(args.out);
+  mkdirSync21(dirname19(outPath), { recursive: true });
   const header = [
     `#!/usr/bin/env ${shellCommand}`,
     ...commentLines(
@@ -13111,7 +14606,7 @@ function runExtractStep(args) {
     ),
     ""
   ].join("\n");
-  writeFileSync19(outPath, header + script + (script.endsWith("\n") ? "" : "\n"));
+  writeFileSync22(outPath, header + script + (script.endsWith("\n") ? "" : "\n"));
   chmodSync(outPath, 493);
   return {
     workflow: args.workflow,
@@ -13172,7 +14667,7 @@ var extractStepCommand = {
 
 // packages/cli/src/commands/review/submit.ts
 init_esbuild_shims();
-import { mkdirSync as mkdirSync19, readFileSync as readFileSync21 } from "node:fs";
+import { mkdirSync as mkdirSync22, readFileSync as readFileSync24 } from "node:fs";
 
 // packages/cli/src/commands/review/lib/receipt.ts
 init_esbuild_shims();
@@ -13190,123 +14685,11 @@ function parseReceiptIds(raw) {
 }
 __name(parseReceiptIds, "parseReceiptIds");
 
-// packages/cli/src/services/skill-args-file.ts
-init_esbuild_shims();
-import {
-  mkdirSync as mkdirSync18,
-  openSync as openSync2,
-  writeSync,
-  closeSync as closeSync2,
-  rmSync as rmSync7,
-  lstatSync as lstatSync3,
-  existsSync as existsSync8,
-  constants
-} from "node:fs";
-import { join as join15 } from "node:path";
-var debugLogger3 = createDebugLogger("SKILL_ARGS_FILE");
-var SKILL_ARGS_DIR = join15(".qwen", "tmp");
-function safe(s) {
-  return s.replace(/[^A-Za-z0-9._-]/g, "_");
-}
-__name(safe, "safe");
-function currentSessionId() {
-  return sessionIdContext.getStore()?.trim() || process.env["QWEN_CODE_SESSION_ID"]?.trim() || "";
-}
-__name(currentSessionId, "currentSessionId");
-function skillArgsDir(sessionId = currentSessionId()) {
-  return sessionId ? join15(SKILL_ARGS_DIR, `s-${safe(sessionId)}`) : SKILL_ARGS_DIR;
-}
-__name(skillArgsDir, "skillArgsDir");
-function skillArgsPath(skillName, sessionId = currentSessionId()) {
-  return join15(
-    skillArgsDir(sessionId),
-    `qwen-skill-args-${safe(skillName)}.txt`
-  );
-}
-__name(skillArgsPath, "skillArgsPath");
-function writeSkillArgs(skillName, args) {
-  const path3 = skillArgsPath(skillName);
-  try {
-    const dir = skillArgsDir();
-    mkdirSync18(dir, { recursive: true });
-    if (lstatSync3(dir).isSymbolicLink()) {
-      debugLogger3.warn(
-        `Skill args directory ${dir} is a symlink; refusing to write through it.`
-      );
-      return null;
-    }
-    if (lstatSync3(path3, { throwIfNoEntry: false })?.isSymbolicLink()) {
-      debugLogger3.warn(
-        `Skill args file ${path3} is a symlink; refusing to write through it.`
-      );
-      return null;
-    }
-    const fd = openSync2(
-      path3,
-      constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | constants.O_NOFOLLOW,
-      384
-    );
-    try {
-      const buf = Buffer.from(args, "utf8");
-      let off = 0;
-      while (off < buf.length) {
-        off += writeSync(fd, buf, off, buf.length - off);
-      }
-    } finally {
-      closeSync2(fd);
-    }
-    return path3;
-  } catch (err) {
-    debugLogger3.warn(
-      `Could not write skill args to ${path3}: ${err.message}`
-    );
-    return null;
-  }
-}
-__name(writeSkillArgs, "writeSkillArgs");
-function clearSkillArgs(skillName) {
-  const path3 = skillArgsPath(skillName);
-  try {
-    rmSync7(path3, { force: true });
-  } catch (err) {
-    debugLogger3.warn(
-      `Could not clear skill args for ${skillName}: ${err.message}`
-    );
-    return false;
-  }
-  if (existsSync8(path3)) {
-    debugLogger3.warn(`Skill args for ${skillName} survived removal at ${path3}`);
-    return false;
-  }
-  return true;
-}
-__name(clearSkillArgs, "clearSkillArgs");
-function staleArgsWarning() {
-  return `
-
-<skill-args-stale>A previous invocation's argument record could not be removed, so it is still on disk and still names whatever it named. This invocation supplied NO arguments. Do not treat that stale record as this run's authorisation: this run has none, and must not post.</skill-args-stale>
-`;
-}
-__name(staleArgsWarning, "staleArgsWarning");
-function skillArgsNote(path3, args) {
-  return `
-
-Your invocation arguments have been written verbatim to a session-private file. Its exact path is below \u2014 use it wherever these instructions say to read the args file (e.g. \`< '${path3}'\`), and do not retype the arguments, which is how they get mistyped.
-<skill-args-file>${path3}</skill-args-file>
-<skill-args>${args}</skill-args>
-`;
-}
-__name(skillArgsNote, "skillArgsNote");
-
 // packages/cli/src/commands/review/submit.ts
-function defaultSkillArgsPath() {
-  return skillArgsPath("review");
-}
-__name(defaultSkillArgsPath, "defaultSkillArgsPath");
 var EVENTS = /* @__PURE__ */ new Set(["APPROVE", "REQUEST_CHANGES", "COMMENT"]);
 function readReceiptIds(receiptPath) {
   try {
-    return parseReceiptIds(readFileSync21(receiptPath, "utf8"));
+    return parseReceiptIds(readFileSync24(receiptPath, "utf8"));
   } catch {
     return [];
   }
@@ -13317,60 +14700,20 @@ function isDiffLine(n) {
 }
 __name(isDiffLine, "isDiffLine");
 function authorization(args) {
-  if (args.userAuthorized) {
-    return { ok: true, why: "the user asked for this review to be published" };
-  }
-  const sessionScoped = defaultSkillArgsPath();
-  const path3 = currentSessionId() === "" && args.skillArgs ? args.skillArgs : sessionScoped;
-  let raw;
-  try {
-    raw = readFileSync21(path3, "utf8");
-  } catch {
-    return {
-      ok: false,
-      why: `no review arguments were recorded at ${path3}, so this run cannot show that \`--comment\` was requested`
-    };
-  }
-  const verdict = parseReviewArgs(raw);
-  if (!verdict.comment.effective) {
-    return {
-      ok: false,
-      why: `\`--comment\` was not in the review arguments (${JSON.stringify(raw.trim())})`
-    };
-  }
-  const t2 = verdict.target;
-  const authorisedPr = t2.type === "pr-number" || t2.type === "pr-url" ? t2.number : void 0;
-  if (authorisedPr === void 0) {
-    return {
-      ok: false,
-      why: `the review arguments (${JSON.stringify(raw.trim())}) do not name a pull request, so they cannot authorise posting to one`
-    };
-  }
-  if (authorisedPr !== args.pr) {
-    return {
-      ok: false,
-      why: `the review arguments authorise pull request #${authorisedPr}, but this submission targets #${args.pr}`
-    };
-  }
-  if (t2.type === "pr-url") {
-    const authorisedRepo = `${t2.owner}/${t2.repo}`;
-    if (authorisedRepo.toLowerCase() !== args.repo.toLowerCase()) {
-      return {
-        ok: false,
-        why: `the review arguments authorise ${authorisedRepo}, but this submission targets ${args.repo}`
-      };
-    }
-    if (args.host && t2.host.toLowerCase() !== args.host.toLowerCase()) {
-      return {
-        ok: false,
-        why: `the review arguments authorise ${t2.host}, but this submission targets ${args.host}`
-      };
-    }
-  }
-  return {
-    ok: true,
-    why: `\`--comment\` was in the review arguments for #${authorisedPr}`
-  };
+  return reviewWriteAuthorization({
+    userAuthorized: args.userAuthorized,
+    skillArgs: args.skillArgs,
+    pr: args.pr,
+    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)
+  });
 }
 __name(authorization, "authorization");
 function compose(payload, cliVersion) {
@@ -13481,7 +14824,7 @@ function runSubmit(args, cliVersion = "unknown") {
   }
   let payload;
   try {
-    payload = JSON.parse(readFileSync21(args.review, "utf8"));
+    payload = JSON.parse(readFileSync24(args.review, "utf8"));
   } catch (err) {
     throw new Error(
       `Cannot read review JSON ${args.review}: ${err.message}`
@@ -13557,7 +14900,7 @@ Posting is a public, irreversible write, and this run has no authorisation for o
       const receiptPath = tmpFile(`pr-${args.pr}`, "submit-receipt.json");
       const priorIds = readReceiptIds(receiptPath);
       const reviewIds = [.../* @__PURE__ */ new Set([...priorIds, reviewId])];
-      mkdirSync19(REVIEW_TMP_DIR, { recursive: true });
+      mkdirSync22(REVIEW_TMP_DIR, { recursive: true });
       atomicWriteFileSync(
         receiptPath,
         `${JSON.stringify({ reviewIds, event, postedAt: (/* @__PURE__ */ new Date()).toISOString() })}
@@ -13620,20 +14963,20 @@ var submitCommand = {
 
 // packages/cli/src/commands/review/test-efficacy.ts
 init_esbuild_shims();
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
 import {
-  mkdirSync as mkdirSync20,
+  mkdirSync as mkdirSync23,
   readdirSync as readdirSync5,
-  writeFileSync as writeFileSync20,
-  readFileSync as readFileSync22,
-  rmSync as rmSync8,
+  writeFileSync as writeFileSync23,
+  readFileSync as readFileSync25,
+  rmSync as rmSync9,
   lstatSync as lstatSync4,
-  existsSync as existsSync9,
-  statSync as statSync6,
+  existsSync as existsSync11,
+  statSync as statSync8,
   symlinkSync
 } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname as dirname17, join as join16, isAbsolute as isAbsolute3, sep as sep3 } from "node:path";
+import { dirname as dirname20, join as join17, isAbsolute as isAbsolute3, sep as sep3 } 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);
@@ -13988,6 +15331,73 @@ function collocatedProbe(file, testPaths) {
   });
 }
 __name(collocatedProbe, "collocatedProbe");
+function heldForRedCollocatedTest(kind, file, probes, greenProbes, baselinePerFile) {
+  const own = collocatedProbe(file, probes);
+  if (!own || greenProbes.includes(own)) return void 0;
+  return collocatedNotGreenDetail(kind, own, baselinePerFile);
+}
+__name(heldForRedCollocatedTest, "heldForRedCollocatedTest");
+function runnerFailureReason(r) {
+  return r.signal || r.error?.code === "ETIMEDOUT" ? "runner-died" : "not-run";
+}
+__name(runnerFailureReason, "runnerFailureReason");
+var ProbeRunFailure = class extends Error {
+  constructor(message, reason) {
+    super(message);
+    this.reason = reason;
+    this.name = "ProbeRunFailure";
+  }
+  static {
+    __name(this, "ProbeRunFailure");
+  }
+};
+var BASELINE_REASON = /* @__PURE__ */ new Set([
+  "no-output",
+  "not-in-results",
+  "no-tests",
+  "all-skipped"
+]);
+var REASON_PHRASE = {
+  // The suite ran and read green, but the control proved the runner could not
+  // have reported otherwise.
+  "control-failed": "it read green there, but the positive control failed, so nothing could have turned that run red",
+  // Nothing ran: no worktree, the checkout failed, or the runner could not be
+  // started at all — a spawn that fails with ENOENT never gets to a test.
+  "not-run": "no probe suite ran for it at all there",
+  // Started and did not survive. How much of it ran before that is unknown.
+  "runner-died": "the probe suite was started there and did not survive (killed at the deadline, or by a signal)",
+  // Nothing is known about collection here — the runner never produced output
+  // to read. Saying "collected no tests" would be the same invented cause this
+  // function exists to stop, one layer down: a reader sent after a compile
+  // error that is not there, while the runner itself is what fell over.
+  "no-output": "the runner produced no parseable output there, so nothing at all is known about it",
+  // The run answered, and this file was not in the answer. A compile or import
+  // error looks like this — and so does a path that failed to match, which the
+  // boundary and case rules in `classifyProbeRun` exist because of. Naming one
+  // would be picking between two live possibilities.
+  "not-in-results": "the run produced results there but none for it \u2014 which a compile or import error looks like, and so does a path that did not match",
+  "no-tests": "it collected no tests there \u2014 the shape a compile or import error in the probe tree takes",
+  "all-skipped": "it collected tests there but executed none of them"
+};
+var NOT_REPORTED = "the baseline did not report it";
+function collocatedNotGreenDetail(kind, probe, baselinePerFile) {
+  const entry = baselinePerFile.find((p) => p.file === probe);
+  const reason = entry === void 0 ? NOT_REPORTED : entry.verdict === "inconclusive" ? (
+    // Three reasons are set on the run-level `results` array and never by
+    // `classifyProbeRun`, so a baseline entry cannot carry them. Reaching
+    // one means the caller passed something other than the baseline —
+    // say that, rather than emit "did not run green … it read green".
+    BASELINE_REASON.has(entry.reason) ? REASON_PHRASE[entry.reason] : `the baseline did not classify it (${REASON_PHRASE[entry.reason]}), so this explanation does not apply to it`
+  ) : entry.verdict === "gated" ? "it was RED there" : (
+    // `inert` IS green, so the sentence this function builds does not
+    // apply to it. Say that, rather than produce a fluent claim that
+    // contradicts the measurement — the caller is what is wrong here.
+    "the baseline reported it GREEN, so this explanation does not apply to it"
+  );
+  const what = kind === "mutant" ? "the statement" : "the hunk";
+  return `this ${kind}'s collocated test ${probe} did not run green in the unmutated baseline \u2014 ${reason}, so the remaining probes passing cannot show ${what} is uncovered`;
+}
+__name(collocatedNotGreenDetail, "collocatedNotGreenDetail");
 function hasCollocatedNewTest(file, testPaths) {
   return collocatedProbe(file, testPaths) !== void 0;
 }
@@ -14018,6 +15428,7 @@ function classifyProbeRun(exitCode, stdout, probes, stderr = "") {
     return probes.map((file) => ({
       file,
       verdict: "inconclusive",
+      reason: "no-output",
       detail: `runner produced no parseable JSON (exit ${exitCode})${why ? `: ${why}` : ""}`
     }));
   }
@@ -14032,10 +15443,19 @@ function classifyProbeRun(exitCode, stdout, probes, stderr = "") {
     const assertions = result?.assertionResults ?? [];
     const failed = assertions.filter((a) => a.status === "failed").length;
     const passed = assertions.filter((a) => a.status === "passed").length;
-    if (!result || assertions.length === 0) {
+    if (!result) {
+      return {
+        file,
+        verdict: "inconclusive",
+        reason: "not-in-results",
+        detail: `the run produced results but none for this file (run exit ${exitCode}) \u2014 a compile or import error looks like this, and so does a path that did not match; not evidence either way`
+      };
+    }
+    if (assertions.length === 0) {
       return {
         file,
         verdict: "inconclusive",
+        reason: "no-tests",
         detail: `collected no tests with the source reverted (run exit ${exitCode}) \u2014 likely a compile or import error, which is not evidence either way`
       };
     }
@@ -14050,6 +15470,7 @@ function classifyProbeRun(exitCode, stdout, probes, stderr = "") {
       return {
         file,
         verdict: "inconclusive",
+        reason: "all-skipped",
         detail: `${assertions.length} test(s) collected but none executed with the source reverted (all skipped) \u2014 not evidence either way`
       };
     }
@@ -14062,7 +15483,7 @@ function classifyProbeRun(exitCode, stdout, probes, stderr = "") {
 }
 __name(classifyProbeRun, "classifyProbeRun");
 function git3(cwd, ...args) {
-  const r = spawnSync6("git", args, { cwd, encoding: "utf8" });
+  const r = spawnSync7("git", args, { cwd, encoding: "utf8" });
   if (r.error) throw r.error;
   if (r.status !== 0) {
     throw new Error(`git ${args.join(" ")} failed: ${r.stderr ?? ""}`);
@@ -14070,7 +15491,7 @@ function git3(cwd, ...args) {
 }
 __name(git3, "git");
 function gitOut2(cwd, ...args) {
-  const r = spawnSync6("git", args, { cwd, encoding: "utf8" });
+  const r = spawnSync7("git", args, { cwd, encoding: "utf8" });
   if (r.error) throw r.error;
   if (r.status !== 0) {
     throw new Error(`git ${args.join(" ")} failed: ${r.stderr ?? ""}`);
@@ -14079,7 +15500,7 @@ function gitOut2(cwd, ...args) {
 }
 __name(gitOut2, "gitOut");
 function findVitestBin(worktree) {
-  const req = createRequire(join16(worktree, "noop.js"));
+  const req = createRequire(join17(worktree, "noop.js"));
   let pkgPath;
   try {
     pkgPath = req.resolve("vitest/package.json");
@@ -14089,16 +15510,16 @@ function findVitestBin(worktree) {
     }
     throw error;
   }
-  const pkg = JSON.parse(readFileSync22(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync25(pkgPath, "utf8"));
   const bin = pkg.bin?.vitest;
   if (!bin) {
     throw new Error(`vitest package at ${pkgPath} declares no "vitest" bin`);
   }
-  return join16(dirname17(pkgPath), bin);
+  return join17(dirname20(pkgPath), bin);
 }
 __name(findVitestBin, "findVitestBin");
 function gitCapture(cwd, ...args) {
-  const r = spawnSync6("git", args, {
+  const r = spawnSync7("git", args, {
     cwd,
     encoding: "utf8",
     maxBuffer: 64 * 1024 * 1024
@@ -14111,7 +15532,7 @@ function gitCapture(cwd, ...args) {
 }
 __name(gitCapture, "gitCapture");
 function existsAtRev(cwd, rev, path3) {
-  const r = spawnSync6("git", ["cat-file", "-e", `${rev}:${path3}`], { cwd });
+  const r = spawnSync7("git", ["cat-file", "-e", `${rev}:${path3}`], { cwd });
   if (r.error) throw r.error;
   return r.status === 0;
 }
@@ -14120,7 +15541,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 = join16(cur, parts[i]);
+    cur = join17(cur, parts[i]);
     let st;
     try {
       st = lstatSync4(cur);
@@ -14133,7 +15554,7 @@ function safeRmWithin(worktree, relPath) {
       );
     }
   }
-  rmSync8(cur, { force: true });
+  rmSync9(cur, { force: true });
 }
 __name(safeRmWithin, "safeRmWithin");
 var existsAtBase = /* @__PURE__ */ __name((cwd, base, path3) => existsAtRev(cwd, base, path3), "existsAtBase");
@@ -14145,15 +15566,15 @@ __name(probeCleanupFailureDetail, "probeCleanupFailureDetail");
 function exposeDependencies(probeTree, dependencyRoot) {
   const done = { linked: 0, failed: 0 };
   if (probeTree === dependencyRoot) return done;
-  const source = join16(dependencyRoot, "node_modules");
-  const target = join16(probeTree, "node_modules");
-  if (!existsSync9(source) || existsSync9(target)) return done;
-  mkdirSync20(target);
+  const source = join17(dependencyRoot, "node_modules");
+  const target = join17(probeTree, "node_modules");
+  if (!existsSync11(source) || existsSync11(target)) return done;
+  mkdirSync23(target);
   const linkType = process.platform === "win32" ? "junction" : "dir";
   for (const entry of readdirSync5(source, { withFileTypes: true })) {
     if (entry.name === ".vite" || entry.name === ".vite-temp") continue;
-    const sourceEntry = join16(source, entry.name);
-    const targetEntry = join16(target, entry.name);
+    const sourceEntry = join17(source, entry.name);
+    const targetEntry = join17(target, entry.name);
     let sourceStats;
     try {
       sourceStats = lstatSync4(sourceEntry);
@@ -14163,7 +15584,7 @@ function exposeDependencies(probeTree, dependencyRoot) {
     }
     if (sourceStats.isSymbolicLink()) {
       try {
-        if (!statSync6(sourceEntry).isDirectory()) continue;
+        if (!statSync8(sourceEntry).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -14173,7 +15594,7 @@ function exposeDependencies(probeTree, dependencyRoot) {
     if (entry.name.startsWith("@")) {
       let pkgs;
       try {
-        mkdirSync20(targetEntry);
+        mkdirSync23(targetEntry);
         pkgs = readdirSync5(sourceEntry);
       } catch {
         done.failed++;
@@ -14181,7 +15602,7 @@ function exposeDependencies(probeTree, dependencyRoot) {
       }
       for (const pkg of pkgs) {
         try {
-          symlinkSync(join16(sourceEntry, pkg), join16(targetEntry, pkg), linkType);
+          symlinkSync(join17(sourceEntry, pkg), join17(targetEntry, pkg), linkType);
           done.linked++;
         } catch {
           done.failed++;
@@ -14203,7 +15624,7 @@ function runProbeSuite(probeTree, probes, deadlineAt, now = Date.now, dependency
   const started = now();
   const timeout = deadlineAt !== void 0 ? Math.max(1, Math.min(PROBE_RUN_TIMEOUT_MS, deadlineAt - started)) : PROBE_RUN_TIMEOUT_MS;
   const exposed = exposeDependencies(probeTree, dependencyRoot);
-  const r = spawnSync6(
+  const r = spawnSync7(
     process.execPath,
     [findVitestBin(dependencyRoot), "run", "--reporter=json", ...probes],
     {
@@ -14216,10 +15637,12 @@ function runProbeSuite(probeTree, probes, deadlineAt, now = Date.now, dependency
       maxBuffer: 64 * 1024 * 1024
     }
   );
-  if (r.error) throw r.error;
+  if (r.error)
+    throw new ProbeRunFailure(r.error.message, runnerFailureReason(r));
   if (r.signal) {
-    throw new Error(
-      `runner killed by ${r.signal}${r.signal === "SIGTERM" ? ` (probe timed out after ${Math.round(timeout / 1e3)}s)` : ""}`
+    throw new ProbeRunFailure(
+      `runner killed by ${r.signal}${r.signal === "SIGTERM" ? ` (probe timed out after ${Math.round(timeout / 1e3)}s)` : ""}`,
+      runnerFailureReason(r)
     );
   }
   return {
@@ -14325,10 +15748,10 @@ function newSideLength(header) {
 __name(newSideLength, "newSideLength");
 function runOneHunkProbe(probeTree, hunk, probes, deadlineAt, now = Date.now) {
   const { patch: _patch, ...meta } = hunk;
-  const abs = join16(probeTree, hunk.file);
+  const abs = join17(probeTree, hunk.file);
   let original;
   try {
-    original = readFileSync22(abs, "utf8");
+    original = readFileSync25(abs, "utf8");
   } catch (e) {
     return {
       ...meta,
@@ -14336,7 +15759,7 @@ function runOneHunkProbe(probeTree, hunk, probes, deadlineAt, now = Date.now) {
       detail: `the probe tree does not hold ${hunk.file}: ${e instanceof Error ? e.message : String(e)}`
     };
   }
-  const applied = spawnSync6("git", ["apply", "--reverse", "-"], {
+  const applied = spawnSync7("git", ["apply", "--reverse", "-"], {
     cwd: probeTree,
     input: hunk.patch,
     encoding: "utf8"
@@ -14354,21 +15777,21 @@ 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 {
-    mkdirSync20(dirname17(abs), { recursive: true });
-    writeFileSync20(abs, original, "utf8");
+    mkdirSync23(dirname20(abs), { recursive: true });
+    writeFileSync23(abs, original, "utf8");
   }
 }
 __name(runOneHunkProbe, "runOneHunkProbe");
 function runControlMutant(probeTree, probeFile, deadlineAt, now = Date.now) {
-  const abs = join16(probeTree, probeFile);
+  const abs = join17(probeTree, probeFile);
   let original;
   try {
-    original = readFileSync22(abs, "utf8");
+    original = readFileSync25(abs, "utf8");
   } catch {
     return null;
   }
   try {
-    writeFileSync20(
+    writeFileSync23(
       abs,
       `${original}
 ;import { it as __qcIt, expect as __qcExpect } from 'vitest';
@@ -14381,13 +15804,13 @@ __qcIt('QWEN-REVIEW-POSITIVE-CONTROL', () => {
     const { perFile } = runProbeSuite(probeTree, [probeFile], deadlineAt, now);
     return perFile.some((r) => r.verdict === "gated");
   } finally {
-    writeFileSync20(abs, original, "utf8");
+    writeFileSync23(abs, original, "utf8");
   }
 }
 __name(runControlMutant, "runControlMutant");
 function runOneMutant(probeTree, mutant, probes, deadlineAt, now = Date.now, dependencyRoot = probeTree) {
-  const abs = join16(probeTree, mutant.file);
-  const original = readFileSync22(abs, "utf8");
+  const abs = join17(probeTree, mutant.file);
+  const original = readFileSync25(abs, "utf8");
   const lines2 = original.split("\n");
   if ((lines2[mutant.line - 1] ?? "").trim() !== mutant.statement) {
     return {
@@ -14403,7 +15826,7 @@ function runOneMutant(probeTree, mutant, probes, deadlineAt, now = Date.now, dep
     lines2.splice(mutant.line - 1, 1);
   }
   try {
-    writeFileSync20(abs, lines2.join("\n"), "utf8");
+    writeFileSync23(abs, lines2.join("\n"), "utf8");
     const { perFile } = runProbeSuite(
       probeTree,
       probes,
@@ -14415,7 +15838,7 @@ function runOneMutant(probeTree, mutant, probes, deadlineAt, now = Date.now, dep
     const detail = verdict === "killed" ? `the suite went red with this statement ${what} \u2014 a test catches it` : verdict === "survived" ? `every affected test still PASSED with this statement ${what} \u2014 no test fails ${mutant.mutated === void 0 ? "when it is removed" : "when it changes"}` : "the mutated tree produced no clean verdict (likely a compile or import error) \u2014 not evidence either way";
     return { ...mutant, verdict, detail };
   } finally {
-    writeFileSync20(abs, original, "utf8");
+    writeFileSync23(abs, original, "utf8");
   }
 }
 __name(runOneMutant, "runOneMutant");
@@ -14454,9 +15877,9 @@ async function runTestEfficacy(args) {
   const now = args.now ?? Date.now;
   const startedAt = now();
   const { report, worktree, base, out } = args;
-  const plan = JSON.parse(readFileSync22(report, "utf8"));
+  const plan = JSON.parse(readFileSync25(report, "utf8"));
   const rootPkg = JSON.parse(
-    readFileSync22(`${worktree}/package.json`, "utf8")
+    readFileSync25(`${worktree}/package.json`, "utf8")
   );
   const globs = rootPkg.workspaces ?? [];
   const { unreachable, probes, revert } = planTestEfficacy(
@@ -14464,8 +15887,8 @@ async function runTestEfficacy(args) {
     globs
   );
   for (const p of revert) {
-    const norm = join16(worktree, p);
-    const root = join16(worktree, ".");
+    const norm = join17(worktree, p);
+    const root = join17(worktree, ".");
     if (isAbsolute3(p) || norm !== root && !norm.startsWith(root + sep3)) {
       throw new Error(
         `refusing to run: revert path escapes the worktree: ${JSON.stringify(p)}`
@@ -14568,7 +15991,12 @@ async function runTestEfficacy(args) {
         String(sweep?.stderr ?? "")
       );
       for (const file of probes) {
-        results.push({ file, verdict: "inconclusive", detail });
+        results.push({
+          file,
+          verdict: "inconclusive",
+          reason: "not-run",
+          detail
+        });
       }
       for (const c of candidates) {
         mutantResults.push({ ...c, verdict: "inconclusive", detail });
@@ -14618,6 +16046,21 @@ async function runTestEfficacy(args) {
             );
           }
           for (const c of harnessValidated === false ? [] : candidates) {
+            const heldDetail = heldForRedCollocatedTest(
+              "mutant",
+              c.file,
+              probes,
+              greenProbes,
+              baseline.perFile
+            );
+            if (heldDetail) {
+              mutantResults.push({
+                ...c,
+                verdict: "inconclusive",
+                detail: heldDetail
+              });
+              continue;
+            }
             const remaining = mutantDeadline - now();
             if (!fitsAnotherMutantRun(remaining, estimatedRunMs)) {
               mutantsSkippedForBudget = candidates.length - mutantResults.length;
@@ -14635,13 +16078,19 @@ async function runTestEfficacy(args) {
             );
           }
           for (const h of harnessValidated === false ? [] : hunkCandidates) {
-            const own = collocatedProbe(h.file, probes);
-            if (own && !greenProbes.includes(own)) {
+            const heldDetail = heldForRedCollocatedTest(
+              "hunk",
+              h.file,
+              probes,
+              greenProbes,
+              baseline.perFile
+            );
+            if (heldDetail) {
               const { patch: _patch, ...meta } = h;
               hunkResults.push({
                 ...meta,
                 verdict: "inconclusive",
-                detail: `this hunk's collocated test ${own} did not run green in the unmutated baseline (likely a compile or import error in the probe tree), so the remaining probes passing cannot show the hunk is uncovered`
+                detail: heldDetail
               });
               continue;
             }
@@ -14692,11 +16141,14 @@ async function runTestEfficacy(args) {
         noteDependencyFarm(revertRun.exposed);
         results.push(...revertRun.perFile);
       } catch (e) {
-        const detail = `probe could not run: ${e instanceof Error ? e.message : String(e)}`;
+        const message = e instanceof Error ? e.message : String(e);
+        const detail = `probe could not run: ${message}`;
+        const reason = e instanceof ProbeRunFailure ? e.reason : "not-run";
         results.push(
           ...probes.map((file) => ({
             file,
             verdict: "inconclusive",
+            reason,
             detail
           }))
         );
@@ -14708,7 +16160,7 @@ async function runTestEfficacy(args) {
         } catch (e) {
           removeError = e;
         }
-        if (existsSync9(probeTree)) {
+        if (existsSync11(probeTree)) {
           cleanupFailure = probeCleanupFailureDetail(
             probeTree,
             removeError,
@@ -14732,10 +16184,15 @@ async function runTestEfficacy(args) {
         h.detail = detail;
       }
     }
-    for (const r of results) {
+    for (let i = 0; i < results.length; i++) {
+      const r = results[i];
       if (r.verdict === "inert") {
-        r.verdict = "inconclusive";
-        r.detail = detail;
+        results[i] = {
+          file: r.file,
+          verdict: "inconclusive",
+          reason: "control-failed",
+          detail
+        };
       }
     }
   }
@@ -14802,8 +16259,8 @@ async function runTestEfficacy(args) {
     findings,
     cleanupFailure
   };
-  mkdirSync20(dirname17(out), { recursive: true });
-  writeFileSync20(out, JSON.stringify(result, null, 2), "utf8");
+  mkdirSync23(dirname20(out), { recursive: true });
+  writeFileSync23(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))`
   );
@@ -14880,8 +16337,8 @@ var testEfficacyCommand = {
 
 // packages/cli/src/commands/review/test-plan.ts
 init_esbuild_shims();
-import { existsSync as existsSync10, mkdirSync as mkdirSync21, readFileSync as readFileSync23, writeFileSync as writeFileSync21 } from "node:fs";
-import { dirname as dirname18, join as join17, normalize, resolve as resolve17 } from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync24, readFileSync as readFileSync26, writeFileSync as writeFileSync24 } from "node:fs";
+import { dirname as dirname21, join as join18, normalize, resolve as resolve20 } 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*$/;
@@ -15084,7 +16541,7 @@ function rulePath(text, worktree, changed) {
     };
   }
   const ignored = isGitIgnored(worktree, path3);
-  if (existsSync10(join17(worktree, path3))) {
+  if (existsSync12(join18(worktree, path3))) {
     return {
       kind: "path",
       text,
@@ -15155,7 +16612,7 @@ function ruleCommand(text, worktree, buildTest) {
   let rootScripts = [];
   try {
     const rootPkg = JSON.parse(
-      readFileSync23(join17(worktree, "package.json"), "utf8")
+      readFileSync26(join18(worktree, "package.json"), "utf8")
     );
     rootScripts = Object.keys(rootPkg.scripts ?? {});
   } catch {
@@ -15233,7 +16690,7 @@ __name(fetchPrBody, "fetchPrBody");
 function runTestPlan(args, fetchBody = fetchPrBody) {
   let plan;
   try {
-    plan = JSON.parse(readFileSync23(args.plan, "utf8"));
+    plan = JSON.parse(readFileSync26(args.plan, "utf8"));
   } catch (err) {
     throw new Error(
       `test-plan: cannot read the plan ${args.plan}: ${err.message}`
@@ -15260,7 +16717,7 @@ function runTestPlan(args, fetchBody = fetchPrBody) {
       note: "the PR description has no Test Plan section"
     };
   }
-  const worktree = resolve17(args.worktree);
+  const worktree = resolve20(args.worktree);
   const changed = new Set(
     (plan.files ?? []).map((f) => normalize(String(f.path)))
   );
@@ -15268,7 +16725,7 @@ function runTestPlan(args, fetchBody = fetchPrBody) {
   if (args.buildTest) {
     try {
       buildTest = JSON.parse(
-        readFileSync23(args.buildTest, "utf8")
+        readFileSync26(args.buildTest, "utf8")
       );
     } catch {
       buildTest = null;
@@ -15325,8 +16782,8 @@ var testPlanCommand = {
     try {
       const report = runTestPlan(args);
       if (args.out) {
-        mkdirSync21(dirname18(resolve17(args.out)), { recursive: true });
-        writeFileSync21(resolve17(args.out), JSON.stringify(report, null, 2));
+        mkdirSync24(dirname21(resolve20(args.out)), { recursive: true });
+        writeFileSync24(resolve20(args.out), JSON.stringify(report, null, 2));
       }
       writeStdoutLine(JSON.stringify(report, null, 2));
       writeStderrLine(`test-plan: ${report.note}`);
@@ -15340,8 +16797,8 @@ var testPlanCommand = {
 // packages/cli/src/commands/review/cleanup.ts
 init_esbuild_shims();
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { existsSync as existsSync11, readFileSync as readFileSync24, readdirSync as readdirSync6, rmSync as rmSync9 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync27, readdirSync as readdirSync6, rmSync as rmSync10 } from "node:fs";
+import { join as join19 } from "node:path";
 var AUTOMATION_MARKER = "<!-- qwen-";
 function isAutomationComment(body) {
   return (body ?? "").trimStart().startsWith(AUTOMATION_MARKER);
@@ -15372,7 +16829,7 @@ var OWNER_REPO_RE = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
 function readAuditWindow(target, expectedPrNumber) {
   let raw;
   try {
-    raw = readFileSync24(tmpFile(target, "fetch.json"), "utf8");
+    raw = readFileSync27(tmpFile(target, "fetch.json"), "utf8");
   } catch (err) {
     const code = err.code;
     return code === "ENOENT" ? { skip: "no fetch report" } : {
@@ -15419,7 +16876,7 @@ function readSubmitReceipt(target) {
   try {
     return new Set(
       parseReceiptIds(
-        readFileSync24(tmpFile(target, "submit-receipt.json"), "utf8")
+        readFileSync27(tmpFile(target, "submit-receipt.json"), "utf8")
       )
     );
   } catch {
@@ -15523,7 +16980,7 @@ function runCleanup(target) {
     report("probe worktree", probeWorktreePath(wt));
     report("base worktree", baseWorktreePath(wt));
     try {
-      rmSync9(`${baseWorktreePath(wt)}.lock`, { recursive: true, force: true });
+      rmSync10(`${baseWorktreePath(wt)}.lock`, { recursive: true, force: true });
     } catch (err) {
       writeStderrLine(
         `note: could not remove base lock ${baseWorktreePath(wt)}.lock: ${err.message}`
@@ -15546,7 +17003,7 @@ function runCleanup(target) {
   const prefix = tmpPrefix(target);
   let tmpEntries = [];
   try {
-    tmpEntries = existsSync11(REVIEW_TMP_DIR) ? readdirSync6(REVIEW_TMP_DIR) : [];
+    tmpEntries = existsSync13(REVIEW_TMP_DIR) ? readdirSync6(REVIEW_TMP_DIR) : [];
   } catch (err) {
     writeStderrLine(
       `Failed to read ${REVIEW_TMP_DIR}: ${err.message}`
@@ -15554,9 +17011,9 @@ function runCleanup(target) {
   }
   for (const file of tmpEntries) {
     if (!file.startsWith(prefix)) continue;
-    const full = join18(REVIEW_TMP_DIR, file);
+    const full = join19(REVIEW_TMP_DIR, file);
     try {
-      rmSync9(full, { recursive: true, force: true });
+      rmSync10(full, { recursive: true, force: true });
       writeStdoutLine(`Removed temp file: ${full}`);
       removedAny = true;
     } catch (err) {
@@ -15588,8 +17045,8 @@ var cleanupCommand = {
 // packages/cli/src/commands/review/run.ts
 init_esbuild_shims();
 import { spawn, execFileSync as execFileSync6 } from "node:child_process";
-import { readdirSync as readdirSync7, readFileSync as readFileSync25, statSync as statSync7 } from "node:fs";
-import { join as join19, resolve as resolve18 } from "node:path";
+import { readdirSync as readdirSync7, readFileSync as readFileSync28, realpathSync as realpathSync3, statSync as statSync9 } from "node:fs";
+import { dirname as dirname22, join as join20, resolve as resolve21 } from "node:path";
 var COMPOSED_PATTERN = /^qwen-review-.*composed\.json$/;
 var COMPOSED_POLL_MS = 250;
 var SIGNAL_EXIT_CODES = {
@@ -15623,10 +17080,10 @@ function newestArtifactSince(dir, pattern, startMs) {
   }
   for (const name of names) {
     if (!pattern.test(name)) continue;
-    const path3 = join19(dir, name);
+    const path3 = join20(dir, name);
     let mtime;
     try {
-      mtime = statSync7(path3).mtimeMs;
+      mtime = statSync9(path3).mtimeMs;
     } catch {
       continue;
     }
@@ -15644,7 +17101,7 @@ function exitCodeFor(completed, event, failOn) {
 __name(exitCodeFor, "exitCodeFor");
 function readComposed(path3) {
   try {
-    const parsed = JSON.parse(readFileSync25(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync28(path3, "utf8"));
     return typeof parsed.event === "string" ? parsed : null;
   } catch {
     return null;
@@ -15667,6 +17124,23 @@ function killProcessGroup(pid, signal) {
   }
 }
 __name(killProcessGroup, "killProcessGroup");
+function childEnv() {
+  const env = { ...process.env };
+  const inherited = env["QWEN_CODE_CLI"];
+  const ownEntry = process.argv[1];
+  if (!inherited || !ownEntry) {
+    return env;
+  }
+  try {
+    if (dirname22(realpathSync3(inherited)) === dirname22(realpathSync3(ownEntry))) {
+      return env;
+    }
+  } catch {
+  }
+  env["QWEN_CODE_CLI"] = "";
+  return env;
+}
+__name(childEnv, "childEnv");
 async function runReview(args) {
   const startMs = Date.now();
   const prompt = buildReviewPrompt(args);
@@ -15682,6 +17156,7 @@ async function runReview(args) {
       args.approvalMode
     ],
     {
+      env: childEnv(),
       // stdin CLOSED, not inherited: piped input would be prepended to the
       // prompt and the leading `/` would no longer be the first character —
       // the slash command would reach the model as plain text.
@@ -15693,9 +17168,9 @@ async function runReview(args) {
     }
   );
   if (!args.quiet) {
-    const writeProgress = /* @__PURE__ */ __name((chunk) => {
+    const writeProgress = /* @__PURE__ */ __name((chunk2) => {
       try {
-        process.stderr.write(chunk);
+        process.stderr.write(chunk2);
       } catch {
       }
     }, "writeProgress");
@@ -15779,8 +17254,8 @@ async function runReview(args) {
     downgraded: composed?.downgraded ?? false,
     downgradedFrom: composed?.downgradedFrom ?? null,
     remediation: composed?.remediation ?? [],
-    composedPath: composedPath ? resolve18(composedPath) : null,
-    reportPath: reportPath ? resolve18(reportPath) : null,
+    composedPath: composedPath ? resolve21(composedPath) : null,
+    reportPath: reportPath ? resolve21(reportPath) : null,
     childExitCode,
     childSignal,
     timedOut,
@@ -15794,7 +17269,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 ${resolve18(composedPath)} but could not be parsed` : "no composed verdict was produced";
+      const detail = composedPath !== null ? `a composed verdict was found at ${resolve21(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})` : ""}.`
       );
@@ -15861,9 +17336,9 @@ var runCommand = {
 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(prContextCommand).command(commentStatusCommand).command(loadRulesCommand).command(agentPromptCommand).command(buildTestCommand).command(baseTreeCommand).command(testDeltaCommand).command(extractStepCommand).command(scriptLintCommand).command(resolveAnchorsCommand).command(checkCoverageCommand).command(presubmitCommand).command(testEfficacyCommand).command(testPlanCommand).command(findingsCommand).command(composeReviewCommand).command(submitCommand).command(cleanupCommand).demandCommand(
+  builder: /* @__PURE__ */ __name((yargs) => yargs.command(runCommand).command(parseArgsCommand).command(fetchPrCommand).command(captureLocalCommand).command(planDiffCommand).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(presubmitCommand).command(testEfficacyCommand).command(testPlanCommand).command(findingsCommand).command(publishAssetsCommand).command(composeReviewCommand).command(submitCommand).command(cleanupCommand).demandCommand(
     1,
-    "Specify a subcommand: run, parse-args, fetch-pr, capture-local, plan-diff, pr-context, comment-status, load-rules, agent-prompt, build-test, base-tree, test-delta, extract-step, script-lint, resolve-anchors, check-coverage, presubmit, test-efficacy, test-plan, findings, compose-review, submit, or cleanup."
+    "Specify a subcommand: run, parse-args, fetch-pr, capture-local, plan-diff, 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, presubmit, test-efficacy, test-plan, findings, publish-assets, compose-review, submit, or cleanup."
   ).version(false), "builder"),
   handler: /* @__PURE__ */ __name(() => {
   }, "handler")
@@ -16063,10 +17538,10 @@ var updateCommand3 = {
       stdioHelpers,
       { updateEventEmitter }
     ] = await Promise.all([
-      import("./settings-LI2ORVXC.js"),
-      import("./updateCheck-7EG4BLBH.js"),
-      import("./installationInfo-2LIKCNVX.js"),
-      import("./standalone-update-E4V5V7WT.js"),
+      import("./settings-ILWAOKA4.js"),
+      import("./updateCheck-42SPCLH7.js"),
+      import("./installationInfo-IWMM6DPV.js"),
+      import("./standalone-update-Y5JB4S2K.js"),
       import("./stdioHelpers-HGIYTWAY.js"),
       import("./updateEventEmitter-5MKC7BLQ.js")
     ]);
@@ -17233,7 +18708,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-BOQJPVLB.js");
+      const { getTerminalImageRenderSupport } = await import("./terminal-image-renderer-NWC2RALG.js");
       return getTerminalImageRenderSupport();
     } : void 0,
     disabledSkillLevels: bareMode || safeMode || !Array.isArray(settings.skills?.disabledLevels) ? void 0 : settings.skills.disabledLevels.filter(isSkillLevel),
@@ -17387,6 +18862,7 @@ async function loadCliConfig(settings, argv, cwd = process.cwd(), overrideExtens
     enableAutoSkill: bareMode || safeMode ? false : settings.memory?.enableAutoSkill ?? false,
     autoSkillConfirm: bareMode || safeMode ? false : settings.memory?.autoSkillConfirm ?? true,
     memoryAgentTimeoutMinutes: settings.memory?.agentTimeoutMinutes,
+    memoryAgentMaxTurns: settings.memory?.agentMaxTurns,
     fastModel: settings.fastModel || void 0,
     webSearch: bareMode || safeMode ? void 0 : resolveWebSearchSettings(settings),
     visionModel: settings.visionModel || void 0,