@cortexkit/aft-opencode 0.54.0 → 0.55.1

package/dist/index.js

@@ -8842,6 +8842,21 @@ class BinaryBridge {
     }
     return this.sendWithVersionMismatchRetry(command, dispatchParams, options, true);
   }
+  listenForRequestAbort(requestId, signal) {
+    if (!signal)
+      return () => {};
+    let fired = false;
+    const onAbort = () => {
+      if (fired)
+        return;
+      fired = true;
+      this.send("cancel_request", { id: requestId }, { keepBridgeOnTimeout: true }).catch(() => {});
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted)
+      onAbort();
+    return () => signal.removeEventListener("abort", onAbort);
+  }
   async toolCall(sessionId, name, rawArgs = {}, options) {
     const params = { name, arguments: rawArgs };
     if (sessionId)
@@ -8864,7 +8879,7 @@ class BinaryBridge {
       if (this._shuttingDown) {
         throw new BridgeTransportUnavailableError(`${this.errorPrefix} Bridge is shutting down, cannot send "${command}"`);
       }
-      if (Object.hasOwn(params, "id")) {
+      if (Object.hasOwn(params, "id") && command !== "cancel_request") {
         throw new Error("params cannot contain reserved key 'id'");
       }
       const requestSessionId = typeof params.session_id === "string" && params.session_id.length > 0 ? params.session_id : undefined;
@@ -8918,7 +8933,7 @@ class BinaryBridge {
       }
       const id = String(this.nextId++);
       let request;
-      if (Object.hasOwn(params, "command") || Object.hasOwn(params, "method")) {
+      if (command === "cancel_request" || Object.hasOwn(params, "command") || Object.hasOwn(params, "method")) {
         const nested = { ...params };
         const reserved = {};
         for (const key of ["session_id", "lsp_hints"]) {
@@ -8938,11 +8953,12 @@ class BinaryBridge {
       const child = this.process;
       const response = await new Promise((resolve3, reject) => {
         const timer = setTimeout(() => {
-          const entry = this.pending.get(id);
-          if (!entry)
+          const entry2 = this.pending.get(id);
+          if (!entry2)
             return;
           this.pending.delete(id);
-          clearTimeout(entry.timer);
+          clearTimeout(entry2.timer);
+          entry2.onSettled?.();
           if (keepBridgeOnTimeout) {
             const timeoutMsg2 = `Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`;
             if (requestSessionId) {
@@ -8950,7 +8966,7 @@ class BinaryBridge {
             } else {
               this.warnVia(timeoutMsg2);
             }
-            entry.reject(new BridgeTransportTimeoutError(command, effectiveTimeoutMs, `${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
+            entry2.reject(new BridgeTransportTimeoutError(command, effectiveTimeoutMs, `${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
             return;
           }
           const childActiveSinceRequest = this.lastChildActivityAt > requestSentAt;
@@ -8965,13 +8981,20 @@ class BinaryBridge {
             this.warnVia(timeoutMsg);
           }
           if (keepWarm) {
-            entry.reject(new Error(`${this.errorPrefix} request "${command}" timed out after ${effectiveTimeoutMs}ms (bridge busy/under load); bridge kept warm — retry`));
+            entry2.reject(new Error(`${this.errorPrefix} request "${command}" timed out after ${effectiveTimeoutMs}ms (bridge busy/under load); bridge kept warm — retry`));
             return;
           }
-          entry.reject(new Error(`${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
+          entry2.reject(new Error(`${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
           this.handleTimeout(requestSessionId);
         }, effectiveTimeoutMs);
-        this.pending.set(id, { resolve: resolve3, reject, timer, onProgress: options?.onProgress, command });
+        const entry = {
+          resolve: resolve3,
+          reject,
+          timer,
+          onProgress: options?.onProgress,
+          command
+        };
+        this.pending.set(id, entry);
         if (!child?.stdin?.writable) {
           this.pending.delete(id);
           clearTimeout(timer);
@@ -8985,11 +9008,12 @@ class BinaryBridge {
         const handleWriteFailure = (cause) => {
           const writeError = cause instanceof Error ? cause : new Error(String(cause));
           const error2 = new BridgeTransportUnknownOutcomeError(`${this.errorPrefix} Failed to write to stdin: ${writeError.message}`, { cause: writeError });
-          const entry = this.pending.get(id);
-          if (entry) {
+          const entry2 = this.pending.get(id);
+          if (entry2) {
             this.pending.delete(id);
-            clearTimeout(entry.timer);
-            entry.reject(error2);
+            clearTimeout(entry2.timer);
+            entry2.onSettled?.();
+            entry2.reject(error2);
           }
           if (this.process === child)
             this.invalidateTransportProcess(error2);
@@ -9002,6 +9026,9 @@ class BinaryBridge {
         } catch (err) {
           handleWriteFailure(err);
         }
+        if (this.pending.has(id)) {
+          entry.onSettled = this.listenForRequestAbort(id, options?.abortSignal);
+        }
       });
       if (command === "configure" && response.success === true && options?.markConfiguredOnSuccess !== false) {
         this.configured = true;
@@ -9370,6 +9397,7 @@ class BinaryBridge {
         if (requestId && entry) {
           this.pending.delete(requestId);
           clearTimeout(entry.timer);
+          entry.onSettled?.();
           entry.resolve({
             success: false,
             code: "permission_required",
@@ -9411,6 +9439,7 @@ class BinaryBridge {
           return;
         this.pending.delete(id);
         clearTimeout(entry.timer);
+        entry.onSettled?.();
         this.consecutiveRequestTimeouts = 0;
         this.scheduleRestartCountReset();
         this.accountForBashTaskResponse(entry.command, response);
@@ -9501,6 +9530,7 @@ class BinaryBridge {
   rejectAllPending(error2) {
     for (const [_id, entry] of this.pending) {
       clearTimeout(entry.timer);
+      entry.onSettled?.();
       entry.reject(error2);
     }
     this.pending.clear();
@@ -9525,6 +9555,12 @@ import { join as join5 } from "node:path";
 function homeDir2(env) {
   return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir4();
 }
+function getOpenCodeCacheRoot(env = process.env, home = homedir4()) {
+  return join5(env.XDG_CACHE_HOME || join5(home, ".cache"), "opencode");
+}
+function getOpenCodeConfigRoot(env = process.env, home = homedir4()) {
+  return join5(env.XDG_CONFIG_HOME || join5(home, ".config"), "opencode");
+}
 function getAftCacheRoot(env = process.env) {
   if (env.AFT_CACHE_DIR)
     return env.AFT_CACHE_DIR;
@@ -14284,6 +14320,7 @@ async function ensureStorageMigrated(opts) {
   throw new Error(`AFT storage migration failed (${detail}). ` + `Harness: ${opts.harness}. Legacy: ${legacyRoot}. Target: ${newRoot}. ` + `See log: ${logPath}. ` + `Plugin load aborted to prevent legacy/new state divergence.` + (stderrTail ? ` Stderr tail: ${stderrTail}` : "") + (stdoutTail ? ` Stdout tail: ${stdoutTail}` : ""));
 }
 // ../aft-bridge/dist/npm-resolver.js
+import { spawn as spawn3, spawnSync as spawnSync3 } from "node:child_process";
 import { readdirSync as readdirSync2, statSync as statSync5 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import { delimiter as delimiter2, dirname as dirname4, isAbsolute as isAbsolute3, join as join10 } from "node:path";
@@ -14390,6 +14427,189 @@ function resolveNpm(deps = defaultDeps()) {
   }
   return null;
 }
+function quoteCmdArgument(value) {
+  if (/[\0\r\n"%]/.test(value)) {
+    throw new Error(`npm argument cannot be represented safely for cmd.exe: ${JSON.stringify(value)}`);
+  }
+  return `"${value}"`;
+}
+function npmInvocation(resolved, npmArgs, platform = process.platform, env = process.env) {
+  if (platform !== "win32" || !/\.(?:cmd|bat)$/i.test(resolved.command)) {
+    return { command: resolved.command, args: [...npmArgs] };
+  }
+  if (/[\0\r\n"]/.test(resolved.command)) {
+    throw new Error(`npm command cannot be represented safely for cmd.exe: ${JSON.stringify(resolved.command)}`);
+  }
+  const commandEnvName = "AFT_NPM_COMMAND";
+  const quotedArgs = npmArgs.map(quoteCmdArgument);
+  const commandLine = `""%${commandEnvName}%"${quotedArgs.length > 0 ? ` ${quotedArgs.join(" ")}` : ""}"`;
+  return {
+    command: env.ComSpec ?? env.COMSPEC ?? "cmd.exe",
+    args: ["/d", "/s", "/v:off", "/c", commandLine],
+    env: { [commandEnvName]: resolved.command },
+    windowsVerbatimArguments: true,
+    windowsCmdShim: true
+  };
+}
+
+class NpmTerminationUnknownError extends Error {
+  code = "npm_termination_unknown";
+  constructor(detail) {
+    super(`npm process-tree termination could not be confirmed: ${detail}`);
+    this.name = "NpmTerminationUnknownError";
+  }
+}
+function terminateDirectNpmChild(child, gracePeriodMs) {
+  if (child.exitCode !== null || child.signalCode !== null)
+    return Promise.resolve();
+  return new Promise((resolve7, reject) => {
+    let settled = false;
+    let forceTimer = null;
+    let confirmationTimer = null;
+    let signalFailure = null;
+    const cleanup = () => {
+      if (forceTimer)
+        clearTimeout(forceTimer);
+      if (confirmationTimer)
+        clearTimeout(confirmationTimer);
+      child.removeListener("exit", finish);
+      child.removeListener("error", onChildError);
+    };
+    const finish = () => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      resolve7();
+    };
+    const fail = () => {
+      if (settled)
+        return;
+      if (child.exitCode !== null || child.signalCode !== null) {
+        finish();
+        return;
+      }
+      settled = true;
+      cleanup();
+      reject(new NpmTerminationUnknownError(signalFailure ?? `direct npm child did not exit after SIGKILL within ${gracePeriodMs}ms`));
+    };
+    const onChildError = (error2) => {
+      signalFailure = `direct npm child error during termination: ${String(error2)}`;
+    };
+    const signal = (value) => {
+      try {
+        if (!child.kill(value)) {
+          signalFailure = `direct npm child rejected ${value ?? "SIGTERM"}`;
+        }
+      } catch (error2) {
+        signalFailure = `direct npm child ${value ?? "SIGTERM"} failed: ${String(error2)}`;
+      }
+    };
+    child.once("exit", finish);
+    child.on("error", onChildError);
+    forceTimer = setTimeout(() => {
+      signal("SIGKILL");
+      confirmationTimer = setTimeout(fail, gracePeriodMs);
+    }, gracePeriodMs);
+    signal();
+    if (child.exitCode !== null || child.signalCode !== null)
+      finish();
+  });
+}
+function terminateNpmProcessTree(child, invocation, env = process.env, gracePeriodMs = 5000) {
+  if (!invocation.windowsCmdShim)
+    return terminateDirectNpmChild(child, gracePeriodMs);
+  const exitedSuccessfully = () => child.exitCode === 0 && child.signalCode === null;
+  if (exitedSuccessfully())
+    return Promise.resolve();
+  if (child.pid === undefined) {
+    return Promise.reject(new NpmTerminationUnknownError("cmd.exe child has no process ID"));
+  }
+  return new Promise((resolve7, reject) => {
+    let settled = false;
+    let childExited = child.exitCode !== null || child.signalCode !== null;
+    let treeKillConfirmed = false;
+    let treeKillFailure = null;
+    let killer = null;
+    const timeout = setTimeout(() => {
+      try {
+        killer?.kill();
+      } catch {}
+      if (treeKillConfirmed || exitedSuccessfully()) {
+        settled = true;
+        cleanup();
+        resolve7();
+        return;
+      }
+      fail(treeKillFailure ?? `taskkill.exe did not finish within ${gracePeriodMs}ms`);
+    }, gracePeriodMs);
+    const cleanup = () => {
+      clearTimeout(timeout);
+      child.removeListener("exit", onChildExit);
+    };
+    const succeedIfConfirmed = () => {
+      if (settled || !childExited || !treeKillConfirmed)
+        return;
+      settled = true;
+      cleanup();
+      resolve7();
+    };
+    const fail = (detail) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(new NpmTerminationUnknownError(detail));
+    };
+    function onChildExit() {
+      childExited = true;
+      if (treeKillFailure !== null) {
+        if (exitedSuccessfully()) {
+          settled = true;
+          cleanup();
+          resolve7();
+        } else {
+          fail(treeKillFailure);
+        }
+        return;
+      }
+      succeedIfConfirmed();
+    }
+    const recordTreeKillFailure = (detail) => {
+      if (settled)
+        return;
+      if (exitedSuccessfully()) {
+        settled = true;
+        cleanup();
+        resolve7();
+        return;
+      }
+      treeKillFailure = detail;
+      if (childExited)
+        fail(detail);
+    };
+    child.once("exit", onChildExit);
+    const systemRoot = env.SystemRoot ?? env.SYSTEMROOT;
+    const taskkill = systemRoot ? join10(systemRoot, "System32", "taskkill.exe") : "taskkill.exe";
+    try {
+      killer = spawn3(taskkill, ["/pid", String(child.pid), "/t", "/f"], {
+        stdio: "ignore",
+        windowsHide: true
+      });
+      killer.once("error", (error2) => recordTreeKillFailure(`taskkill.exe failed to start: ${String(error2)}`));
+      killer.once("exit", (code) => {
+        if (code !== 0) {
+          recordTreeKillFailure(`taskkill.exe exited with code ${code ?? "unknown"}`);
+          return;
+        }
+        treeKillConfirmed = true;
+        succeedIfConfirmed();
+      });
+    } catch (error2) {
+      recordTreeKillFailure(`taskkill.exe failed to start: ${String(error2)}`);
+    }
+  });
+}
 function npmSpawnEnv(resolved, baseEnv = process.env) {
   if (!resolved.binDir)
     return { ...baseEnv };
@@ -15142,6 +15362,10 @@ function pathValue(record, property) {
   return value;
 }
 function normalizeAliasPair(record, canonical, legacy, required) {
+  if (isNullOrEmptyString(record[canonical]))
+    delete record[canonical];
+  if (isNullOrEmptyString(record[legacy]))
+    delete record[legacy];
   const hasCanonical = hasOwn(record, canonical);
   const hasLegacy = hasOwn(record, legacy);
   if (!hasCanonical && !hasLegacy) {
@@ -15173,8 +15397,13 @@ function normalizeAliasPair(record, canonical, legacy, required) {
   delete record[legacy];
 }
 function validateOptionalCanonicalPath(record, property) {
-  if (hasOwn(record, property))
-    pathValue(record, property);
+  if (!hasOwn(record, property))
+    return;
+  if (isNullOrEmptyString(record[property])) {
+    delete record[property];
+    return;
+  }
+  pathValue(record, property);
 }
 function normalizeZoomTargets(record) {
   if (!hasOwn(record, "targets"))
@@ -15330,6 +15559,10 @@ function prepareCanonicalEditArguments(toolName, rawArguments) {
   return record;
 }
 function normalizeEditPathAlias(record) {
+  if (isNullOrEmptyString(record.path))
+    delete record.path;
+  if (isNullOrEmptyString(record.filePath))
+    delete record.filePath;
   const hasCanonical = hasOwn(record, "path");
   const hasLegacy = hasOwn(record, "filePath");
   if (!hasCanonical && !hasLegacy)
@@ -15355,7 +15588,7 @@ function normalizeEditPathAlias(record) {
   }
 }
 function validateEditPath(record) {
-  if (!hasOwn(record, "path")) {
+  if (!hasOwn(record, "path") || isNullOrEmptyString(record.path)) {
     throw new InvalidRequestError("'path' is required");
   }
   pathValue(record, "path");
@@ -15416,10 +15649,13 @@ function isEditSentinelItem(item) {
   if (record.oldString === null && ["startLine", "endLine"].some((key) => hasOwn(record, key) && record[key] !== null)) {
     return false;
   }
-  const newStringEmpty = !hasOwn(record, "newString") || isNullOrEmptyString(record.newString);
-  if (!newStringEmpty)
-    return false;
-  return !hasOwn(record, "content") || isNullOrEmptyString(record.content);
+  return (!hasOwn(record, "newString") || isNullOrEmptyString(record.newString)) && (!hasOwn(record, "content") || isNullOrEmptyString(record.content)) && (!hasOwn(record, "replaceAll") || record.replaceAll === null || record.replaceAll === false) && isDefaultOccurrence(record.occurrence);
+}
+function hasMeaningfulFindPayload(item) {
+  return isNonEmptyString(item.oldString);
+}
+function isDefaultOccurrence(value) {
+  return value === undefined || value === null || value === 1;
 }
 function normalizeEditArraySentinels(record) {
   const value = record.edits;
@@ -15472,8 +15708,8 @@ function parseEditArray(value) {
   }
   return value;
 }
-function stripLineRangeSentinels(item) {
-  const hasRangeField = ["startLine", "endLine", "content"].some((key) => hasOwn(item, key));
+function normalizeEditItemSentinels(item) {
+  const hadRangeFields = ["startLine", "endLine", "content"].some((key) => hasOwn(item, key));
   for (const key of [
     "oldString",
     "newString",
@@ -15486,7 +15722,19 @@ function stripLineRangeSentinels(item) {
     if (item[key] === null)
       delete item[key];
   }
-  if (!hasRangeField)
+  const contentIsEmpty = item.content === "";
+  if (hasMeaningfulFindPayload(item) && (!hasOwn(item, "content") || contentIsEmpty)) {
+    for (const key of ["startLine", "endLine", "content"])
+      delete item[key];
+    if (hadRangeFields) {
+      if (item.replaceAll === false)
+        delete item.replaceAll;
+      if (hasOwn(item, "occurrence") && isDefaultOccurrence(item.occurrence))
+        delete item.occurrence;
+    }
+    return;
+  }
+  if (!isNonEmptyString(item.content))
     return;
   if (item.oldString === "")
     delete item.oldString;
@@ -15494,7 +15742,7 @@ function stripLineRangeSentinels(item) {
     delete item.newString;
   if (item.replaceAll === false)
     delete item.replaceAll;
-  if (item.occurrence === 1)
+  if (hasOwn(item, "occurrence") && isDefaultOccurrence(item.occurrence))
     delete item.occurrence;
 }
 function normalizeEditItem(value, index) {
@@ -15505,7 +15753,7 @@ function normalizeEditItem(value, index) {
   const item = copyOwnProperties(source);
   normalizeItemAlias(item, "oldString", "oldText");
   normalizeItemAlias(item, "newString", "newText");
-  stripLineRangeSentinels(item);
+  normalizeEditItemSentinels(item);
   const hasFindField = ["oldString", "newString", "replaceAll", "occurrence"].some((key) => hasOwn(item, key));
   const hasRangeField = ["startLine", "endLine", "content"].some((key) => hasOwn(item, key));
   if (hasFindField && hasRangeField) {
@@ -30707,6 +30955,9 @@ var GhShimConfigSchema = exports_external.object({
   enabled: exports_external.boolean().optional(),
   binary_path: exports_external.string().trim().refine(isAbsolute6, "gh_shim.binary_path must be absolute").optional()
 });
+var GhReadConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().optional()
+});
 var GitCoAuthorSchema = exports_external.string().trim().refine((value) => value === "off" || value === "auto" || /^[^<>\r\n]+\s+<[^<>\s@]+@[^<>\s@]+>$/.test(value), "git.co_author must be 'off', 'auto', or an explicit 'Name <email>' identity");
 var GitConfigSchema = exports_external.object({
   co_author: GitCoAuthorSchema.optional()
@@ -30768,6 +31019,7 @@ var AftConfigFieldsSchema = exports_external.object({
   bridge: BridgeConfigSchema.optional(),
   subc: SubcConfigSchema.optional(),
   gh_shim: GhShimConfigSchema.optional(),
+  gh_read: GhReadConfigSchema.optional(),
   git: GitConfigSchema.optional()
 });
 var HarnessOverrideSchema = exports_external.preprocess((value) => {
@@ -31246,6 +31498,8 @@ function getStrippedTopLevelKeys(override) {
     stripped.push("subc");
   if (override.gh_shim !== undefined)
     stripped.push("gh_shim");
+  if (override.gh_read !== undefined)
+    stripped.push("gh_read");
   if (override.disabled_tools?.includes("aft_safety"))
     stripped.push("disabled_tools.aft_safety");
   return stripped;
@@ -31463,6 +31717,8 @@ var UNKNOWN_COMPLETION_CAP = 32;
 var DEFAULT_SESSION_ID2 = "__default__";
 var LOG_PREFIX = "[aft-plugin] bg-notifications:";
 var SUBC_NUDGE_LOG_INTERVAL_MS = 60000;
+var DEFAULT_BG_HOP_TIMEOUT_MS = 15000;
+var bgHopTimeoutMs = DEFAULT_BG_HOP_TIMEOUT_MS;
 var subcNudgesInFlight = new Map;
 var subcNudgeLogState = new Map;
 function consumeBgCompletion(sessionID, taskId) {
@@ -31690,11 +31946,20 @@ function handleSubcBgEventsNudge(drainContext) {
 }
 async function handleSubcBgEventsNudgeOnce(drainContext) {
   bridgeForDrain(drainContext);
-  stateFor(drainContext.sessionID).wakeDeferredTaskIds.clear();
+  const state = stateFor(drainContext.sessionID);
+  state.wakeDeferredTaskIds.clear();
+  rearmHardStoppedWake(state, drainContext);
   await triggerWakeIfPending(drainContext, false, true, true);
 }
 function logSubcNudgeLifecycle(drainContext, kind, message) {
-  const key = `${kind}\x00${drainContext.directory}\x00${drainContext.sessionID}`;
+  logDeliveryHop(drainContext, kind, message, {
+    event: "subc_bg_nudge_delivery",
+    cause: kind
+  });
+}
+function logDeliveryHop(drainContext, kind, message, data, level = "info") {
+  const taskKey = typeof data.task_id === "string" ? data.task_id : Array.isArray(data.task_ids) ? data.task_ids.join(",") : "";
+  const key = `${kind}\x00${taskKey}\x00${drainContext.directory}\x00${drainContext.sessionID}`;
   const now = Date.now();
   const state = subcNudgeLogState.get(key);
   if (state && now - state.lastEmittedAt < SUBC_NUDGE_LOG_INTERVAL_MS) {
@@ -31703,13 +31968,59 @@ function logSubcNudgeLifecycle(drainContext, kind, message) {
   }
   const suppressed = state?.suppressed ?? 0;
   subcNudgeLogState.set(key, { lastEmittedAt: now, suppressed: 0 });
-  sessionLog(drainContext.sessionID, `${LOG_PREFIX} ${message}`, {
-    event: "subc_bg_nudge_delivery",
-    cause: kind,
+  const payload = {
+    ...data,
     canonical_root: drainContext.directory,
     suppressed
+  };
+  if (level === "warn") {
+    sessionWarn(drainContext.sessionID, `${LOG_PREFIX} ${message}`, payload);
+  } else {
+    sessionLog(drainContext.sessionID, `${LOG_PREFIX} ${message}`, payload);
+  }
+}
+function logPerTaskDeliveryHop(drainContext, kind, message, taskIDs, data, level = "info") {
+  for (const taskID of taskIDs) {
+    logDeliveryHop(drainContext, kind, message, { ...data, task_id: taskID, task_ids: taskIDs }, level);
+  }
+}
+function rearmHardStoppedWake(state, drainContext) {
+  if (!state.wakeHardStopped)
+    return;
+  state.wakeHardStopped = false;
+  state.wakeRetryAttempts = 0;
+  state.retryDelayMs = null;
+  logDeliveryHop(drainContext, "inject-rearmed", "delivery retry re-armed", {
+    event: "bash_completion_inject_rearmed",
+    task_ids: state.pendingCompletions.map((completion) => completion.task_id)
   });
 }
+async function withBgHopTimeout(operation, label) {
+  let timer;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out after ${bgHopTimeoutMs}ms`)), bgHopTimeoutMs);
+        timer.unref?.();
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+function promptAsyncFailure(response) {
+  if (!response || typeof response !== "object" || Array.isArray(response))
+    return null;
+  const record2 = response;
+  if (record2.error != null) {
+    return typeof record2.error === "string" ? record2.error : JSON.stringify(record2.error);
+  }
+  if (record2.success === false)
+    return String(record2.message ?? "promptAsync returned success=false");
+  return null;
+}
 async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredCompletions = true, forceDrain = false) {
   const state = stateFor(drainContext.sessionID);
   if (!skipDrain && (forceDrain || state.outstandingTaskIds.size > 0 || !state.forcedDrainCompleted)) {
@@ -31732,11 +32043,12 @@ async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredComp
       }
       return drainContext.client;
     };
-    const sendPrompt = async (client2) => {
-      if (typeof client2.session?.promptAsync !== "function") {
+    const sendPrompt = async (client) => {
+      const promptAsync = client.session?.promptAsync;
+      if (typeof promptAsync !== "function") {
         throw new Error("wake client.session.promptAsync is unavailable");
       }
-      const promptContext = await resolvePromptContext(client2, drainContext.sessionID);
+      const promptContext = await resolvePromptContext(client, drainContext.sessionID);
       const body = {
         noReply: false,
         parts: [{ type: "text", text: reminder, synthetic: true }]
@@ -31751,52 +32063,73 @@ async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredComp
       }
       if (promptContext?.variant)
         body.variant = promptContext.variant;
-      const deliveryID2 = `aftdel_${randomUUID2()}`;
-      const wakeMeta = {
-        delivery_id: deliveryID2,
-        attempt: state.wakeRetryAttempts + 1,
-        task_ids: taskIDs,
-        directory: drainContext.directory,
-        reminder_sha256: hashReminder(reminder),
-        reminder_chars: reminder.length,
-        prompt_context: promptContext ? {
-          agent: promptContext.agent,
-          model: promptContext.model ? {
-            providerID: promptContext.model.providerID,
-            modelID: promptContext.model.modelID
-          } : null,
-          variant: promptContext.variant ?? null
-        } : null
-      };
-      sessionLog(drainContext.sessionID, `${LOG_PREFIX} wake promptAsync start`, {
-        event: "bash_completion_wake_prompt_async_start",
-        ...wakeMeta
-      });
-      try {
-        await client2.session.promptAsync({
-          path: { id: drainContext.sessionID },
-          body
-        });
-      } catch (err) {
-        sessionWarn(drainContext.sessionID, `${LOG_PREFIX} wake promptAsync error`, {
-          event: "bash_completion_wake_prompt_async_error",
+      const attemptPrompt = async (attemptBody, mode) => {
+        const deliveryID2 = `aftdel_${randomUUID2()}`;
+        const wakeMeta = {
           delivery_id: deliveryID2,
           attempt: state.wakeRetryAttempts + 1,
           task_ids: taskIDs,
-          error: err instanceof Error ? err.message : String(err)
+          directory: drainContext.directory,
+          reminder_sha256: hashReminder(reminder),
+          reminder_chars: reminder.length,
+          injection_mode: mode,
+          prompt_context: promptContext ? {
+            agent: promptContext.agent,
+            model: promptContext.model ? {
+              providerID: promptContext.model.providerID,
+              modelID: promptContext.model.modelID
+            } : null,
+            variant: promptContext.variant ?? null
+          } : null
+        };
+        logPerTaskDeliveryHop(drainContext, `inject-start-${mode}`, "session inject start", taskIDs, { event: "bash_completion_wake_prompt_async_start", ...wakeMeta });
+        try {
+          const response = await withBgHopTimeout(Promise.resolve(promptAsync({
+            path: { id: drainContext.sessionID },
+            body: attemptBody
+          })), "session promptAsync injection");
+          const failure = promptAsyncFailure(response);
+          if (failure)
+            throw new Error(failure);
+        } catch (err) {
+          logPerTaskDeliveryHop(drainContext, "inject-error", "session inject failed", taskIDs, {
+            event: "bash_completion_wake_prompt_async_error",
+            delivery_id: deliveryID2,
+            attempt: state.wakeRetryAttempts + 1,
+            injection_mode: mode,
+            cause: err instanceof Error ? err.message : String(err)
+          }, "warn");
+          throw err;
+        }
+        logPerTaskDeliveryHop(drainContext, `inject-ok-${mode}`, "session inject ok", taskIDs, {
+          event: "bash_completion_wake_prompt_async_ok",
+          delivery_id: deliveryID2,
+          attempt: state.wakeRetryAttempts + 1,
+          injection_mode: mode
         });
-        throw err;
+        return deliveryID2;
+      };
+      try {
+        return await attemptPrompt(body, "mirrored-context");
+      } catch (err) {
+        if (!promptContext?.model)
+          throw err;
+        const fallbackBody = { ...body };
+        delete fallbackBody.model;
+        delete fallbackBody.variant;
+        return attemptPrompt(fallbackBody, "model-free-fallback");
       }
-      sessionLog(drainContext.sessionID, `${LOG_PREFIX} wake promptAsync ok`, {
-        event: "bash_completion_wake_prompt_async_ok",
-        delivery_id: deliveryID2,
-        attempt: state.wakeRetryAttempts + 1,
-        task_ids: taskIDs
-      });
-      return deliveryID2;
     };
-    const client = getInProcessClient();
-    const deliveryID = await sendPrompt(client);
+    let deliveryID;
+    try {
+      deliveryID = await sendPrompt(getInProcessClient());
+    } catch (err) {
+      logPerTaskDeliveryHop(drainContext, "inject-error", "session inject failed", taskIDs, {
+        event: "bash_completion_wake_prompt_async_error",
+        cause: err instanceof Error ? err.message : String(err)
+      }, "warn");
+      throw err;
+    }
     markDeliveredAwaitingAck(state, taskIDs);
     const acked = await ackCompletions(drainContext, deliveredCompletions, deliveryID);
     if (acked)
@@ -31812,7 +32145,12 @@ async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredComp
       });
       return;
     }
-    sessionWarn(drainContext.sessionID, hardStopped ? `${LOG_PREFIX} wake send failed ${MAX_WAKE_SEND_ATTEMPTS} times; stopping retries: ${err instanceof Error ? err.message : String(err)}` : `${LOG_PREFIX} wake send failed: ${err instanceof Error ? err.message : String(err)}`);
+    if (hardStopped) {
+      logDeliveryHop(drainContext, "inject-hard-stopped", "delivery retries paused", {
+        event: "bash_completion_inject_hard_stopped",
+        cause: err instanceof Error ? err.message : String(err)
+      });
+    }
   }, drainContext.sessionID, includeDeferredCompletions);
 }
 function formatSystemReminder(completions) {
@@ -31899,14 +32237,21 @@ async function drainCompletions(drainContext) {
   try {
     const bridge = bridgeForDrain(drainContext);
     const state = stateFor(drainContext.sessionID);
-    const response = await bridge.send("bash_drain_completions", {
-      session_id: drainContext.sessionID
-    });
+    const response = await withBgHopTimeout(bridge.send("bash_drain_completions", { session_id: drainContext.sessionID }, { timeoutMs: bgHopTimeoutMs }), "bash_drain_completions");
     if (response.success === false) {
-      sessionWarn(drainContext.sessionID, `${LOG_PREFIX} drain failed: ${String(response.message ?? "unknown error")}`);
+      logDeliveryHop(drainContext, "drain-error", "drain failed", {
+        event: "bash_completion_drain_error",
+        cause: String(response.message ?? "unknown error")
+      }, "warn");
       return;
     }
     state.forcedDrainCompleted = true;
+    const drainedTaskIds = Array.isArray(response.bg_completions) ? response.bg_completions.filter(isBgCompletion).map((completion) => completion.task_id) : [];
+    logDeliveryHop(drainContext, "drain-ok", "drain ok", {
+      event: "bash_completion_drain_ok",
+      count: drainedTaskIds.length,
+      task_ids: drainedTaskIds
+    });
     const reackTaskIds = reconcileAwaitingAck(state, response.bg_completions);
     ingestDrainedBgCompletions(drainContext.sessionID, response.bg_completions);
     if (reackTaskIds.length > 0) {
@@ -31922,7 +32267,10 @@ async function drainCompletions(drainContext) {
   } catch (err) {
     if (drainContext.nudgeRef && isTerminalNudgeError(err))
       throw err;
-    sessionWarn(drainContext.sessionID, `${LOG_PREFIX} drain failed: ${err instanceof Error ? err.message : String(err)}`);
+    logDeliveryHop(drainContext, "drain-error", "drain failed", {
+      event: "bash_completion_drain_error",
+      cause: err instanceof Error ? err.message : String(err)
+    }, "warn");
   }
 }
 async function ackCompletions(drainContext, completions, deliveryID) {
@@ -31931,24 +32279,26 @@ async function ackCompletions(drainContext, completions, deliveryID) {
     return true;
   try {
     const bridge = bridgeForDrain(drainContext);
-    const response = await bridge.send("bash_ack_completions", {
-      session_id: drainContext.sessionID,
-      task_ids: taskIds
-    });
+    const response = await withBgHopTimeout(bridge.send("bash_ack_completions", { session_id: drainContext.sessionID, task_ids: taskIds }, { timeoutMs: bgHopTimeoutMs }), "bash_ack_completions");
     if (response.success === false) {
-      sessionWarn(drainContext.sessionID, `${LOG_PREFIX} ack failed: ${String(response.message ?? "unknown error")}`);
+      logPerTaskDeliveryHop(drainContext, "ack-error", "ack failed", taskIds, {
+        event: "bash_completion_ack_error",
+        cause: String(response.message ?? "unknown error")
+      }, "warn");
       return false;
     }
-    sessionLog(drainContext.sessionID, `${LOG_PREFIX} ack ok`, {
+    logPerTaskDeliveryHop(drainContext, "ack-ok", "ack ok", taskIds, {
       event: "bash_completion_ack_ok",
-      delivery_id: deliveryID ?? null,
-      task_ids: taskIds
+      delivery_id: deliveryID ?? null
     });
     return true;
   } catch (err) {
     if (drainContext.nudgeRef && isTerminalNudgeError(err))
       throw err;
-    sessionWarn(drainContext.sessionID, `${LOG_PREFIX} ack failed: ${err instanceof Error ? err.message : String(err)}`);
+    logPerTaskDeliveryHop(drainContext, "ack-error", "ack failed", taskIds, {
+      event: "bash_completion_ack_error",
+      cause: err instanceof Error ? err.message : String(err)
+    }, "warn");
     return false;
   }
 }
@@ -32540,6 +32890,15 @@ async function callBashBridge(ctx, runtime, command, params = {}, options) {
 // src/bash-wait-detach.ts
 var BASH_WAIT_DETACH_MAGIC_KEYWORD = "&detach";
 var EMPTY_DETACH_MESSAGE = "(requested background detach)";
+var STANDALONE_DETACH_KEYWORD_SOURCE = `(^|[^\\p{L}\\p{N}_])${BASH_WAIT_DETACH_MAGIC_KEYWORD}(?![\\p{L}\\p{N}_])`;
+var STANDALONE_DETACH_KEYWORD_PATTERN = new RegExp(STANDALONE_DETACH_KEYWORD_SOURCE, "u");
+var STANDALONE_DETACH_KEYWORDS_PATTERN = new RegExp(STANDALONE_DETACH_KEYWORD_SOURCE, "gu");
+function containsStandaloneDetachKeyword(messageText) {
+  return STANDALONE_DETACH_KEYWORD_PATTERN.test(messageText);
+}
+function stripStandaloneDetachKeywords(messageText) {
+  return messageText.replace(STANDALONE_DETACH_KEYWORDS_PATTERN, "$1");
+}
 function userTextParts(output) {
   if (!output || typeof output !== "object")
     return [];
@@ -32561,9 +32920,9 @@ function stripUserMessageDetachKeyword(output) {
   const parts = userTextParts(output);
   const original = parts.map((part) => part.text).join(`
 `);
-  if (!original.includes(BASH_WAIT_DETACH_MAGIC_KEYWORD))
+  if (!containsStandaloneDetachKeyword(original))
     return original;
-  const stripped = parts.map((part) => part.text.replaceAll(BASH_WAIT_DETACH_MAGIC_KEYWORD, "")).map((text) => text.replace(/[ \t]{2,}/g, " "));
+  const stripped = parts.map((part) => stripStandaloneDetachKeywords(part.text)).map((text) => text.replace(/[ \t]{2,}/g, " "));
   if (stripped.join(`
 `).trim() === "") {
     if (parts[0])
@@ -32579,7 +32938,7 @@ function stripUserMessageDetachKeyword(output) {
 `);
 }
 function shouldDetachBashWaitOnUserMessage(config2, messageText) {
-  return resolveBashConfig(config2).detach_on_user_message || messageText.includes(BASH_WAIT_DETACH_MAGIC_KEYWORD);
+  return resolveBashConfig(config2).detach_on_user_message || containsStandaloneDetachKeyword(messageText);
 }
 async function sendBashWaitDetach(bridge, sessionID) {
   const response = await bridge.send("bash_wait_detach", { session_id: sessionID }, { keepBridgeOnTimeout: true, transportTimeoutMs: BASH_TRANSPORT_TIMEOUT_MS });
@@ -33169,40 +33528,32 @@ import {
 import { dirname as dirname8 } from "node:path";
 
 // src/hooks/auto-update-checker/cache.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import { cpSync, existsSync as existsSync14, mkdtempSync, readFileSync as readFileSync10, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { basename as basename3, dirname as dirname7, join as join16 } from "node:path";
 var import_comment_json3 = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/checker.ts
-var import_comment_json2 = __toESM(require_src2(), 1);
 import { existsSync as existsSync13, readFileSync as readFileSync9, statSync as statSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
 import { dirname as dirname6, isAbsolute as isAbsolute8, join as join15, resolve as resolve9 } from "node:path";
 import { fileURLToPath } from "node:url";
+var import_comment_json2 = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/constants.ts
-import { homedir as homedir13, platform as platform2 } from "node:os";
 import { join as join14 } from "node:path";
 var PACKAGE_NAME = "@cortexkit/aft-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var NPM_FETCH_TIMEOUT = 1e4;
-function getOpenCodeCacheRoot() {
-  if (platform2() === "win32") {
-    return join14(process.env.LOCALAPPDATA ?? homedir13(), "opencode");
-  }
-  return join14(homedir13(), ".cache", "opencode");
+function cacheDir() {
+  return join14(getOpenCodeCacheRoot(), "packages");
 }
-function getOpenCodeConfigRoot() {
-  if (platform2() === "win32") {
-    return join14(process.env.APPDATA ?? join14(homedir13(), "AppData", "Roaming"), "opencode");
-  }
-  return join14(process.env.XDG_CONFIG_HOME ?? join14(homedir13(), ".config"), "opencode");
+function userOpenCodeConfig() {
+  return join14(getOpenCodeConfigRoot(), "opencode.json");
+}
+function userOpenCodeConfigJsonc() {
+  return join14(getOpenCodeConfigRoot(), "opencode.jsonc");
 }
-var CACHE_DIR = join14(getOpenCodeCacheRoot(), "packages");
-var USER_OPENCODE_CONFIG = join14(getOpenCodeConfigRoot(), "opencode.json");
-var USER_OPENCODE_CONFIG_JSONC = join14(getOpenCodeConfigRoot(), "opencode.jsonc");
 
 // src/hooks/auto-update-checker/types.ts
 var NpmPackageEnvelopeSchema = exports_external.object({
@@ -33262,8 +33613,8 @@ function getConfigPaths(directory) {
   return [
     join15(directory, ".opencode", "opencode.json"),
     join15(directory, ".opencode", "opencode.jsonc"),
-    USER_OPENCODE_CONFIG,
-    USER_OPENCODE_CONFIG_JSONC
+    userOpenCodeConfig(),
+    userOpenCodeConfigJsonc()
   ];
 }
 function resolvePathPluginSpec(spec, configPath) {
@@ -33368,7 +33719,7 @@ function findPluginEntry(directory) {
 }
 var cachedPackageVersion = null;
 function getSpecCachePackageJsonPath(spec) {
-  return join15(CACHE_DIR, spec, "node_modules", PACKAGE_NAME, "package.json");
+  return join15(cacheDir(), spec, "node_modules", PACKAGE_NAME, "package.json");
 }
 function getCachedVersion(spec) {
   if (!spec && cachedPackageVersion)
@@ -33377,7 +33728,7 @@ function getCachedVersion(spec) {
     getCurrentRuntimePackageJsonPath(),
     spec ? getSpecCachePackageJsonPath(spec) : null,
     getSpecCachePackageJsonPath(`${PACKAGE_NAME}@latest`),
-    join15(homedir14(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
+    join15(getOpenCodeCacheRoot(), "node_modules", PACKAGE_NAME, "package.json")
   ].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
@@ -33424,6 +33775,7 @@ async function getLatestVersion(channel = "latest", options = {}) {
 
 // src/hooks/auto-update-checker/cache.ts
 var pendingSnapshots = new Map;
+var quarantinedInstallDirs = new Set;
 function createAutoUpdateSnapshot(installDir, packageJsonPath, packageName) {
   const packageDir = join16(installDir, "node_modules", packageName);
   const lockfilePath = join16(installDir, "package-lock.json");
@@ -33517,6 +33869,13 @@ function ensureDependencyVersion(packageJsonPath, packageName, version2) {
     return false;
   }
 }
+function restorePendingSnapshot(installDir) {
+  const snapshot = pendingSnapshots.get(installDir);
+  if (!snapshot)
+    return;
+  pendingSnapshots.delete(installDir);
+  restoreAutoUpdateSnapshot(snapshot);
+}
 function removeInstalledPackage(installDir, packageName) {
   const packageDir = join16(installDir, "node_modules", packageName);
   if (!existsSync14(packageDir))
@@ -33537,9 +33896,10 @@ function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackage
     }
     return null;
   }
-  const legacyPackageJsonPath = join16(dirname7(CACHE_DIR), "package.json");
+  const cacheRoot = dirname7(cacheDir());
+  const legacyPackageJsonPath = join16(cacheRoot, "package.json");
   if (existsSync14(legacyPackageJsonPath)) {
-    return { installDir: dirname7(CACHE_DIR), packageJsonPath: legacyPackageJsonPath };
+    return { installDir: cacheRoot, packageJsonPath: legacyPackageJsonPath };
   }
   return null;
 }
@@ -33550,6 +33910,12 @@ function preparePackageUpdate(version2, packageName = PACKAGE_NAME, runtimePacka
       warn2("[auto-update-checker] No install context found for auto-update");
       return null;
     }
+    if (quarantinedInstallDirs.has(installContext.installDir)) {
+      const recoverySnapshot = pendingSnapshots.get(installContext.installDir);
+      const recoveryDetail = recoverySnapshot ? ` Recovery snapshot: ${recoverySnapshot.tempDir}` : "";
+      warn2(`[auto-update-checker] Auto-update blocked after unconfirmed npm termination; ` + `restart OpenCode to retry.${recoveryDetail}`);
+      return null;
+    }
     const snapshot = createAutoUpdateSnapshot(installContext.installDir, installContext.packageJsonPath, packageName);
     pendingSnapshots.set(installContext.installDir, snapshot);
     if (!ensureDependencyVersion(installContext.packageJsonPath, packageName, version2)) {
@@ -33573,18 +33939,29 @@ async function runNpmInstallSafe(installDir, options = {}) {
   let timeout = null;
   let stderrTail = "";
   try {
-    if (options.signal?.aborted)
+    if (options.signal?.aborted) {
+      restorePendingSnapshot(installDir);
       return { ok: false, reason: "aborted" };
+    }
     const npm = resolveNpm();
     if (!npm) {
+      restorePendingSnapshot(installDir);
       const reason = "npm not found on PATH or in known version-manager locations";
       warnNpmInstallFailure(reason, stderrTail);
       return { ok: false, reason };
     }
-    const proc = spawn3(npm.command, ["install", "--no-audit", "--no-fund", "--no-progress", "--ignore-scripts"], {
+    const invocation = npmInvocation(npm, [
+      "install",
+      "--no-audit",
+      "--no-fund",
+      "--no-progress",
+      "--ignore-scripts"
+    ]);
+    const proc = spawn4(invocation.command, invocation.args, {
       cwd: installDir,
       stdio: ["ignore", "pipe", "pipe"],
-      env: npmSpawnEnv(npm)
+      env: { ...npmSpawnEnv(npm), ...invocation.env },
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments
     });
     proc.stderr?.on("data", (chunk) => {
       stderrTail += chunk.toString("utf8");
@@ -33593,12 +33970,11 @@ async function runNpmInstallSafe(installDir, options = {}) {
       }
     });
     proc.stdout?.on("data", () => {});
+    let terminationPromise = null;
     const abortProcess = () => {
-      try {
-        proc.kill();
-      } catch {}
+      terminationPromise ??= terminateNpmProcessTree(proc, invocation);
+      return terminationPromise;
     };
-    options.signal?.addEventListener("abort", abortProcess, { once: true });
     const exitPromise = new Promise((resolveExit) => {
       proc.on("error", (err) => resolveExit({ ok: false, reason: `spawn error: ${String(err)}` }));
       proc.on("exit", (code) => resolveExit(code === 0 ? { ok: true } : { ok: false, reason: `npm install exited with code ${code ?? "signal/unknown"}` }));
@@ -33606,16 +33982,29 @@ async function runNpmInstallSafe(installDir, options = {}) {
     const timeoutPromise = new Promise((resolveTimeout) => {
       timeout = setTimeout(() => resolveTimeout("timeout"), options.timeoutMs ?? 60000);
     });
-    const result = await Promise.race([exitPromise, timeoutPromise]);
-    options.signal?.removeEventListener("abort", abortProcess);
-    if (result === "timeout" || options.signal?.aborted) {
-      abortProcess();
-      const snapshot2 = pendingSnapshots.get(installDir);
-      if (snapshot2) {
-        pendingSnapshots.delete(installDir);
-        restoreAutoUpdateSnapshot(snapshot2);
-      }
-      const reason = options.signal?.aborted ? "aborted" : "timeout";
+    let resolveAbort;
+    const abortPromise = new Promise((resolve10) => {
+      resolveAbort = resolve10;
+    });
+    const onAbort = () => resolveAbort("abort");
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    if (options.signal?.aborted)
+      onAbort();
+    const result = await Promise.race([exitPromise, timeoutPromise, abortPromise]);
+    options.signal?.removeEventListener("abort", onAbort);
+    if (result === "timeout" || result === "abort") {
+      try {
+        await abortProcess();
+      } catch (error53) {
+        quarantinedInstallDirs.add(installDir);
+        const recoverySnapshot = pendingSnapshots.get(installDir);
+        const recoveryDetail = recoverySnapshot ? `; auto-update quarantined for this session; recovery snapshot: ${recoverySnapshot.tempDir}` : "; auto-update quarantined for this session";
+        const reason2 = `termination outcome unknown: ${String(error53)}${recoveryDetail}`;
+        warnNpmInstallFailure(reason2, stderrTail);
+        return { ok: false, reason: reason2, stderrTail: stderrTail || undefined };
+      }
+      restorePendingSnapshot(installDir);
+      const reason = result === "abort" ? "aborted" : "timeout";
       warnNpmInstallFailure(reason, stderrTail);
       return { ok: false, reason, stderrTail: stderrTail || undefined };
     }
@@ -33631,11 +34020,7 @@ async function runNpmInstallSafe(installDir, options = {}) {
     }
     return { ...result, stderrTail: stderrTail || undefined };
   } catch (err) {
-    const snapshot = pendingSnapshots.get(installDir);
-    if (snapshot) {
-      pendingSnapshots.delete(installDir);
-      restoreAutoUpdateSnapshot(snapshot);
-    }
+    restorePendingSnapshot(installDir);
     const reason = `exception: ${String(err)}`;
     warnNpmInstallFailure(reason, stderrTail);
     return { ok: false, reason, stderrTail: stderrTail || undefined };
@@ -33910,7 +34295,7 @@ function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
 }
 
 // src/lsp-auto-install.ts
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import {
   createReadStream,
@@ -33925,6 +34310,7 @@ import {
 import { join as join19 } from "node:path";
 
 // src/lsp-cache.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
 import {
   closeSync as closeSync6,
   mkdirSync as mkdirSync7,
@@ -34006,27 +34392,46 @@ var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
   mkdirSync7(lspPackageDir(lockKey), { recursive: true });
   const lock = lockPath(lockKey);
+  const token = randomUUID3();
   const tryClaim = () => {
     try {
       const fd = openSync6(lock, "wx");
       try {
         writeFileSync8(fd, `${process.pid}
 ${new Date().toISOString()}
+${token}
 `);
       } finally {
         closeSync6(fd);
       }
-      return true;
+      let retained = false;
+      let released = false;
+      return {
+        retain() {
+          retained = true;
+        },
+        release() {
+          if (released)
+            return;
+          released = true;
+          if (retained) {
+            warn2(`[lsp] retaining install lock for ${lockKey} after unconfirmed npm termination; ` + `cross-process retries remain blocked until stale-lock recovery`);
+            return;
+          }
+          releaseInstallLock(lockKey, token);
+        }
+      };
     } catch (err) {
       const code = err.code;
       if (code === "EEXIST")
-        return false;
+        return null;
       warn2(`[lsp] unexpected error acquiring install lock for ${lockKey}: ${err}`);
-      return false;
+      return null;
     }
   };
-  if (tryClaim())
-    return true;
+  const claimed = tryClaim();
+  if (claimed)
+    return claimed;
   let owningPid = null;
   let lockMtimeMs = 0;
   try {
@@ -34044,7 +34449,7 @@ ${new Date().toISOString()}
   const skipLiveness = process.platform === "win32";
   const ownerAlive = !skipLiveness && owningPid !== null && isProcessAlive3(owningPid);
   if (skipLiveness ? ageWithinFresh : ownerAlive && ageWithinFresh) {
-    return false;
+    return null;
   }
   log2(`[lsp] reclaiming install lock for ${lockKey} (owner_pid=${owningPid ?? "unknown"}, alive=${ownerAlive}, age_ms=${age})`);
   try {
@@ -34063,16 +34468,18 @@ function isProcessAlive3(pid) {
     return true;
   }
 }
-function releaseInstallLock(lockKey) {
+function releaseInstallLock(lockKey, acquisitionToken) {
   const lock = lockPath(lockKey);
   try {
     let owningPid = null;
+    let owningToken = "";
     try {
       const raw = readFileSync12(lock, "utf8");
-      const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
-      const parsed = Number.parseInt(firstLine, 10);
+      const lines = raw.split(/\r?\n/);
+      const parsed = Number.parseInt(lines[0]?.trim() ?? "", 10);
       if (Number.isFinite(parsed) && parsed > 0)
         owningPid = parsed;
+      owningToken = lines[2]?.trim() ?? "";
     } catch (readErr) {
       const code = readErr.code;
       if (code === "ENOENT")
@@ -34080,8 +34487,8 @@ function releaseInstallLock(lockKey) {
       warn2(`[lsp] could not read install lock for ${lockKey} during release: ${readErr}`);
       return;
     }
-    if (owningPid !== process.pid) {
-      log2(`[lsp] not releasing install lock for ${lockKey}: owned by pid ${owningPid ?? "unknown"} (we are ${process.pid})`);
+    if (owningPid !== process.pid || owningToken !== acquisitionToken) {
+      log2(`[lsp] not releasing install lock for ${lockKey}: acquisition ownership changed`);
       return;
     }
     try {
@@ -34097,12 +34504,13 @@ function releaseInstallLock(lockKey) {
   }
 }
 async function withInstallLock(lockKey, task) {
-  if (!acquireInstallLock(lockKey))
+  const lease = acquireInstallLock(lockKey);
+  if (!lease)
     return null;
   try {
-    return await task();
+    return await task(lease);
   } finally {
-    releaseInstallLock(lockKey);
+    lease.release();
   }
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
@@ -34447,6 +34855,7 @@ function buildExtensionMap(specs) {
   return byExt;
 }
 var inFlightAutoInstalls = new Set;
+var quarantinedNpmInstalls = new Set;
 function trackInFlightAutoInstall(controller, promise2) {
   const entry = { controller, promise: promise2 };
   inFlightAutoInstalls.add(entry);
@@ -34494,7 +34903,7 @@ function ensureInstallAnchor(cwd) {
     warn2(`[lsp] could not write package.json stub in ${cwd}: ${err}`);
   }
 }
-function runInstall(spec, version2, cwd, signal) {
+function runInstall(spec, version2, cwd, installLock, signal) {
   return new Promise((resolve10) => {
     const target = `${spec.npm}@${version2}`;
     log2(`[lsp] installing ${target} to ${cwd}`);
@@ -34510,19 +34919,25 @@ function runInstall(spec, version2, cwd, signal) {
       return;
     }
     ensureInstallAnchor(cwd);
-    const child = spawn4(npm.command, ["install", "--no-save", "--ignore-scripts", "--silent", target], {
+    const invocation = npmInvocation(npm, [
+      "install",
+      "--no-save",
+      "--ignore-scripts",
+      "--silent",
+      target
+    ]);
+    const child = spawn5(invocation.command, invocation.args, {
       stdio: ["ignore", "pipe", "pipe"],
       cwd,
-      env: npmSpawnEnv(npm)
+      env: { ...npmSpawnEnv(npm), ...invocation.env },
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments
     });
     child.unref();
     let stderrBuf = "";
     let settled = false;
-    let killTimer = null;
+    let terminationPromise = null;
     const cleanup = () => {
       signal?.removeEventListener("abort", onAbort);
-      if (killTimer)
-        clearTimeout(killTimer);
     };
     const finish = (ok) => {
       if (settled)
@@ -34531,14 +34946,31 @@ function runInstall(spec, version2, cwd, signal) {
       cleanup();
       resolve10(ok);
     };
+    const childCompletedSuccessfully = () => child.exitCode === 0 && child.signalCode === null;
+    const finishAfterConfirmedTermination = () => {
+      const completedSuccessfully = childCompletedSuccessfully();
+      if (completedSuccessfully)
+        log2(`[lsp] installed ${target}`);
+      finish(completedSuccessfully);
+    };
     const onAbort = () => {
+      if (childCompletedSuccessfully()) {
+        finishAfterConfirmedTermination();
+        return;
+      }
       warn2(`[lsp] install ${target} aborted during shutdown`);
-      child.kill("SIGTERM");
-      killTimer = setTimeout(() => {
-        if (!settled)
-          child.kill("SIGKILL");
-      }, 5000);
-      killTimer.unref?.();
+      terminationPromise ??= terminateNpmProcessTree(child, invocation);
+      terminationPromise.then(finishAfterConfirmedTermination, (terminationError) => {
+        if (child.pid === undefined) {
+          error52(`[lsp] install ${target} failed to spawn during shutdown: ${terminationError}`);
+          finish(false);
+          return;
+        }
+        quarantinedNpmInstalls.add(spec.npm);
+        installLock.retain();
+        error52(`[lsp] install ${target} termination outcome unknown; quarantining retries for this session: ${String(terminationError)}`);
+        finish(false);
+      });
     };
     signal?.addEventListener("abort", onAbort, { once: true });
     if (signal?.aborted)
@@ -34552,10 +34984,16 @@ function runInstall(spec, version2, cwd, signal) {
       }
     });
     child.on("error", (err) => {
-      error52(`[lsp] install ${target} failed to spawn: ${err}`);
+      if (settled)
+        return;
+      error52(`[lsp] install ${target} child-process error: ${err}`);
+      if (terminationPromise && child.pid !== undefined)
+        return;
       finish(false);
     });
     child.on("exit", (code) => {
+      if (settled || terminationPromise)
+        return;
       if (code === 0) {
         log2(`[lsp] installed ${target}`);
         finish(true);
@@ -34568,7 +35006,13 @@ ${stderrBuf.trim()}`);
   });
 }
 async function ensureServerInstalled(spec, config2, fetchImpl, signal) {
-  const outcome = await withInstallLock(spec.npm, async () => {
+  if (quarantinedNpmInstalls.has(spec.npm)) {
+    return {
+      started: false,
+      reason: "install blocked after unconfirmed npm termination; restart the host to retry"
+    };
+  }
+  const outcome = await withInstallLock(spec.npm, async (installLock) => {
     const { version: version2, probe } = await resolveTargetVersion(spec, config2, fetchImpl);
     if (!version2) {
       const installed = isInstalled(spec.npm, spec.binary);
@@ -34604,7 +35048,7 @@ async function ensureServerInstalled(spec, config2, fetchImpl, signal) {
         log2(`[lsp] reinstalling ${spec.npm}@${version2}: no installed-version metadata recorded`);
       }
     }
-    const ok = await runInstall(spec, version2, cachedPackageDir(spec.npm), signal).catch((err) => {
+    const ok = await runInstall(spec, version2, cachedPackageDir(spec.npm), installLock, signal).catch((err) => {
       error52(`[lsp] background install ${spec.npm} crashed: ${err}`);
       return false;
     });
@@ -34787,69 +35231,69 @@ import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 
 // src/lsp-github-table.ts
-function exe(platform3, name) {
-  return platform3 === "win32" ? `${name}.exe` : name;
+function exe(platform2, name) {
+  return platform2 === "win32" ? `${name}.exe` : name;
 }
 var CLANGD = {
   id: "clangd",
   githubRepo: "clangd/clangd",
   binary: "clangd",
-  resolveAsset: (platform3, _arch, version2) => {
-    const platformName = platform3 === "darwin" ? "mac" : platform3 === "linux" ? "linux" : "windows";
+  resolveAsset: (platform2, _arch, version2) => {
+    const platformName = platform2 === "darwin" ? "mac" : platform2 === "linux" ? "linux" : "windows";
     return { name: `clangd-${platformName}-${version2}.zip`, archive: "zip" };
   },
-  binaryPathInArchive: (platform3, _arch, version2) => `clangd_${version2}/bin/${exe(platform3, "clangd")}`
+  binaryPathInArchive: (platform2, _arch, version2) => `clangd_${version2}/bin/${exe(platform2, "clangd")}`
 };
 var LUA_LS = {
   id: "lua-ls",
   githubRepo: "LuaLS/lua-language-server",
   binary: "lua-language-server",
-  resolveAsset: (platform3, arch, version2) => {
-    const ext = platform3 === "win32" ? "zip" : "tar.gz";
-    const platformName = platform3 === "darwin" ? "darwin" : platform3 === "linux" ? "linux" : "win32";
+  resolveAsset: (platform2, arch, version2) => {
+    const ext = platform2 === "win32" ? "zip" : "tar.gz";
+    const platformName = platform2 === "darwin" ? "darwin" : platform2 === "linux" ? "linux" : "win32";
     const archName = arch === "arm64" ? "arm64" : "x64";
     return {
       name: `lua-language-server-${version2}-${platformName}-${archName}.${ext}`,
       archive: ext
     };
   },
-  binaryPathInArchive: (platform3, _arch, _version) => `bin/${exe(platform3, "lua-language-server")}`
+  binaryPathInArchive: (platform2, _arch, _version) => `bin/${exe(platform2, "lua-language-server")}`
 };
 var ZLS = {
   id: "zls",
   githubRepo: "zigtools/zls",
   binary: "zls",
-  resolveAsset: (platform3, arch, _version) => {
-    const ext = platform3 === "win32" ? "zip" : "tar.xz";
+  resolveAsset: (platform2, arch, _version) => {
+    const ext = platform2 === "win32" ? "zip" : "tar.xz";
     const archName = arch === "arm64" ? "aarch64" : "x86_64";
-    const platformName = platform3 === "darwin" ? "macos" : platform3 === "linux" ? "linux" : "windows";
+    const platformName = platform2 === "darwin" ? "macos" : platform2 === "linux" ? "linux" : "windows";
     return { name: `zls-${archName}-${platformName}.${ext}`, archive: ext };
   },
-  binaryPathInArchive: (platform3, _arch, _version) => exe(platform3, "zls")
+  binaryPathInArchive: (platform2, _arch, _version) => exe(platform2, "zls")
 };
 var TINYMIST = {
   id: "tinymist",
   githubRepo: "Myriad-Dreamin/tinymist",
   binary: "tinymist",
-  resolveAsset: (platform3, arch, _version) => {
+  resolveAsset: (platform2, arch, _version) => {
     const archName = arch === "arm64" ? "aarch64" : "x86_64";
-    const triple = platform3 === "darwin" ? "apple-darwin" : platform3 === "linux" ? "unknown-linux-gnu" : "pc-windows-msvc";
-    const ext = platform3 === "win32" ? "zip" : "tar.gz";
+    const triple = platform2 === "darwin" ? "apple-darwin" : platform2 === "linux" ? "unknown-linux-gnu" : "pc-windows-msvc";
+    const ext = platform2 === "win32" ? "zip" : "tar.gz";
     return { name: `tinymist-${archName}-${triple}.${ext}`, archive: ext };
   },
-  binaryPathInArchive: (platform3, _arch, _version) => exe(platform3, "tinymist")
+  binaryPathInArchive: (platform2, _arch, _version) => exe(platform2, "tinymist")
 };
 var TEXLAB = {
   id: "texlab",
   githubRepo: "latex-lsp/texlab",
   binary: "texlab",
-  resolveAsset: (platform3, arch, _version) => {
+  resolveAsset: (platform2, arch, _version) => {
     const archName = arch === "arm64" ? "aarch64" : "x86_64";
-    const platformName = platform3 === "darwin" ? "macos" : platform3 === "linux" ? "linux" : "windows";
-    const ext = platform3 === "win32" ? "zip" : "tar.gz";
+    const platformName = platform2 === "darwin" ? "macos" : platform2 === "linux" ? "linux" : "windows";
+    const ext = platform2 === "win32" ? "zip" : "tar.gz";
     return { name: `texlab-${archName}-${platformName}.${ext}`, archive: ext };
   },
-  binaryPathInArchive: (platform3, _arch, _version) => exe(platform3, "texlab")
+  binaryPathInArchive: (platform2, _arch, _version) => exe(platform2, "texlab")
 };
 var GITHUB_LSP_TABLE = [
   CLANGD,
@@ -34859,14 +35303,14 @@ var GITHUB_LSP_TABLE = [
   TEXLAB
 ];
 function detectHostPlatform() {
-  const platform3 = process.platform;
-  if (platform3 !== "darwin" && platform3 !== "linux" && platform3 !== "win32")
+  const platform2 = process.platform;
+  if (platform2 !== "darwin" && platform2 !== "linux" && platform2 !== "win32")
     return null;
   const arch = process.arch;
   if (arch === "x64")
-    return { platform: platform3, arch: "x64" };
+    return { platform: platform2, arch: "x64" };
   if (arch === "arm64")
-    return { platform: platform3, arch: "arm64" };
+    return { platform: platform2, arch: "arm64" };
   return null;
 }
 
@@ -34884,12 +35328,12 @@ function ghExtractDir(spec) {
   return join20(ghPackageDir(spec), "extracted");
 }
 var INSTALLED_META_FILE2 = ".aft-installed";
-function ghBinaryPath(spec, platform3) {
-  const ext = platform3 === "win32" ? ".exe" : "";
+function ghBinaryPath(spec, platform2) {
+  const ext = platform2 === "win32" ? ".exe" : "";
   return join20(ghBinDir(spec), `${spec.binary}${ext}`);
 }
-function isGithubInstalled(spec, platform3) {
-  for (const candidate of ghBinaryCandidates(spec, platform3)) {
+function isGithubInstalled(spec, platform2) {
+  for (const candidate of ghBinaryCandidates(spec, platform2)) {
     try {
       if (statSync11(join20(ghBinDir(spec), candidate)).isFile())
         return true;
@@ -34897,8 +35341,8 @@ function isGithubInstalled(spec, platform3) {
   }
   return false;
 }
-function ghBinaryCandidates(spec, platform3) {
-  if (platform3 !== "win32")
+function ghBinaryCandidates(spec, platform2) {
+  if (platform2 !== "win32")
     return [spec.binary];
   return [spec.binary, `${spec.binary}.cmd`, `${spec.binary}.exe`, `${spec.binary}.bat`];
 }
@@ -35278,10 +35722,10 @@ function quarantineCachedGithubInstall(spec, reason) {
     warn2(`[lsp] tofu_mismatch ${spec.id}: failed to quarantine cache entry: ${err}`);
   }
 }
-function validateCachedGithubInstall(spec, platform3) {
+function validateCachedGithubInstall(spec, platform2) {
   const packageDir = ghPackageDir(spec);
   const meta3 = readGithubInstalledMetaIn(packageDir);
-  const binaryPath = ghBinaryCandidates(spec, platform3).map((candidate) => join20(ghBinDir(spec), candidate)).find((candidate) => {
+  const binaryPath = ghBinaryCandidates(spec, platform2).map((candidate) => join20(ghBinDir(spec), candidate)).find((candidate) => {
     try {
       return statSync11(candidate).isFile();
     } catch {
@@ -35345,11 +35789,11 @@ function runPlatformExtractor(archivePath, destDir, archiveType) {
   }
   throw new Error(`unsupported archive type: ${archiveType}`);
 }
-async function downloadAndInstall(spec, tag, assets, platform3, arch, fetchImpl, signal) {
+async function downloadAndInstall(spec, tag, assets, platform2, arch, fetchImpl, signal) {
   const version2 = stripTagV(tag);
-  const expected = spec.resolveAsset(platform3, arch, version2);
+  const expected = spec.resolveAsset(platform2, arch, version2);
   if (!expected) {
-    warn2(`[lsp] ${spec.id}: unsupported platform/arch combo ${platform3}/${arch}`);
+    warn2(`[lsp] ${spec.id}: unsupported platform/arch combo ${platform2}/${arch}`);
     return null;
   }
   const matchingAsset = assets.find((a) => a.name === expected.name);
@@ -35399,16 +35843,16 @@ async function downloadAndInstall(spec, tag, assets, platform3, arch, fetchImpl,
       unlinkSync7(archivePath);
     } catch {}
   }
-  const innerBinaryPath = join20(extractDir, spec.binaryPathInArchive(platform3, arch, version2));
+  const innerBinaryPath = join20(extractDir, spec.binaryPathInArchive(platform2, arch, version2));
   if (!existsSync18(innerBinaryPath)) {
     error52(`[lsp] ${spec.id}: extracted binary not found at ${innerBinaryPath}`);
     return null;
   }
-  const targetBinary = ghBinaryPath(spec, platform3);
+  const targetBinary = ghBinaryPath(spec, platform2);
   mkdirSync9(dirname9(targetBinary), { recursive: true });
   try {
     copyFileSync4(innerBinaryPath, targetBinary);
-    if (platform3 !== "win32") {
+    if (platform2 !== "win32") {
       const { chmodSync: chmodSync4 } = await import("node:fs");
       chmodSync4(targetBinary, 493);
     }
@@ -35421,11 +35865,11 @@ async function downloadAndInstall(spec, tag, assets, platform3, arch, fetchImpl,
   log2(`[lsp] ${spec.id} ${tag} binary_sha256=${binarySha256}`);
   return { archiveSha256, binarySha256 };
 }
-async function ensureGithubInstalled(spec, config2, fetchImpl, platform3, arch, signal) {
+async function ensureGithubInstalled(spec, config2, fetchImpl, platform2, arch, signal) {
   const outcome = await withInstallLock(spec.githubRepo, async () => {
     const { tag, assets, blockedByGrace, reason } = await resolveTargetTag(spec, config2, fetchImpl, signal);
     if (!tag) {
-      const installed = isGithubInstalled(spec, platform3);
+      const installed = isGithubInstalled(spec, platform2);
       if (installed) {
         warn2(`[lsp] no eligible release of ${spec.githubRepo} (grace=${config2.graceDays}d); keeping existing install`);
         return { started: false, reason: "kept existing install" };
@@ -35434,7 +35878,7 @@ async function ensureGithubInstalled(spec, config2, fetchImpl, platform3, arch,
       warn2(`[lsp] skipping ${spec.id}: ${fallbackReason}`);
       return { started: false, reason: fallbackReason };
     }
-    if (isGithubInstalled(spec, platform3)) {
+    if (isGithubInstalled(spec, platform2)) {
       const installedMeta = readInstalledMetaIn(ghPackageDir(spec));
       if (installedMeta && installedMeta.version === tag) {
         return { started: false, reason: "already installed" };
@@ -35445,7 +35889,7 @@ async function ensureGithubInstalled(spec, config2, fetchImpl, platform3, arch,
         log2(`[lsp] reinstalling ${spec.id}@${tag}: no installed-version metadata recorded`);
       }
     }
-    const hashes = await downloadAndInstall(spec, tag, assets, platform3, arch, fetchImpl, signal).catch((err) => {
+    const hashes = await downloadAndInstall(spec, tag, assets, platform2, arch, fetchImpl, signal).catch((err) => {
       error52(`[lsp] github install ${spec.id} crashed: ${err}`);
       return null;
     });
@@ -37825,6 +38269,48 @@ function relativeToWorktree(fp, worktree) {
 function readAttachments(data) {
   return Array.isArray(data.attachments) ? data.attachments : [];
 }
+var ISSUE_AND_PR_READ_DESCRIPTION = "GitHub issues and pull requests can be read with `issue://NUMBER` and `pr://NUMBER` (or `issue://OWNER/REPO/NUMBER` and `pr://OWNER/REPO/NUMBER`).";
+function asRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function visionCapabilityForOpenCodeModel(model) {
+  const entry = model;
+  if (Array.isArray(entry?.modalities?.input)) {
+    return entry.modalities.input.includes("image");
+  }
+  return typeof entry?.attachment === "boolean" ? entry.attachment : undefined;
+}
+function modelFromOpenCodeProvider(provider, modelID) {
+  const models = provider.models;
+  if (Array.isArray(models)) {
+    return models.find((model) => asRecord2(model)?.id === modelID);
+  }
+  return asRecord2(models)?.[modelID];
+}
+async function currentSessionVisionCapability(client, sessionID) {
+  if (!sessionID)
+    return;
+  const promptContext = await resolvePromptContext(client, sessionID);
+  const currentModel = promptContext?.model;
+  if (!currentModel)
+    return;
+  const providerApi = client.provider;
+  if (typeof providerApi?.list !== "function")
+    return;
+  let listed;
+  try {
+    listed = await providerApi.list();
+  } catch {
+    return;
+  }
+  const result = asRecord2(listed);
+  const catalog = asRecord2(result?.data) ?? result;
+  const providers = Array.isArray(catalog?.all) ? catalog.all : Array.isArray(catalog?.providers) ? catalog.providers : [];
+  const provider = providers.map(asRecord2).find((entry) => entry?.id === currentModel.providerID);
+  if (!provider)
+    return;
+  return visionCapabilityForOpenCodeModel(modelFromOpenCodeProvider(provider, currentModel.modelID));
+}
 function persistFilePathAlias(args, context) {
   if (typeof args.path === "string" && !Object.hasOwn(args, "filePath")) {
     args.filePath = args.path;
@@ -38012,10 +38498,19 @@ Examples:
   Read 30 lines from line 200: { "path": "src/app.ts", "offset": 200, "limit": 30 }
   List directory: { "path": "src/" }
 `;
+function readDescription(ghReadEnabled) {
+  if (!ghReadEnabled)
+    return READ_DESCRIPTION;
+  return READ_DESCRIPTION.replace(`
+Examples:`, `
+${ISSUE_AND_PR_READ_DESCRIPTION}
+
+Examples:`);
+}
 function createReadTool(ctx) {
   return prepareToolMap({
     read: {
-      description: READ_DESCRIPTION,
+      description: readDescription(ctx.config.gh_read?.enabled === true),
       args: {
         filePath: z8.string().describe("Path to file or directory (absolute or relative to project root)"),
         startLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line to start reading from"),
@@ -38066,6 +38561,9 @@ function createReadTool(ctx) {
           rawArgs.endLine = endLine;
         if (rawLimit !== undefined && rawOffset === undefined)
           rawArgs.limit = rawLimit;
+        const visionCapability = await currentSessionVisionCapability(ctx.client, context.sessionID);
+        if (visionCapability !== undefined)
+          rawArgs.vision_capability = visionCapability;
         const response = await callToolCall(ctx, context, "read", rawArgs);
         if (response.success === false) {
           throw new Error(response.message || "read failed");
@@ -38700,7 +39198,7 @@ async function resolveAndGateScope(ctx, context, scope) {
   }
   return { scope: Array.isArray(scope) ? resolved : resolved[0] };
 }
-function asRecord2(value) {
+function asRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
 function asString(value) {
@@ -38708,7 +39206,7 @@ function asString(value) {
 }
 function firstRecord(...values) {
   for (const value of values) {
-    const record2 = asRecord2(value);
+    const record2 = asRecord3(value);
     if (record2)
       return record2;
   }
@@ -38743,7 +39241,7 @@ function parseInspectPhaseEntries(value) {
   if (!Array.isArray(value))
     return [];
   return value.flatMap((candidate) => {
-    const entry = asRecord2(candidate);
+    const entry = asRecord3(candidate);
     const id = asString(entry?.id);
     if (!id)
       return [];
@@ -38759,7 +39257,7 @@ function parseInspectPhaseEntries(value) {
   });
 }
 function parseInspectTerminal(payload) {
-  const response = asRecord2(payload);
+  const response = asRecord3(payload);
   if (!response)
     return;
   const kind = terminalKind(response);
@@ -38774,7 +39272,7 @@ function parseInspectTerminal(payload) {
       waitStampText: kind === "FRESH" ? firstString(waitStamp?.text, waitStamp?.human_text) : undefined
     };
   }
-  const failedPhaseRecord = asRecord2(response.failed_phase);
+  const failedPhaseRecord = asRecord3(response.failed_phase);
   const failedPhaseId = firstString(failedPhaseRecord?.id, response.failed_phase);
   const failedPhase = failedPhaseId ? parseInspectPhaseEntries([
     {
@@ -38870,12 +39368,12 @@ function createInspectTier2IdleScheduler(options) {
 }
 function inspectTools(ctx) {
   const inspectTool = {
-    description: "Blocking-fresh codebase health inspection. Each call completes current analysis and produces exactly one terminal result: FRESH includes a wait-stamp and completed phases; INTERRUPTED and PHASE-FAILED retain completed phases, with PHASE-FAILED also reporting its phase attribution and failure reason. `sections` selects drill-down detail, not the categories verified.\n\n" + "Use `scope=` to narrow returned results. Scope filters rendered diagnostics; it does not change collection work. Scoped files no producer has authoritatively analyzed are reported as named gaps (complete: false). Passive health changes use the alert channel; do not infer inspect completion from that channel.\n\n" + `Use when: starting work on unfamiliar code, after multi-edit batches to check diagnostics, before a refactor, before review, or to verify cleanup completeness.
+    description: "Blocking-fresh codebase health inspection. Each call completes current analysis and produces exactly one terminal result: FRESH includes a wait-stamp and completed phases; INTERRUPTED and PHASE-FAILED retain completed phases, with PHASE-FAILED also reporting its phase attribution and failure reason. `sections` selects drill-down detail, not the categories verified.\n\n" + "Use `scope=` to narrow returned results. Scope filters rendered diagnostics and limits Rust LSP startup to Cargo workspaces owning the scoped paths; it does not trigger per-file collection work. Scoped files no producer has authoritatively analyzed are reported as named gaps (complete: false). Passive health changes use the alert channel; do not infer inspect completion from that channel.\n\n" + `Use when: starting work on unfamiliar code, after multi-edit batches to check diagnostics, before a refactor, before review, or to verify cleanup completeness.
 
 ` + "Treat `dead_code` as a hint, not proof: reachability is call-based, so symbols reached only via method dispatch or referenced only in type position may be false positives — verify before deleting.",
     args: {
       sections: arg(z10.union([z10.string(), z10.array(z10.string())]).optional().describe("Categories to include in detailed drill-down (e.g. 'todos' or ['todos', 'dead_code', 'cycles']). Use 'all' for every active category. Omit for summary-only mode. `sections` changes detail, not the categories verified.")),
-      scope: arg(z10.union([z10.string(), z10.array(z10.string())]).optional().describe("Restrict returned results to paths under this scope (file or directory, absolute or relative to project root). `scope=` narrows results; it does not change the diagnostic collection work. Scoped files no producer has authoritatively analyzed are reported as named gaps (complete: false), never as a clean empty result.")),
+      scope: arg(z10.union([z10.string(), z10.array(z10.string())]).optional().describe("Restrict returned results to paths under this scope (file or directory, absolute or relative to project root). `scope=` narrows results and limits Rust LSP startup to owning Cargo workspaces; it does not trigger per-file diagnostic collection. Scoped files no producer has authoritatively analyzed are reported as named gaps (complete: false), never as a clean empty result.")),
       topK: arg(z10.number().int().positive().max(100).optional().describe("Max drill-down items per category. Default 20, max 100."))
     },
     execute: async (args, context) => {
@@ -39724,7 +40222,9 @@ function semanticTools(ctx) {
         rawArgs.includeTests = args.includeTests;
       if (pathArg)
         rawArgs.path = pathArg;
-      const response = await callToolCall(ctx, context, "search", rawArgs);
+      const response = await callToolCall(ctx, context, "search", rawArgs, {
+        abortSignal: context.abort
+      });
       if (response.success === false) {
         const message = typeof response.text === "string" && response.text.length > 0 ? response.text : typeof response.message === "string" && response.message.length > 0 ? response.message : "semantic_search failed";
         throw new Error(message);
@@ -39903,7 +40403,7 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.54.0";
+var ANNOUNCEMENT_VERSION = "0.55.1";
 var ANNOUNCEMENT_FEATURES = [
   "Callgraph stays consistent under load: edits arriving mid-rebuild can no longer be silently lost from navigation results.",
   "aft_zoom handles real-world .jsonc: files with comment banners above the opening brace now resolve, and not-found errors point at the segment that actually failed (thanks @iceteaSA).",