@qwen-code/qwen-code 0.19.9-nightly.20260714.9dd8389eb → 0.19.10

package/chunks/{chunk-4DYYRLIE.js → chunk-CEW4HDPK.js}

@@ -3,7 +3,7 @@
 import {
   escapeAnsiCtrlCodes,
   stringWidth
-} from "./chunk-YWUK7OS7.js";
+} from "./chunk-WTSXKLG5.js";
 import {
   require_undici
 } from "./chunk-L573Z2QZ.js";
@@ -12,18 +12,18 @@ import {
 } from "./chunk-RXFQM6FQ.js";
 import {
   serveCommand
-} from "./chunk-LAM6CGP5.js";
+} from "./chunk-WDW64OW3.js";
 import {
   listCommand
-} from "./chunk-V75IOTWF.js";
+} from "./chunk-L62SEJWY.js";
 import {
   getErrorMessage as getErrorMessage2
-} from "./chunk-SUWGUGAD.js";
+} from "./chunk-65N2J6V2.js";
 import {
   collectProviderModelsForProtocol,
   getAuthTypeFromEnv,
   resolveCliGenerationConfig
-} from "./chunk-CSACSGAW.js";
+} from "./chunk-GGJII3FM.js";
 import {
   resolvePath
 } from "./chunk-FSA7ERJ2.js";
@@ -39,14 +39,14 @@ import {
   registerToolCallDispatch,
   selectFirstModel,
   sessionsPath
-} from "./chunk-GYGGUR4Q.js";
+} from "./chunk-Q5GLXH5Q.js";
 import {
   getExtensionManager,
   requestChoicePluginNonInteractive,
   requestConsentNonInteractive,
   requestConsentOrFail,
   resolveExtensionCommandScope
-} from "./chunk-6HHAADP2.js";
+} from "./chunk-AAR5SGMD.js";
 import {
   parseChannelConfig
 } from "./chunk-OATTJGPJ.js";
@@ -97,23 +97,23 @@ import {
   assembleMcpServers,
   getPendingGatedMcpServers,
   mcpCommand
-} from "./chunk-YH4J5XI3.js";
+} from "./chunk-YYPXHMWO.js";
 import {
   loadSettings
-} from "./chunk-T2L6SGQY.js";
+} from "./chunk-6GETGQWP.js";
 import {
   detectSystemLanguage,
   getCurrentLanguage,
   initializeI18n,
   resolveLanguageSetting,
   t
-} from "./chunk-SE74CIZD.js";
+} from "./chunk-RDRVMDWV.js";
 import {
   loadEnvironment
-} from "./chunk-WN4D7YCI.js";
+} from "./chunk-5EBKKSBX.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-X7EBAABW.js";
+} from "./chunk-4YWLED2A.js";
 import {
   require_strip_json_comments
 } from "./chunk-ALGGS7UH.js";
@@ -127,7 +127,7 @@ import {
 } from "./chunk-XFSFZCM5.js";
 import {
   getCliVersion
-} from "./chunk-UI3W56WF.js";
+} from "./chunk-YU56QGXX.js";
 import {
   getPackageJson
 } from "./chunk-VJNBRRZG.js";
@@ -146,6 +146,7 @@ import {
   getScopedEnvContents,
   ideContextStore,
   isBareMode,
+  isExtensionCommittedWithWarningsError,
   isSafeModeEnv,
   isToolEnabled,
   loadServerHierarchicalMemory,
@@ -158,7 +159,7 @@ import {
   sessionIdContext,
   unquoteCStylePath,
   updateSetting
-} from "./chunk-SSFDPGFN.js";
+} from "./chunk-K7CRWKOE.js";
 import {
   nextFireTime,
   parseCron
@@ -167,7 +168,7 @@ import {
   getAllGeminiMdFilenames,
   resolveTelemetrySettings,
   setGeminiMdFilename
-} from "./chunk-T7FSRWQ5.js";
+} from "./chunk-P6LART6G.js";
 import {
   DEFAULT_QWEN_EMBEDDING_MODEL
 } from "./chunk-CARU2RR2.js";
@@ -817,6 +818,8 @@ function normalizeScope(scope) {
 }
 __name(normalizeScope, "normalizeScope");
 async function handleInstall(args) {
+  const scope = normalizeScope(args.scope);
+  let extensionManager;
   try {
     const installMetadata = await parseInstallSource(args.source);
     if (installMetadata.type !== "git" && installMetadata.type !== "github-release" && installMetadata.type !== "npm" && installMetadata.type !== "archive-url") {
@@ -843,7 +846,7 @@ async function handleInstall(args) {
     }
     const requestConsent = args.consent ? () => Promise.resolve() : requestConsentOrFail.bind(null, requestConsentNonInteractive);
     const workspaceDir = process.cwd();
-    const extensionManager = new ExtensionManager({
+    extensionManager = new ExtensionManager({
       workspaceDir,
       locale: getCurrentLanguage(),
       isWorkspaceTrusted: isWorkspaceTrusted(loadSettings(workspaceDir).merged).isTrusted ?? true,
@@ -858,35 +861,20 @@ async function handleInstall(args) {
         autoUpdate: args.autoUpdate,
         allowPreRelease: args.allowPreRelease
       },
-      requestConsent
+      requestConsent,
+      void 0,
+      workspaceDir,
+      void 0,
+      scope === "project" ? { scope: "workspace", workspacePath: workspaceDir } : { scope: "user" }
     );
-    const scope = normalizeScope(args.scope);
     if (args.scope) {
-      if (scope === "project") {
-        await extensionManager.disableExtension(
-          extension.name,
-          "User" /* User */
+      try {
+        extensionManager.setExtensionScope(extension.name, scope);
+      } catch (scopeError) {
+        writeStderrLine(
+          `Warning: Extension installed, but failed to save scope preference: ${getErrorMessage2(scopeError)}`
         );
-        try {
-          await extensionManager.enableExtension(
-            extension.name,
-            "Workspace" /* Workspace */
-          );
-        } catch (enableError) {
-          try {
-            await extensionManager.enableExtension(
-              extension.name,
-              "User" /* User */
-            );
-          } catch (rollbackError) {
-            writeStderrLine(
-              `Warning: failed to roll back the scope change for "${extension.name}"; it may be disabled at all scopes: ${getErrorMessage2(rollbackError)}`
-            );
-          }
-          throw enableError;
-        }
       }
-      extensionManager.setExtensionScope(extension.name, scope);
     }
     writeStdoutLine(
       scope === "project" ? t(
@@ -897,6 +885,19 @@ async function handleInstall(args) {
       })
     );
   } catch (error) {
+    if (isExtensionCommittedWithWarningsError(error)) {
+      if (args.scope && extensionManager) {
+        try {
+          extensionManager.setExtensionScope(error.identity.name, scope);
+        } catch (scopeError) {
+          writeStderrLine(
+            `Warning: Extension installed, but failed to save scope preference: ${getErrorMessage2(scopeError)}`
+          );
+        }
+      }
+      writeStderrLine(`Warning: ${getErrorMessage2(error)}`);
+      return;
+    }
     writeStderrLine(getErrorMessage2(error));
     process.exit(1);
   }
@@ -971,10 +972,13 @@ async function handleUninstall(args) {
       isWorkspaceTrusted: isWorkspaceTrusted(loadSettings(workspaceDir).merged).isTrusted ?? true
     });
     await extensionManager.refreshCache();
-    await extensionManager.uninstallExtension(args.name, false);
+    const result = await extensionManager.uninstallExtension(args.name, false);
     writeStdoutLine(
       t('Extension "{{name}}" successfully uninstalled.', { name: args.name })
     );
+    for (const warning of result.warnings ?? []) {
+      writeStderrLine(`${warning.code}: ${warning.error}`);
+    }
   } catch (error) {
     writeStderrLine(getErrorMessage2(error));
     process.exit(1);
@@ -1014,6 +1018,13 @@ var updateOutput = /* @__PURE__ */ __name((info) => t(
     newVersion: info.updatedVersion
   }
 ), "updateOutput");
+var updateWarningOutput = /* @__PURE__ */ __name((info) => (info.warnings ?? []).map(
+  (warning) => t('Extension "{{name}}" updated with warning {{code}}: {{error}}', {
+    name: info.name,
+    code: warning.code,
+    error: warning.error
+  })
+).join("\n"), "updateWarningOutput");
 async function handleUpdate(args) {
   const extensionManager = await getExtensionManager();
   const extensions = extensionManager.getLoadedExtensions();
@@ -1069,6 +1080,8 @@ async function handleUpdate(args) {
           t('Extension "{{name}}" is already up to date.', { name: args.name })
         );
       }
+      const warnings = updateWarningOutput(updatedExtensionInfo);
+      if (warnings) writeStderrLine(warnings);
     } catch (error) {
       writeStderrLine(getErrorMessage2(error));
     }
@@ -1098,6 +1111,8 @@ async function handleUpdate(args) {
         return;
       }
       writeStdoutLine(updateInfos.map((info) => updateOutput(info)).join("\n"));
+      const warnings = updateInfos.map((info) => updateWarningOutput(info)).filter(Boolean).join("\n");
+      if (warnings) writeStderrLine(warnings);
     } catch (error) {
       writeStderrLine(getErrorMessage2(error));
     }
@@ -1137,13 +1152,16 @@ async function handleDisable(args) {
   const extensionManager = await getExtensionManager();
   try {
     const scope = resolveExtensionCommandScope(args.scope);
-    await extensionManager.disableExtension(args.name, scope);
+    const result = await extensionManager.disableExtension(args.name, scope);
     writeStdoutLine(
       t('Extension "{{name}}" successfully disabled for scope "{{scope}}".', {
         name: args.name,
         scope: args.scope || "User" /* User */
       })
     );
+    for (const warning of result.warnings ?? []) {
+      writeStderrLine(`${warning.code}: ${warning.error}`);
+    }
   } catch (error) {
     writeStderrLine(getErrorMessage2(error));
     process.exit(1);
@@ -1178,7 +1196,7 @@ async function handleEnable(args) {
   const extensionManager = await getExtensionManager();
   try {
     const scope = resolveExtensionCommandScope(args.scope);
-    await extensionManager.enableExtension(args.name, scope);
+    const result = await extensionManager.enableExtension(args.name, scope);
     if (args.scope) {
       writeStdoutLine(
         t('Extension "{{name}}" successfully enabled for scope "{{scope}}".', {
@@ -1193,6 +1211,9 @@ async function handleEnable(args) {
         })
       );
     }
+    for (const warning of result.warnings ?? []) {
+      writeStderrLine(`${warning.code}: ${warning.error}`);
+    }
   } catch (error) {
     throw new FatalConfigError(getErrorMessage(error));
   }
@@ -1244,6 +1265,10 @@ async function handleLink(args) {
       })
     );
   } catch (error) {
+    if (isExtensionCommittedWithWarningsError(error)) {
+      writeStderrLine(`Warning: ${getErrorMessage2(error)}`);
+      return;
+    }
     writeStderrLine(getErrorMessage2(error));
     process.exit(1);
   }
@@ -2229,7 +2254,7 @@ var stopCommand = {
     if (argv["daemon-url"]) {
       const token = argv.token ?? process.env[QWEN_SERVER_TOKEN_ENV] ?? process.env[QWEN_DAEMON_TOKEN_ENV];
       try {
-        const sdk = await import("./daemon-CEZ27OH4.js");
+        const sdk = await import("./daemon-RNGFPMAB.js");
         const client = new sdk.DaemonClient({
           baseUrl: argv["daemon-url"],
           ...token ? { token } : {}
@@ -2315,7 +2340,7 @@ var statusCommand = {
     if (argv["daemon-url"]) {
       const token = argv.token ?? process.env[QWEN_SERVER_TOKEN_ENV] ?? process.env[QWEN_DAEMON_TOKEN_ENV];
       try {
-        const sdk = await import("./daemon-CEZ27OH4.js");
+        const sdk = await import("./daemon-RNGFPMAB.js");
         const client = new sdk.DaemonClient({
           baseUrl: argv["daemon-url"],
           ...token ? { token } : {}
@@ -2420,7 +2445,7 @@ var reloadCommand = {
     const token = resolveToken(argv.token);
     let sdk;
     try {
-      sdk = await import("./daemon-CEZ27OH4.js");
+      sdk = await import("./daemon-RNGFPMAB.js");
     } catch (err) {
       writeStderrLine(
         `[Channel] Failed to load daemon SDK: ${err instanceof Error ? err.message : String(err)}`
@@ -2491,7 +2516,7 @@ var setCommand2 = {
     const selection = names[0] === "all" ? { mode: "all" } : { mode: "names", names };
     let sdk;
     try {
-      sdk = await import("./daemon-CEZ27OH4.js");
+      sdk = await import("./daemon-RNGFPMAB.js");
     } catch (error) {
       writeStderrLine(
         `[Channel] Failed to load daemon SDK: ${error instanceof Error ? error.message : String(error)}`
@@ -2591,7 +2616,7 @@ function createDaemonChannelBridgeFacade(bridge, opts) {
 }
 __name(createDaemonChannelBridgeFacade, "createDaemonChannelBridgeFacade");
 async function loadDaemonSdk() {
-  return await import("./daemon-CEZ27OH4.js");
+  return await import("./daemon-RNGFPMAB.js");
 }
 __name(loadDaemonSdk, "loadDaemonSdk");
 function selectedChannelNames(channelsConfig, selection) {
@@ -2672,7 +2697,7 @@ async function runChannelDaemonWorker(opts) {
   );
   const requestedWorkspace = canonicalizeWorkspace(opts.workspace);
   let daemonWorkspace;
-  if (capabilities.workspaces && capabilities.workspaces.length > 0) {
+  if (capabilities.workspaces && capabilities.workspaces.length > 1) {
     const match = capabilities.workspaces.find(
       (workspace) => canonicalizeWorkspace(workspace.cwd) === requestedWorkspace
     );
@@ -3647,8 +3672,221 @@ var parseArgsCommand = {
 
 // packages/cli/src/commands/review/compose-review.ts
 init_esbuild_shims();
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname2 } from "node:path";
+
+// packages/cli/src/commands/review/lib/coverage.ts
+init_esbuild_shims();
+import { readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
+
+// packages/cli/src/commands/review/lib/transcripts.ts
+init_esbuild_shims();
+import { readFileSync as readFileSync3, readdirSync, statSync } from "node:fs";
+import { join as join3 } from "node:path";
+var TranscriptsUnavailableError = class extends Error {
+  static {
+    __name(this, "TranscriptsUnavailableError");
+  }
+};
+function transcriptDir(env = process.env) {
+  const projectDir = env["QWEN_CODE_PROJECT_DIR"]?.trim();
+  const sessionId = env["QWEN_CODE_SESSION_ID"]?.trim();
+  if (!projectDir || !sessionId) {
+    throw new TranscriptsUnavailableError(
+      "the CLI did not export QWEN_CODE_PROJECT_DIR / QWEN_CODE_SESSION_ID, so this run cannot find the harness's record of what its agents did"
+    );
+  }
+  return join3(projectDir, "subagents", sessionId);
+}
+__name(transcriptDir, "transcriptDir");
+function textOf(rec) {
+  const msg = rec["message"];
+  const parts = Array.isArray(msg?.parts) ? msg.parts : [];
+  return parts.map((p) => p.text).filter((t2) => typeof t2 === "string").join("");
+}
+__name(textOf, "textOf");
+function isErrorResponse(rec) {
+  const msg = rec["message"];
+  const parts = Array.isArray(msg?.parts) ? msg.parts : [];
+  for (const part of parts) {
+    const fr = part.functionResponse;
+    if (!fr) continue;
+    const resp = fr.response;
+    if (resp && resp["error"] !== void 0 && resp["error"] !== null) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(isErrorResponse, "isErrorResponse");
+function parseTranscript(file) {
+  let raw;
+  try {
+    raw = readFileSync3(file, "utf8");
+  } catch {
+    return null;
+  }
+  const lines = raw.split("\n").filter((l) => l.trim());
+  if (lines.length === 0) return null;
+  let agentId = "";
+  let agentName = "";
+  let launchPrompt = "";
+  let finalText = "";
+  let successfulToolCalls = 0;
+  const pendingCalls = [];
+  for (const line of lines) {
+    let rec;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!agentId && typeof rec["agentId"] === "string")
+      agentId = rec["agentId"];
+    if (!agentName && typeof rec["agentName"] === "string") {
+      agentName = rec["agentName"];
+    }
+    const type = rec["type"];
+    if (!launchPrompt && type === "user") launchPrompt = textOf(rec);
+    const msg = rec["message"];
+    const parts = Array.isArray(msg?.parts) ? msg.parts : [];
+    const hasCall = parts.some(
+      (p) => p.functionCall
+    );
+    const hasResponse = parts.some(
+      (p) => p.functionResponse
+    );
+    if (hasCall) {
+      pendingCalls.push("call");
+    }
+    if (hasResponse) {
+      if (!isErrorResponse(rec) && pendingCalls.length > 0) {
+        successfulToolCalls++;
+      }
+      pendingCalls.pop();
+    }
+    if (type === "assistant") {
+      const t2 = textOf(rec);
+      if (t2) finalText = t2;
+    }
+  }
+  if (!agentId) return null;
+  let mtimeMs = 0;
+  try {
+    mtimeMs = statSync(file).mtimeMs;
+  } catch {
+  }
+  return {
+    agentId,
+    agentName,
+    launchPrompt,
+    successfulToolCalls,
+    finalText,
+    mtimeMs
+  };
+}
+__name(parseTranscript, "parseTranscript");
+function readTranscripts(since, env = process.env) {
+  const dir = transcriptDir(env);
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch (err) {
+    throw new TranscriptsUnavailableError(
+      `no subagent transcripts at ${dir} (${err.message}). The harness writes one per agent; if there are none, either no agents ran or the harness could not write them.`
+    );
+  }
+  const out = [];
+  for (const name of names) {
+    if (!name.endsWith(".jsonl")) continue;
+    const rec = parseTranscript(join3(dir, name));
+    if (!rec) continue;
+    if (since !== void 0 && rec.mtimeMs < since) continue;
+    out.push(rec);
+  }
+  return out;
+}
+__name(readTranscripts, "readTranscripts");
+function wasGivenTheDiff(rec, diffPath) {
+  const p = rec.launchPrompt;
+  if (!p) return false;
+  return p.includes(diffPath);
+}
+__name(wasGivenTheDiff, "wasGivenTheDiff");
+
+// packages/cli/src/commands/review/lib/coverage.ts
+function readPlan(path3) {
+  const plan = JSON.parse(readFileSync4(path3, "utf8"));
+  if (typeof plan?.diffPathAbsolute !== "string" || !plan.diffPathAbsolute) {
+    throw new Error(`coverage: ${path3} has no diffPathAbsolute`);
+  }
+  if (!Array.isArray(plan.chunks) || plan.chunks.length === 0) {
+    throw new Error(`coverage: ${path3} has no chunks[]`);
+  }
+  const ids = plan.chunks.map((c) => c?.id);
+  if (ids.some((id) => !Number.isSafeInteger(id) || id < 1)) {
+    throw new Error(
+      `coverage: ${path3} has a chunk with no positive integer id`
+    );
+  }
+  if (new Set(ids).size !== ids.length) {
+    throw new Error(`coverage: ${path3} has duplicate chunk ids`);
+  }
+  return { plan, mtimeMs: statSync2(path3).mtimeMs };
+}
+__name(readPlan, "readPlan");
+var CHUNK_RE = /\bchunk\s+(\d+)\s+of\s+\d+\b/i;
+function assignedChunk(rec) {
+  const m = CHUNK_RE.exec(rec.launchPrompt);
+  return m ? Number(m[1]) : null;
+}
+__name(assignedChunk, "assignedChunk");
+var UNCOVERABLE_RE = /^\s*Uncoverable:\s*chunk\s+(\d+)\b/im;
+function coverageFromTranscripts(planPath, env = process.env) {
+  const { plan, mtimeMs } = readPlan(planPath);
+  const records = readTranscripts(mtimeMs, env);
+  const blindAgents = [];
+  const idleAgents = [];
+  const covered = /* @__PURE__ */ new Set();
+  const uncoverable = /* @__PURE__ */ new Set();
+  for (const rec of records) {
+    const chunk = assignedChunk(rec);
+    const label = chunk !== null ? `chunk ${chunk}` : rec.agentName || rec.agentId;
+    if (chunk !== null && !wasGivenTheDiff(rec, plan.diffPathAbsolute)) {
+      blindAgents.push(label);
+      continue;
+    }
+    if (rec.successfulToolCalls === 0) {
+      idleAgents.push(label);
+      continue;
+    }
+    const u = UNCOVERABLE_RE.exec(rec.finalText);
+    if (u && chunk !== null && Number(u[1]) === chunk) {
+      uncoverable.add(chunk);
+      continue;
+    }
+    if (chunk !== null) covered.add(chunk);
+  }
+  const planned = plan.chunks.map((c) => c.id);
+  const missingChunks = planned.filter(
+    (id) => !covered.has(id) && !uncoverable.has(id)
+  );
+  return {
+    ok: blindAgents.length === 0 && idleAgents.length === 0 && // An uncoverable chunk is a disclosed gap, not coverage: a diff with a line
+    // no read can reach was not reviewed, and the verdict may not be Approve on
+    // its strength. `compose-review` already caps on it; the report must agree.
+    uncoverable.size === 0 && missingChunks.length === 0,
+    agents: records.length,
+    blindAgents,
+    idleAgents,
+    missingChunks,
+    uncoverableChunks: [...uncoverable].sort((a, b) => a - b),
+    coveredChunks: [...covered].sort((a, b) => a - b)
+  };
+}
+__name(coverageFromTranscripts, "coverageFromTranscripts");
+
+// packages/cli/src/commands/review/compose-review.ts
 var CRITICAL_MARKER = "**[Critical]**";
 function withMarker(line) {
   return line.startsWith(CRITICAL_MARKER) ? line : `${CRITICAL_MARKER} ${line}`;
@@ -3671,19 +3909,9 @@ function toStringList(value, field) {
       `compose-review: ${field} must be an array of strings, got ${JSON.stringify(value)}`
     );
   }
-  return value;
+  return [...value];
 }
 __name(toStringList, "toStringList");
-function toNumberList(value, field) {
-  if (value === void 0 || value === null) return [];
-  if (!Array.isArray(value) || value.some((v) => !Number.isSafeInteger(v) || v < 1)) {
-    throw new TypeError(
-      `compose-review: ${field} must be an array of positive whole numbers, got ${JSON.stringify(value)}`
-    );
-  }
-  return value;
-}
-__name(toNumberList, "toNumberList");
 function toBool(value, field) {
   if (value === void 0 || value === null) return false;
   if (typeof value !== "boolean") {
@@ -3718,43 +3946,37 @@ function composeReview(input) {
     "unreviewedDimensions"
   );
   const missingReceipts = [];
-  const coverageRaw = input.coverage ?? {};
-  if (typeof coverageRaw !== "object" || Array.isArray(coverageRaw)) {
-    throw new TypeError(
-      `compose-review: coverage must be an object, got ${JSON.stringify(coverageRaw)}`
-    );
-  }
-  const cov = coverageRaw;
-  const covProvided = input.coverage !== void 0 && input.coverage !== null;
-  if (!covProvided) {
+  if (!input.planPath) {
     unreviewed.push(
-      "coverage \u2014 no `check-coverage` report was supplied, so this run cannot show that any of the diff was read"
+      "coverage \u2014 no plan was given, so this run cannot show that any of the diff was read"
     );
-  }
-  if (covProvided) {
-    if (cov["ok"] !== true) {
+  } else {
+    try {
+      const cov = coverageFromTranscripts(input.planPath, input.env);
+      for (const id of cov.missingChunks) missingReceipts.push(id);
+      for (const id of cov.uncoverableChunks) {
+        const prefix = `chunk ${id}`;
+        const already = uncoverable.some(
+          (e) => e === prefix || e.startsWith(`${prefix} `)
+        );
+        if (!already) uncoverable.push(prefix);
+      }
+      for (const label of cov.idleAgents) {
+        unreviewed.push(
+          `${label} \u2014 the agent made no tool call: it read nothing`
+        );
+      }
+      for (const label of cov.blindAgents) {
+        unreviewed.push(
+          `${label} \u2014 launched with a prompt that never named the diff file, so it could not have read it (build the prompt with \`qwen review agent-prompt\`)`
+        );
+      }
+    } catch (err) {
+      const why = err instanceof TranscriptsUnavailableError ? `could not read the agents' transcripts (${err.message})` : `the plan could not be used (${err.message})`;
       unreviewed.push(
-        "coverage \u2014 the `check-coverage` report says the diff was not covered"
+        `coverage \u2014 ${why}, so this run cannot show that any of the diff was read`
       );
     }
-    for (const id of toNumberList(
-      cov["missingChunks"],
-      "coverage.missingChunks"
-    )) {
-      missingReceipts.push(id);
-    }
-    for (const id of toNumberList(
-      cov["uncoverableChunks"],
-      "coverage.uncoverableChunks"
-    )) {
-      uncoverable.push(`chunk ${id}`);
-    }
-    for (const label of toStringList(
-      cov["whiffedAgents"],
-      "coverage.whiffedAgents"
-    )) {
-      unreviewed.push(`${label} \u2014 the agent returned nothing substantive`);
-    }
   }
   const contextUnavailable = toBool(
     input.contextUnavailable,
@@ -3909,8 +4131,10 @@ var composeReviewCommand = {
   }), "builder"),
   handler: /* @__PURE__ */ __name((argv) => {
     const { input, out } = argv;
-    const raw = readFileSync3(input ?? 0, "utf8");
-    const result = composeReview(JSON.parse(raw));
+    const raw = readFileSync5(input ?? 0, "utf8");
+    const parsed = JSON.parse(raw);
+    delete parsed.env;
+    const result = composeReview(parsed);
     const json = JSON.stringify(result, null, 2);
     if (out) {
       mkdirSync2(dirname2(out), { recursive: true });
@@ -3924,7 +4148,7 @@ var composeReviewCommand = {
 init_esbuild_shims();
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname3, resolve } from "node:path";
+import { dirname as dirname3, resolve as resolve2 } from "node:path";
 
 // packages/cli/src/commands/review/lib/gh.ts
 init_esbuild_shims();
@@ -4014,7 +4238,7 @@ __name(ensureAuthenticated, "ensureAuthenticated");
 // packages/cli/src/commands/review/lib/git.ts
 init_esbuild_shims();
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync2, rmSync } from "node:fs";
 var GIT_TIMEOUT_MS = 12e4;
 function gitOpts() {
   return {
@@ -4047,13 +4271,31 @@ function refExists(ref) {
   return gitOpt("rev-parse", "--verify", "--quiet", ref) !== null;
 }
 __name(refExists, "refExists");
+function worktreeReleaseResult(existed, stillThere, removeError) {
+  const freed = existed && !stillThere;
+  if (!existed || freed) {
+    return { existed, freed, reason: void 0 };
+  }
+  return {
+    existed,
+    freed,
+    reason: removeError ? removeError instanceof Error ? removeError.message : String(removeError) : "the path is still there after `git worktree remove --force` and `rm -rf`"
+  };
+}
+__name(worktreeReleaseResult, "worktreeReleaseResult");
 function releaseWorktree(worktreePath2) {
   const existed = existsSync2(worktreePath2);
+  let removeError;
   if (existed) {
     gitOpt("worktree", "remove", worktreePath2, "--force");
+    try {
+      rmSync(worktreePath2, { recursive: true, force: true });
+    } catch (e) {
+      removeError = e;
+    }
   }
   gitOpt("worktree", "prune");
-  return existed;
+  return worktreeReleaseResult(existed, existsSync2(worktreePath2), removeError);
 }
 __name(releaseWorktree, "releaseWorktree");
 function gitRaw(...args) {
@@ -4098,14 +4340,18 @@ var LITERAL_PATHSPECS = "--literal-pathspecs";
 
 // packages/cli/src/commands/review/lib/paths.ts
 init_esbuild_shims();
-import { join as join3 } from "node:path";
-var REVIEW_TMP_DIR = join3(".qwen", "tmp");
-var REVIEWS_DIR = join3(".qwen", "reviews");
-var REVIEW_CACHE_DIR = join3(".qwen", "review-cache");
+import { join as join4, resolve } from "node:path";
+var REVIEW_TMP_DIR = join4(".qwen", "tmp");
+var REVIEWS_DIR = join4(".qwen", "reviews");
+var REVIEW_CACHE_DIR = join4(".qwen", "review-cache");
 function worktreePath(prNumber) {
-  return join3(REVIEW_TMP_DIR, `review-pr-${prNumber}`);
+  return join4(REVIEW_TMP_DIR, `review-pr-${prNumber}`);
 }
 __name(worktreePath, "worktreePath");
+function probeWorktreePath(worktree) {
+  return `${resolve(worktree)}-probe`;
+}
+__name(probeWorktreePath, "probeWorktreePath");
 function reviewBranch(prNumber) {
   return `qwen-review/pr-${prNumber}`;
 }
@@ -4116,7 +4362,7 @@ function safeTarget(target) {
 }
 __name(safeTarget, "safeTarget");
 function tmpFile(target, suffix) {
-  return join3(REVIEW_TMP_DIR, `qwen-review-${safeTarget(target)}-${suffix}`);
+  return join4(REVIEW_TMP_DIR, `qwen-review-${safeTarget(target)}-${suffix}`);
 }
 __name(tmpFile, "tmpFile");
 function tmpPrefix(target) {
@@ -4492,7 +4738,7 @@ __name(chunksCoverDiff, "chunksCoverDiff");
 
 // packages/cli/src/commands/review/lib/report.ts
 init_esbuild_shims();
-import { statSync } from "node:fs";
+import { statSync as statSync3 } from "node:fs";
 
 // packages/cli/src/commands/review/lib/heavy.ts
 init_esbuild_shims();
@@ -4555,7 +4801,7 @@ __name(buildPlanReport, "buildPlanReport");
 function warnOnReportSize(path3, cap) {
   let size = 0;
   try {
-    size = statSync(path3).size;
+    size = statSync3(path3).size;
   } catch {
     return;
   }
@@ -4707,7 +4953,7 @@ async function runFetchPr(args) {
       writeFileSync3(diffRel, buf);
       diffText = buf.toString("utf8");
       diffPath = diffRel;
-      diffPathAbsolute = resolve(diffRel);
+      diffPathAbsolute = resolve2(diffRel);
     } catch (err) {
       writeStderrLine(`Failed to capture diff: ${err.message}`);
     }
@@ -4802,12 +5048,12 @@ var fetchPrCommand = {
 // packages/cli/src/commands/review/capture-local.ts
 init_esbuild_shims();
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname4, resolve as resolve3 } from "node:path";
+import { dirname as dirname4, resolve as resolve4 } from "node:path";
 
 // packages/cli/src/commands/review/lib/local-diff.ts
 init_esbuild_shims();
-import { lstatSync, statSync as statSync2, realpathSync } from "node:fs";
-import { join as join4, relative, resolve as resolve2, isAbsolute, sep } from "node:path";
+import { lstatSync, statSync as statSync4, realpathSync } from "node:fs";
+import { join as join5, relative, resolve as resolve3, isAbsolute, sep } from "node:path";
 var MAX_UNTRACKED_BYTES = 1e6;
 var MAX_UNTRACKED_FILES = 500;
 var MAX_UNTRACKED_TOTAL_BYTES = 1e7;
@@ -4828,7 +5074,7 @@ function describeUndiffable(abs, st) {
   }
   if (st.isSymbolicLink()) {
     try {
-      return statSync2(abs).isDirectory() ? "is a symlink to a directory \u2014 git cannot diff it as a file" : null;
+      return statSync4(abs).isDirectory() ? "is a symlink to a directory \u2014 git cannot diff it as a file" : null;
     } catch {
       return null;
     }
@@ -4837,7 +5083,7 @@ function describeUndiffable(abs, st) {
 }
 __name(describeUndiffable, "describeUndiffable");
 function toRepoPathspec(repoRoot, file) {
-  let abs = resolve2(process.cwd(), file);
+  let abs = resolve3(process.cwd(), file);
   try {
     abs = realpathSync(abs);
   } catch {
@@ -4933,7 +5179,7 @@ function captureLocalDiff(opts) {
       for (const path3 of candidates) {
         let bytes;
         try {
-          const abs = join4(repoRoot, path3);
+          const abs = join5(repoRoot, path3);
           const st = lstatSync(abs);
           const kind = describeUndiffable(abs, st);
           if (kind) {
@@ -5026,13 +5272,13 @@ function runCaptureLocal(args) {
   });
   const diffText = capture.diff.toString("utf8");
   mkdirSync4(REVIEW_TMP_DIR, { recursive: true });
-  mkdirSync4(dirname4(resolve3(out)), { recursive: true });
+  mkdirSync4(dirname4(resolve4(out)), { recursive: true });
   const diffPath = tmpFile(target, "diff.txt");
   writeFileSync4(diffPath, capture.diff);
   const plan = buildDiffPlan(diffText);
   const result = {
     diffPath,
-    diffPathAbsolute: resolve3(diffPath),
+    diffPathAbsolute: resolve4(diffPath),
     // No ref to `git show` a pre-change file out of, so per-file line counts and
     // heaviness are unavailable — same as `plan-diff`. Chunk coverage, which is
     // what the topology needs, is not.
@@ -5094,13 +5340,13 @@ var captureLocalCommand = {
 
 // packages/cli/src/commands/review/plan-diff.ts
 init_esbuild_shims();
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "node:fs";
-import { resolve as resolve4 } from "node:path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "node:fs";
+import { resolve as resolve5 } from "node:path";
 function runPlanDiff(args) {
   const { diff_path: diffPath, out } = args;
   let diffText;
   try {
-    diffText = readFileSync4(diffPath, "utf8");
+    diffText = readFileSync6(diffPath, "utf8");
   } catch (err) {
     throw new Error(
       `Cannot read diff file ${diffPath}: ${err.message}`
@@ -5109,7 +5355,7 @@ function runPlanDiff(args) {
   const plan = buildDiffPlan(diffText, args.maxChunkLines);
   const result = {
     diffPath,
-    diffPathAbsolute: resolve4(diffPath),
+    diffPathAbsolute: resolve5(diffPath),
     // No `git show` is possible here — there is no ref to resolve a path
     // against — so per-file line counts and heaviness are unavailable. Chunk
     // coverage, which is what Step 3B needs, is not.
@@ -5747,7 +5993,7 @@ var loadRulesCommand = {
 
 // packages/cli/src/commands/review/presubmit.ts
 init_esbuild_shims();
-import { writeFileSync as writeFileSync8, readFileSync as readFileSync5 } from "node:fs";
+import { writeFileSync as writeFileSync8, readFileSync as readFileSync7 } from "node:fs";
 var FAIL_CONCLUSIONS = /* @__PURE__ */ new Set([
   "failure",
   "cancelled",
@@ -5904,7 +6150,7 @@ async function runPresubmit(args) {
   }
   let newFindings = [];
   if (newFindingsPath) {
-    newFindings = JSON.parse(readFileSync5(newFindingsPath, "utf8"));
+    newFindings = JSON.parse(readFileSync7(newFindingsPath, "utf8"));
   }
   const newFindingKeys = new Set(newFindings.map((f) => `${f.path}:${f.line}`));
   const buckets = classifyExistingComments(
@@ -5994,8 +6240,8 @@ var presubmitCommand = {
 
 // packages/cli/src/commands/review/resolve-anchors.ts
 init_esbuild_shims();
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8 } from "node:fs";
-import { dirname as dirname7, resolve as resolve5 } from "node:path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8 } from "node:fs";
+import { dirname as dirname7, resolve as resolve6 } from "node:path";
 
 // packages/cli/src/commands/review/lib/anchors.ts
 init_esbuild_shims();
@@ -6219,7 +6465,7 @@ __name(validateRequests, "validateRequests");
 function runResolveAnchors(args) {
   let diffText;
   try {
-    diffText = readFileSync6(args.diff, "utf8");
+    diffText = readFileSync8(args.diff, "utf8");
   } catch (err) {
     throw new Error(
       `Cannot read diff file ${args.diff}: ${err.message}`
@@ -6227,7 +6473,7 @@ function runResolveAnchors(args) {
   }
   let rawText;
   try {
-    rawText = readFileSync6(args.input, "utf8");
+    rawText = readFileSync8(args.input, "utf8");
   } catch (err) {
     throw new Error(
       `Cannot read findings file ${args.input}: ${err.message}`
@@ -6258,7 +6504,7 @@ function runResolveAnchors(args) {
       loose: resolved.filter((r) => r.tier?.startsWith("loose")).length
     }
   };
-  mkdirSync8(dirname7(resolve5(args.out)), { recursive: true });
+  mkdirSync8(dirname7(resolve6(args.out)), { recursive: true });
   writeFileSync9(args.out, JSON.stringify(report, null, 2), "utf8");
   writeStdoutLine(`Wrote resolved anchors to ${args.out}`);
   const s = report.stats;
@@ -6306,188 +6552,228 @@ var resolveAnchorsCommand = {
 
 // packages/cli/src/commands/review/check-coverage.ts
 init_esbuild_shims();
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync10, mkdirSync as mkdirSync9 } from "node:fs";
-import { dirname as dirname8, resolve as resolve6 } from "node:path";
-var WHIFF_CHARS = 40;
-var BARE_RE = /^\s*no issues found[.!]?\s*$/i;
-var AGENT_RE = /^===\s*AGENT:\s*(.+?)\s*===\s*$/;
-var OWN_CHUNK_RE = /\bchunk\s+(\d+)\b/i;
-function ownChunk(label) {
-  const m = OWN_CHUNK_RE.exec(label);
-  return m ? Number(m[1]) : null;
-}
-__name(ownChunk, "ownChunk");
-function stripReceipts(body) {
-  return body.split("\n").filter((l) => !/^\s*(Covered|Uncoverable):/i.test(l)).join("\n").trim();
-}
-__name(stripReceipts, "stripReceipts");
-var COVERED_RE = /^\s*Covered:\s*chunk\s+(\d+)\b/im;
-var UNCOVERABLE_RE = /^\s*Uncoverable:\s*chunk\s+(\d+)\b/im;
-function splitReturns(text) {
-  const out = [];
-  let cur = null;
-  for (const line of text.split("\n")) {
-    const m = AGENT_RE.exec(line);
-    if (m) {
-      if (cur) out.push(cur);
-      cur = { label: sanitiseLabel(m[1]), body: "" };
-      continue;
-    }
-    if (cur) cur.body += line + "\n";
-  }
-  if (cur) out.push(cur);
-  return out;
-}
-__name(splitReturns, "splitReturns");
-function sanitiseLabel(raw) {
-  const CONTROL = /[\u0000-\u001f\u007f]/g;
-  const clean = raw.replace(CONTROL, "?").slice(0, 80);
-  return clean.trim() || "(unnamed agent)";
-}
-__name(sanitiseLabel, "sanitiseLabel");
-function checkCoverage(plannedChunks, returns, opts = {
-  topology: "territory"
-}) {
-  const territory = opts.topology === "territory";
-  const covered = /* @__PURE__ */ new Set();
-  const uncoverable = /* @__PURE__ */ new Set();
-  const whiffed = [];
-  const roster = opts.expected && opts.expected.length > 0 ? new Set(opts.expected.map((l) => l.toLowerCase().trim())) : null;
-  for (const r of returns) {
-    const body = r.body.trim();
-    const known = roster === null || roster.has(r.label.toLowerCase().trim());
-    const substantive = body.length >= WHIFF_CHARS && !BARE_RE.test(stripReceipts(body));
-    const own = ownChunk(r.label);
-    const c = COVERED_RE.exec(body);
-    const u = UNCOVERABLE_RE.exec(body);
-    if (own !== null && known) {
-      if (c && Number(c[1]) === own) covered.add(own);
-      if (u && Number(u[1]) === own) uncoverable.add(own);
-    }
-    if (known && !substantive) whiffed.push(r.label);
-  }
-  const missing = territory ? plannedChunks.filter((id) => !covered.has(id) && !uncoverable.has(id)) : [];
-  const seen = new Set(returns.map((r) => r.label.toLowerCase().trim()));
-  const missingAgents = (opts.expected ?? []).filter(
-    (label) => !seen.has(label.toLowerCase().trim())
-  );
-  return {
-    plannedChunks,
-    coveredChunks: [...covered].sort((a, b) => a - b),
-    uncoverableChunks: [...uncoverable].sort((a, b) => a - b),
-    missingChunks: missing,
-    whiffedAgents: whiffed,
-    missingAgents,
-    topology: opts.topology,
-    agents: returns.length,
-    // `uncoverable` is a disclosed gap, not a failure — it still forbids an
-    // Approve downstream (compose-review caps on it). A chunk nobody receipted,
-    // an agent that said nothing, and an agent that never ran are failures.
-    ok: missing.length === 0 && whiffed.length === 0 && missingAgents.length === 0
-  };
-}
-__name(checkCoverage, "checkCoverage");
+import { writeFileSync as writeFileSync10, mkdirSync as mkdirSync9 } from "node:fs";
+import { dirname as dirname8, resolve as resolve7 } from "node:path";
 function runCheckCoverage(args) {
-  let plan;
-  try {
-    plan = JSON.parse(readFileSync7(args.plan, "utf8"));
-  } catch (err) {
-    throw new Error(
-      `Cannot read the chunk plan ${args.plan}: ${err.message}`
-    );
-  }
-  if (!Array.isArray(plan.chunks) || plan.chunks.length === 0) {
-    throw new Error(
-      `${args.plan} carries no \`chunks[]\`. That is not a chunk plan \u2014 pass the report from fetch-pr / capture-local / plan-diff for THIS review. A plan with no chunks would let the check pass over a diff nobody saw.`
-    );
-  }
-  const planned = plan.chunks.map((c) => c.id);
-  if (planned.some((id) => !Number.isSafeInteger(id) || id <= 0)) {
-    throw new Error(`${args.plan} has a chunk with no positive integer id.`);
-  }
-  if (new Set(planned).size !== planned.length) {
-    throw new Error(`${args.plan} has duplicate chunk ids.`);
-  }
-  let text;
+  let report;
   try {
-    text = readFileSync7(args.returns, "utf8");
+    report = coverageFromTranscripts(args.plan);
   } catch (err) {
-    throw new Error(
-      `Cannot read the agent returns ${args.returns}: ${err.message}`
-    );
-  }
-  const returns = splitReturns(text);
-  if (returns.length === 0) {
-    throw new Error(
-      `No agent returns found in ${args.returns}. Each one must be preceded by a \`=== AGENT: <label> ===\` line, and its text copied verbatim \u2014 a summary of what an agent said cannot show whether it said anything.`
-    );
+    if (err instanceof TranscriptsUnavailableError) {
+      writeStderrLine(
+        `ERROR: ${err.message}
+This is an environment problem, not a finding about the agents. Coverage cannot be shown, so the review must not certify the diff.`
+      );
+      process.exitCode = 3;
+      return;
+    }
+    throw err;
   }
-  const expected = (args.expect ?? "").split(",").map((l) => l.trim()).filter(Boolean);
-  const report = checkCoverage(planned, returns, {
-    topology: args.topology,
-    expected
-  });
-  mkdirSync9(dirname8(resolve6(args.out)), { recursive: true });
-  writeFileSync10(args.out, JSON.stringify(report, null, 2), "utf8");
+  mkdirSync9(dirname8(resolve7(args.out)), { recursive: true });
+  writeFileSync10(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;
   writeStderrLine(
-    report.topology === "dimension" ? `Coverage: ${report.agents} dimension agent return(s), no per-chunk receipts (every agent walks the whole plan)` : `Coverage: ${report.coveredChunks.length}/${planned.length} chunks receipted by ${report.agents} agent return(s)` + (report.uncoverableChunks.length ? `, ${report.uncoverableChunks.length} uncoverable` : "")
+    `Coverage: ${report.coveredChunks.length}/${totalChunks} chunk(s) reviewed. ${report.agents} agent(s) ran; ${worked} did work` + (report.blindAgents.length ? `, ${report.blindAgents.length} were launched blind` : "") + (report.idleAgents.length ? `, ${report.idleAgents.length} made no tool call` : "")
   );
-  if (report.missingChunks.length > 0) {
+  if (report.blindAgents.length > 0) {
     writeStderrLine(
-      `ERROR: ${report.missingChunks.length} chunk(s) carry NO receipt \u2014 ${report.missingChunks.join(", ")}. Nobody read those lines. Relaunch an agent for each before Step 4; do not aggregate findings over a diff that was not read, and do not certify what nobody looked at.`
+      `ERROR: ${report.blindAgents.length} agent(s) were launched with a prompt that never named the diff file \u2014 ${report.blindAgents.join(", ")}. They could not have read the diff, whatever they returned. Do NOT relaunch them as they are: a second blind agent reads no more than the first. Build each prompt with \`qwen review agent-prompt --plan <plan> --chunk <id>\` and pass it verbatim.`
     );
   }
-  if (report.missingAgents.length > 0) {
+  if (report.idleAgents.length > 0) {
     writeStderrLine(
-      `ERROR: ${report.missingAgents.length} expected agent(s) never returned \u2014 ${report.missingAgents.join(", ")}. A lens nobody ran is not a lens that found nothing. Launch each before Step 4.`
+      `ERROR: ${report.idleAgents.length} agent(s) made no tool call \u2014 ${report.idleAgents.join(", ")}. They read nothing. Their prose is not evidence: of 129 real transcripts, every single one of the 80 agents that made no call still returned confident, specific text.`
     );
   }
-  if (report.whiffedAgents.length > 0) {
+  if (report.uncoverableChunks.length > 0) {
     writeStderrLine(
-      `ERROR: ${report.whiffedAgents.length} agent(s) returned nothing substantive \u2014 ${report.whiffedAgents.join("; ")}. A return this short is indistinguishable from an agent that did not run (a receipt says which lines it was handed, not that it looked at them). Relaunch each ONCE; if it comes back bare again, record its dimension in \`unreviewedDimensions\`, which forbids an Approve.`
+      `ERROR: ${report.uncoverableChunks.length} chunk(s) were declared uncoverable \u2014 ${report.uncoverableChunks.join(", ")}. A diff with a line no read can reach was not reviewed; the verdict may not approve on its strength. Report them to the user as an unreviewed gap.`
     );
   }
-  if (!report.ok) {
+  if (report.missingChunks.length > 0) {
     writeStderrLine(
-      "The review has not covered the diff. Fix that before Step 4."
+      `ERROR: ${report.missingChunks.length} chunk(s) were not reviewed \u2014 ${report.missingChunks.join(", ")}. Nobody read those lines. Do not aggregate findings over a diff that was not read.`
     );
+  }
+  if (!report.ok) {
     process.exitCode = 3;
   }
 }
 __name(runCheckCoverage, "runCheckCoverage");
 var checkCoverageCommand = {
   command: "check-coverage",
-  describe: "Read the review agents' verbatim returns and report which chunks nobody covered (the Step 3 receipt check, as code)",
+  describe: "Prove the diff was read, from the harness's own per-agent transcripts (not from any file the caller writes)",
   builder: /* @__PURE__ */ __name((yargs) => yargs.option("plan", {
     type: "string",
     demandOption: true,
-    describe: "The chunk plan from fetch-pr / capture-local / plan-diff (its `chunks[]` is what must be covered)"
-  }).option("returns", {
-    type: "string",
-    demandOption: true,
-    describe: "Every review agent's return, VERBATIM, each preceded by `=== AGENT: <label> ===`. Not a summary: a summary of an agent that said nothing says something."
+    describe: "Path to the plan report from Step 1"
   }).option("out", {
     type: "string",
     demandOption: true,
     describe: "Output JSON path (will be overwritten)"
-  }).option("topology", {
+  }), "builder"),
+  handler: /* @__PURE__ */ __name((argv) => {
+    runCheckCoverage(argv);
+  }, "handler")
+};
+
+// packages/cli/src/commands/review/agent-prompt.ts
+init_esbuild_shims();
+import { readFileSync as readFileSync9 } from "node:fs";
+var SEVERITY = `Apply the severity definitions:
+- **Critical** \u2014 the code does something wrong. A bug that produces incorrect behaviour, a security hole, data loss, a resource or state leak, a build or test failure.
+- **Suggestion** \u2014 a recommended improvement to code that works.
+- **Nice to have** \u2014 optional.`;
+var FINDING_FORMAT = `Format each finding using this structure:
+- **File:** <file path>:<line number or range>
+- **Anchor:** <1-3 consecutive lines copied VERBATIM from the diff>
+- **Source:** [review]
+- **Issue:** <one-line statement of the defect>
+- **Failure scenario:** <the concrete trigger and the concrete wrong outcome: what input, state, timing, or config makes this code misbehave, and what incorrect output / crash / leak / exposure results>
+- **Suggested fix:** <concrete code suggestion when possible, or "N/A">
+- **Severity:** Critical | Suggestion | Nice to have
+- **Confidence:** high | low`;
+function chunkFrom(report, id) {
+  const diffPath = report.diffPathAbsolute;
+  if (typeof diffPath !== "string" || diffPath.length === 0) {
+    throw new Error(
+      "agent-prompt: the plan has no `diffPathAbsolute`. Without it the agent has no way to reach the diff \u2014 which is the entire bug this command exists to prevent. Pass the report written by fetch-pr / plan-diff / capture-local."
+    );
+  }
+  if (!Array.isArray(report.chunks) || report.chunks.length === 0) {
+    throw new Error("agent-prompt: the plan has no `chunks[]`.");
+  }
+  const chunks = report.chunks;
+  const chunk = chunks.find((c) => c?.id === id);
+  if (!chunk) {
+    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) {
+    throw new Error(
+      `agent-prompt: chunk ${id} has no usable line range (startLine=${chunk.startLine}, endLine=${chunk.endLine}).`
+    );
+  }
+  return { diffPath, chunk, total: chunks.length };
+}
+__name(chunkFrom, "chunkFrom");
+function buildChunkAgentPrompt(report, id, rules) {
+  const { diffPath, chunk, total } = chunkFrom(report, id);
+  const offset = chunk.startLine - 1;
+  const limit = chunk.endLine - chunk.startLine + 1;
+  const files = (Array.isArray(chunk.files) ? chunk.files : []).filter(
+    (f) => !!f && typeof f.path === "string" && f.path.length > 0
+  ).map((f) => `- ${f.path} (new-side lines ${f.newStart}-${f.newEnd})`).join("\n");
+  const unreachable = chunk.maxLineChars > READ_FILE_CHAR_CAP;
+  const parts = [
+    `You are reviewing chunk ${chunk.id} of ${total} of a code diff.`,
+    "",
+    "**Read your chunk first. It is a file on disk \u2014 nothing in this prompt contains the code.**",
+    "",
+    "```",
+    `read_file(file_path="${diffPath}", offset=${offset}, limit=${limit})`,
+    "```",
+    "",
+    `That is 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.`,
+    "",
+    "It covers these source files:",
+    files || "- (none recorded)",
+    "",
+    "**If the read comes back with `isTruncated` set, you do not have your chunk.** Keep calling `read_file` with a larger `offset` until you have the whole range. A receipt for a range you only half read makes the coverage guarantee a lie, which is worse than not having one."
+  ];
+  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:`,
+      "",
+      `    Uncoverable: chunk ${chunk.id} \u2014 line exceeds the read limit`
+    );
+  } else if (chunk.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."
+    );
+  }
+  parts.push(
+    "",
+    "You may also `read_file` the **full source files** above from the worktree whenever a hunk's correctness depends on code outside it. Diff context is three lines deep; state invariants are not. Page a source file that comes back truncated rather than reasoning from its first screenful.",
+    "",
+    "## What to review",
+    "",
+    "For your territory only, you own every dimension: line-by-line correctness, the removed-behavior audit of your own deleted lines, security, code quality, performance, test coverage, and the adversarial reading. Two duties are NOT yours, because a chunk agent is structurally blind to them: cross-file tracing (a caller in another chunk) and the cross-chunk half of removed-behavior. Audit the deletions in your own territory; do not conclude a deletion is unreplaced merely because its replacement is not in your range.",
+    "",
+    FINDING_FORMAT,
+    "",
+    SEVERITY,
+    "",
+    "Review the diff, not pre-existing issues in unchanged code."
+  );
+  if (rules && rules.trim()) {
+    parts.push("", "## Project rules", "", rules.trim());
+  }
+  parts.push(
+    "",
+    "## When you are done",
+    "",
+    "If you found nothing, say so **and say what you examined** \u2014 the specific lines, files and cases you walked, in your own words. Do not recite a stock sentence: a return that names nothing you read is indistinguishable from never having read anything, and will be treated as such."
+  );
+  if (!unreachable) {
+    parts.push(
+      "",
+      `Then, on its own final line: \`Covered: chunk ${chunk.id} lines ${chunk.startLine}-${chunk.endLine}\``
+    );
+  }
+  return parts.join("\n");
+}
+__name(buildChunkAgentPrompt, "buildChunkAgentPrompt");
+function runAgentPrompt(args) {
+  let report;
+  try {
+    report = JSON.parse(readFileSync9(args.plan, "utf8"));
+  } catch (err) {
+    throw new Error(
+      `agent-prompt: cannot read the plan ${args.plan}: ${err.message}`
+    );
+  }
+  let rules;
+  if (args.rules) {
+    try {
+      rules = readFileSync9(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.`
+      );
+    }
+  }
+  writeStdoutLine(buildChunkAgentPrompt(report, args.chunk, rules));
+}
+__name(runAgentPrompt, "runAgentPrompt");
+var agentPromptCommand = {
+  command: "agent-prompt",
+  describe: "Build a chunk agent's launch prompt from the plan (the diff path and its byte range are welded in, not left to the caller to remember)",
+  builder: /* @__PURE__ */ __name((yargs) => yargs.option("plan", {
     type: "string",
-    choices: ["territory", "dimension"],
-    default: "territory",
-    describe: "territory (Step 3B: one receipt per chunk) or dimension (Step 3A: no receipts, every agent walks the whole plan)"
-  }).option("expect", {
+    demandOption: true,
+    describe: "Path to the plan report from fetch-pr / plan-diff / capture-local"
+  }).option("chunk", {
+    type: "number",
+    demandOption: true,
+    describe: "Which chunk id this agent owns"
+  }).option("rules", {
     type: "string",
-    describe: "Comma-separated labels of every agent launched, so an agent that never returned is caught"
+    describe: "Path to the project rules file from `load-rules` (omit when the review has none)"
   }), "builder"),
   handler: /* @__PURE__ */ __name((argv) => {
-    runCheckCoverage(argv);
+    runAgentPrompt(argv);
   }, "handler")
 };
 
 // packages/cli/src/commands/review/submit.ts
 init_esbuild_shims();
-import { readFileSync as readFileSync8 } from "node:fs";
+import { readFileSync as readFileSync10 } from "node:fs";
 
 // packages/cli/src/services/skill-args-file.ts
 init_esbuild_shims();
@@ -6496,14 +6782,14 @@ import {
   openSync,
   writeSync,
   closeSync,
-  rmSync,
+  rmSync as rmSync2,
   lstatSync as lstatSync2,
   existsSync as existsSync3,
   constants
 } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 var debugLogger2 = createDebugLogger("SKILL_ARGS_FILE");
-var SKILL_ARGS_DIR = join5(".qwen", "tmp");
+var SKILL_ARGS_DIR = join6(".qwen", "tmp");
 function safe(s) {
   return s.replace(/[^A-Za-z0-9._-]/g, "_");
 }
@@ -6513,11 +6799,11 @@ function currentSessionId() {
 }
 __name(currentSessionId, "currentSessionId");
 function skillArgsDir(sessionId = currentSessionId()) {
-  return sessionId ? join5(SKILL_ARGS_DIR, `s-${safe(sessionId)}`) : SKILL_ARGS_DIR;
+  return sessionId ? join6(SKILL_ARGS_DIR, `s-${safe(sessionId)}`) : SKILL_ARGS_DIR;
 }
 __name(skillArgsDir, "skillArgsDir");
 function skillArgsPath(skillName, sessionId = currentSessionId()) {
-  return join5(
+  return join6(
     skillArgsDir(sessionId),
     `qwen-skill-args-${safe(skillName)}.txt`
   );
@@ -6560,7 +6846,7 @@ __name(writeSkillArgs, "writeSkillArgs");
 function clearSkillArgs(skillName) {
   const path3 = skillArgsPath(skillName);
   try {
-    rmSync(path3, { force: true });
+    rmSync2(path3, { force: true });
   } catch (err) {
     debugLogger2.warn(
       `Could not clear skill args for ${skillName}: ${err.message}`
@@ -6609,7 +6895,7 @@ function authorization(args) {
   const path3 = currentSessionId() === "" && args.skillArgs ? args.skillArgs : sessionScoped;
   let raw;
   try {
-    raw = readFileSync8(path3, "utf8");
+    raw = readFileSync10(path3, "utf8");
   } catch {
     return {
       ok: false,
@@ -6733,7 +7019,7 @@ function runSubmit(args) {
   }
   let payload;
   try {
-    payload = JSON.parse(readFileSync8(args.review, "utf8"));
+    payload = JSON.parse(readFileSync10(args.review, "utf8"));
   } catch (err) {
     throw new Error(
       `Cannot read review JSON ${args.review}: ${err.message}`
@@ -6830,11 +7116,12 @@ import { spawnSync } from "node:child_process";
 import {
   mkdirSync as mkdirSync11,
   writeFileSync as writeFileSync11,
-  readFileSync as readFileSync9,
-  rmSync as rmSync2,
-  lstatSync as lstatSync3
+  readFileSync as readFileSync11,
+  rmSync as rmSync3,
+  lstatSync as lstatSync3,
+  existsSync as existsSync4
 } from "node:fs";
-import { dirname as dirname9, join as join6, isAbsolute as isAbsolute2, resolve as resolve7, sep as sep2 } from "node:path";
+import { dirname as dirname9, join as join7, isAbsolute as isAbsolute2, sep as sep2 } from "node:path";
 function isWorkspaceMember(filePath, workspaceGlobs) {
   const norm = filePath.replace(/^\.\//, "");
   const matches = /* @__PURE__ */ __name((glob) => {
@@ -6951,7 +7238,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 = join6(cur, parts[i]);
+    cur = join7(cur, parts[i]);
     let st;
     try {
       st = lstatSync3(cur);
@@ -6964,15 +7251,34 @@ function safeRmWithin(worktree, relPath) {
       );
     }
   }
-  rmSync2(cur, { force: true });
+  rmSync3(cur, { force: true });
 }
 __name(safeRmWithin, "safeRmWithin");
+function discardWorktree(cwd, tree) {
+  const sweep = spawnSync("git", ["worktree", "remove", "--force", tree], {
+    cwd,
+    encoding: "utf8"
+  });
+  rmSync3(tree, { recursive: true, force: true });
+  return sweep;
+}
+__name(discardWorktree, "discardWorktree");
 var existsAtBase = /* @__PURE__ */ __name((cwd, base, path3) => existsAtRev(cwd, base, path3), "existsAtBase");
+function probeCreateFailureDetail(err, sweepStderr) {
+  const sweepErr = sweepStderr.trim();
+  return `probe worktree could not be created: ${err instanceof Error ? err.message : String(err)}` + (sweepErr ? ` (stale-tree sweep also reported: ${sweepErr})` : "");
+}
+__name(probeCreateFailureDetail, "probeCreateFailureDetail");
+function probeCleanupFailureDetail(probeTree, removeError, sweepStderr) {
+  const why = removeError ? removeError instanceof Error ? removeError.message : String(removeError) : sweepStderr.trim();
+  return `could not remove probe worktree ${probeTree}${why ? `: ${why}` : ""}`;
+}
+__name(probeCleanupFailureDetail, "probeCleanupFailureDetail");
 async function runTestEfficacy(args) {
   const { report, worktree, base, out } = args;
-  const plan = JSON.parse(readFileSync9(report, "utf8"));
+  const plan = JSON.parse(readFileSync11(report, "utf8"));
   const rootPkg = JSON.parse(
-    readFileSync9(`${worktree}/package.json`, "utf8")
+    readFileSync11(`${worktree}/package.json`, "utf8")
   );
   const globs = rootPkg.workspaces ?? [];
   const { unreachable, probes, revert } = planTestEfficacy(
@@ -6980,8 +7286,8 @@ async function runTestEfficacy(args) {
     globs
   );
   for (const p of revert) {
-    const norm = join6(worktree, p);
-    const root = join6(worktree, ".");
+    const norm = join7(worktree, p);
+    const root = join7(worktree, ".");
     if (isAbsolute2(p) || norm !== root && !norm.startsWith(root + sep2)) {
       throw new Error(
         `refusing to run: revert path escapes the worktree: ${JSON.stringify(p)}`
@@ -6992,16 +7298,15 @@ async function runTestEfficacy(args) {
   let cleanupFailure;
   if (probes.length > 0 && revert.length > 0) {
     const headSha = gitOut(worktree, "rev-parse", "HEAD");
-    const probeTree = `${resolve7(worktree)}-probe`;
+    const probeTree = probeWorktreePath(worktree);
     let created = false;
+    let sweep;
     try {
-      spawnSync("git", ["worktree", "remove", "--force", probeTree], {
-        cwd: worktree
-      });
+      sweep = discardWorktree(worktree, probeTree);
       git2(worktree, "worktree", "add", "--detach", probeTree, headSha);
       created = true;
     } catch (e) {
-      const detail = `probe worktree could not be created: ${e instanceof Error ? e.message : String(e)}`;
+      const detail = probeCreateFailureDetail(e, String(sweep?.stderr ?? ""));
       for (const file of probes) {
         results.push({ file, verdict: "inconclusive", detail });
       }
@@ -7054,10 +7359,19 @@ async function runTestEfficacy(args) {
           }))
         );
       } finally {
+        let removeError;
+        let discard;
         try {
-          git2(worktree, "worktree", "remove", "--force", probeTree);
+          discard = discardWorktree(worktree, probeTree);
         } catch (e) {
-          cleanupFailure = `could not remove probe worktree ${probeTree}: ${e instanceof Error ? e.message : String(e)}`;
+          removeError = e;
+        }
+        if (existsSync4(probeTree)) {
+          cleanupFailure = probeCleanupFailureDetail(
+            probeTree,
+            removeError,
+            String(discard?.stderr ?? "")
+          );
         }
       }
     }
@@ -7122,23 +7436,27 @@ var testEfficacyCommand = {
 // packages/cli/src/commands/review/cleanup.ts
 init_esbuild_shims();
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync4, readdirSync, unlinkSync } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync5, readdirSync as readdirSync2, unlinkSync } from "node:fs";
+import { join as join8 } from "node:path";
 function runCleanup(target) {
   let removedAny = false;
+  let failedAny = false;
   const prMatch = /^pr-(\d+)$/.exec(target);
   if (prMatch) {
     const prNumber = prMatch[1];
+    const report = /* @__PURE__ */ __name((label, path3) => {
+      const { existed, freed, reason } = releaseWorktree(path3);
+      if (freed) {
+        writeStdoutLine(`Removed ${label}: ${path3}`);
+        removedAny = true;
+      } else if (existed) {
+        writeStderrLine(`Failed to remove ${label} ${path3}: ${reason}`);
+        failedAny = true;
+      }
+    }, "report");
     const wt = worktreePath(prNumber);
-    if (releaseWorktree(wt)) {
-      writeStdoutLine(`Removed worktree: ${wt}`);
-      removedAny = true;
-    }
-    const probeWt = `${wt}-probe`;
-    if (releaseWorktree(probeWt)) {
-      writeStdoutLine(`Removed probe worktree: ${probeWt}`);
-      removedAny = true;
-    }
+    report("worktree", wt);
+    report("probe worktree", probeWorktreePath(wt));
     const branch = reviewBranch(prNumber);
     if (refExists(branch)) {
       try {
@@ -7155,7 +7473,7 @@ function runCleanup(target) {
   const prefix = tmpPrefix(target);
   let tmpEntries = [];
   try {
-    tmpEntries = existsSync4(REVIEW_TMP_DIR) ? readdirSync(REVIEW_TMP_DIR) : [];
+    tmpEntries = existsSync5(REVIEW_TMP_DIR) ? readdirSync2(REVIEW_TMP_DIR) : [];
   } catch (err) {
     writeStderrLine(
       `Failed to read ${REVIEW_TMP_DIR}: ${err.message}`
@@ -7163,16 +7481,17 @@ function runCleanup(target) {
   }
   for (const file of tmpEntries) {
     if (!file.startsWith(prefix)) continue;
-    const full = join7(REVIEW_TMP_DIR, file);
+    const full = join8(REVIEW_TMP_DIR, file);
     try {
       unlinkSync(full);
       writeStdoutLine(`Removed temp file: ${full}`);
       removedAny = true;
     } catch (err) {
       writeStderrLine(`Failed to remove ${full}: ${err.message}`);
+      failedAny = true;
     }
   }
-  if (!removedAny) {
+  if (!removedAny && !failedAny) {
     writeStdoutLine(`Nothing to clean for target "${target}".`);
   }
 }
@@ -7194,9 +7513,9 @@ var cleanupCommand = {
 var reviewCommand = {
   command: "review",
   describe: "Internal helpers used by the /review skill (PR worktree setup, context fetch, rules loading, presubmit checks, cleanup)",
-  builder: /* @__PURE__ */ __name((yargs) => yargs.command(parseArgsCommand).command(fetchPrCommand).command(captureLocalCommand).command(planDiffCommand).command(prContextCommand).command(loadRulesCommand).command(resolveAnchorsCommand).command(checkCoverageCommand).command(presubmitCommand).command(testEfficacyCommand).command(composeReviewCommand).command(submitCommand).command(cleanupCommand).demandCommand(
+  builder: /* @__PURE__ */ __name((yargs) => yargs.command(parseArgsCommand).command(fetchPrCommand).command(captureLocalCommand).command(planDiffCommand).command(prContextCommand).command(loadRulesCommand).command(agentPromptCommand).command(resolveAnchorsCommand).command(checkCoverageCommand).command(presubmitCommand).command(testEfficacyCommand).command(composeReviewCommand).command(submitCommand).command(cleanupCommand).demandCommand(
     1,
-    "Specify a subcommand: parse-args, fetch-pr, capture-local, plan-diff, pr-context, load-rules, resolve-anchors, check-coverage, presubmit, test-efficacy, compose-review, submit, or cleanup."
+    "Specify a subcommand: parse-args, fetch-pr, capture-local, plan-diff, pr-context, load-rules, agent-prompt, resolve-anchors, check-coverage, presubmit, test-efficacy, compose-review, submit, or cleanup."
   ).version(false), "builder"),
   handler: /* @__PURE__ */ __name(() => {
   }, "handler")
@@ -7396,10 +7715,10 @@ var updateCommand3 = {
       stdioHelpers,
       { updateEventEmitter }
     ] = await Promise.all([
-      import("./settings-IXF5FIQO.js"),
-      import("./updateCheck-ZXL66KIG.js"),
-      import("./installationInfo-WOTDQMSC.js"),
-      import("./standalone-update-MHLSFHE6.js"),
+      import("./settings-HQNDK7TG.js"),
+      import("./updateCheck-QTVVISH7.js"),
+      import("./installationInfo-WELKRHHE.js"),
+      import("./standalone-update-L5XW3D7K.js"),
       import("./stdioHelpers-UMY72QRP.js"),
       import("./updateEventEmitter-5MKC7BLQ.js")
     ]);
@@ -8701,6 +9020,9 @@ async function loadCliConfig(settings, argv, cwd = process.cwd(), overrideExtens
       enabled: lspEnabled
     },
     agents: settings.agents ? {
+      builtin: settings.agents.builtin ? {
+        exploreModel: settings.agents.builtin.exploreModel
+      } : void 0,
       maxParallelAgents: settings.agents.maxParallelAgents,
       displayMode: settings.agents.displayMode,
       arena: settings.agents.arena ? {
@@ -8858,6 +9180,9 @@ var ExtensionRefreshState = class {
   needsExtensionRefresh() {
     return this.extensionRefreshNeeded;
   }
+  isSuppressed() {
+    return this.suppressionDepth > 0 || Date.now() < this.suppressUntil;
+  }
   isReloadInProgress() {
     return this.reloadInProgress;
   }
@@ -8896,9 +9221,6 @@ var ExtensionRefreshState = class {
     this.suppressionDepth = 0;
     this.suppressUntil = 0;
   }
-  isSuppressed() {
-    return this.suppressionDepth > 0 || Date.now() < this.suppressUntil;
-  }
 };
 function isPromiseLike(value) {
   return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";