@cortexkit/aft-opencode 0.50.3 → 0.51.1

package/dist/index.js

@@ -8244,6 +8244,120 @@ function skipSpaces(input, start) {
     index++;
   return index;
 }
+// ../aft-bridge/dist/bash-host-fallback.js
+import { spawn } from "node:child_process";
+var BASH_HOST_FALLBACK_BANNER = "[AFT host fallback - module transport down; no rewrites/compression/background]";
+var BASH_HOST_FALLBACK_MAX_OUTPUT_BYTES = 100 * 1024;
+var BASH_HOST_FALLBACK_MAX_TIMEOUT_MS = 10 * 60 * 1000;
+var BASH_HOST_FALLBACK_REFUSAL = "AFT transport is down; only foreground execution is available in host fallback";
+function bashHostFallbackAskPattern(command, cwd) {
+  return `AFT UNAVAILABLE - host fallback execution:
+
+Exact command:
+${command}
+
+Working directory:
+${cwd}`;
+}
+function appendTail(chunks, chunk) {
+  const combined = Buffer.concat([...chunks, chunk]);
+  if (combined.byteLength <= BASH_HOST_FALLBACK_MAX_OUTPUT_BYTES) {
+    return { chunks: [combined], truncated: false };
+  }
+  return {
+    chunks: [combined.subarray(combined.byteLength - BASH_HOST_FALLBACK_MAX_OUTPUT_BYTES)],
+    truncated: true
+  };
+}
+function renderOutput(output, exitCode) {
+  const body = output.toString("utf8");
+  const separator = body.length === 0 || body.endsWith(`
+`) ? "" : `
+`;
+  return `${BASH_HOST_FALLBACK_BANNER}
+${body}${separator}[exit code: ${exitCode}]`;
+}
+async function runBashHostFallback(options) {
+  const timeoutMs = Math.min(Math.max(1, options.timeoutMs ?? BASH_HOST_FALLBACK_MAX_TIMEOUT_MS), BASH_HOST_FALLBACK_MAX_TIMEOUT_MS);
+  if (options.signal?.aborted) {
+    throw new DOMException("The host fallback command was aborted", "AbortError");
+  }
+  return await new Promise((resolve2, reject) => {
+    const child = spawn(options.command, {
+      cwd: options.projectRoot,
+      shell: true,
+      env: { ...process.env, ...options.env },
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32",
+      windowsHide: true
+    });
+    let chunks = [];
+    let truncated = false;
+    let timedOut = false;
+    let aborted = false;
+    let settled = false;
+    let abortForceTimer;
+    const capture = (chunk) => {
+      const next = appendTail(chunks, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      chunks = next.chunks;
+      truncated ||= next.truncated;
+    };
+    child.stdout?.on("data", capture);
+    child.stderr?.on("data", capture);
+    const kill = (signal) => {
+      if (child.exitCode !== null || child.signalCode !== null)
+        return;
+      if (process.platform !== "win32" && child.pid !== undefined) {
+        try {
+          process.kill(-child.pid, signal);
+          return;
+        } catch {}
+      }
+      child.kill(signal);
+    };
+    const onAbort = () => {
+      aborted = true;
+      kill("SIGTERM");
+      abortForceTimer = setTimeout(() => kill("SIGKILL"), 250);
+      abortForceTimer.unref?.();
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      kill("SIGKILL");
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timer);
+      if (abortForceTimer !== undefined)
+        clearTimeout(abortForceTimer);
+      options.signal?.removeEventListener("abort", onAbort);
+    };
+    child.once("error", (error2) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(error2);
+    });
+    child.once("close", (code) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      if (aborted) {
+        reject(new DOMException("The host fallback command was aborted", "AbortError"));
+        return;
+      }
+      const exitCode = timedOut ? 124 : code ?? 1;
+      resolve2({
+        success: true,
+        output: renderOutput(Buffer.concat(chunks), exitCode),
+        exit_code: exitCode,
+        truncated
+      });
+    });
+  });
+}
 // ../aft-bridge/dist/bash-timeout.js
 function resolveBashKillTimeout(modelTimeout, foregroundWaitMs) {
   if (modelTimeout !== undefined && modelTimeout >= foregroundWaitMs) {
@@ -8252,7 +8366,7 @@ function resolveBashKillTimeout(modelTimeout, foregroundWaitMs) {
   return;
 }
 // ../aft-bridge/dist/bridge.js
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
@@ -8282,56 +8396,6 @@ function isPassiveCommand(command) {
   return PASSIVE_COMMANDS.has(command);
 }
 
-// ../aft-bridge/dist/status-bar.js
-var STATUS_BAR_HEARTBEAT_CALLS = 15;
-function createStatusBarEmitState() {
-  return { callsSinceEmit: 0 };
-}
-function parseStatusBarCounts(value) {
-  if (!value || typeof value !== "object")
-    return;
-  const record = value;
-  const num = (key) => {
-    const raw = record[key];
-    return typeof raw === "number" && Number.isFinite(raw) ? raw : 0;
-  };
-  return {
-    errors: num("errors"),
-    warnings: num("warnings"),
-    dead_code: num("dead_code"),
-    unused_exports: num("unused_exports"),
-    duplicates: num("duplicates"),
-    todos: num("todos"),
-    tier2_stale: record.tier2_stale === true,
-    ...typeof record.line === "string" ? { line: record.line } : {}
-  };
-}
-function countsEqual(a, b) {
-  return a.errors === b.errors && a.warnings === b.warnings && a.dead_code === b.dead_code && a.unused_exports === b.unused_exports && a.duplicates === b.duplicates && a.todos === b.todos && a.tier2_stale === b.tier2_stale && a.line === b.line;
-}
-function shouldEmitStatusBar(state, next) {
-  const changed = state.last === undefined || !countsEqual(state.last, next);
-  state.callsSinceEmit += 1;
-  const heartbeat = state.callsSinceEmit >= STATUS_BAR_HEARTBEAT_CALLS;
-  if (changed || heartbeat) {
-    state.last = next;
-    state.callsSinceEmit = 0;
-    return true;
-  }
-  return false;
-}
-function formatStatusBar(counts) {
-  if (counts.line !== undefined)
-    return counts.line;
-  const staleMark = counts.tier2_stale ? "~" : "";
-  return `[AFT E${counts.errors} W${counts.warnings} | ` + `${staleMark}D${counts.dead_code} U${counts.unused_exports} C${counts.duplicates} | ` + `T${counts.todos}]`;
-}
-function statusBarLine(counts) {
-  return `
-
-${formatStatusBar(counts)}`;
-}
-
 // ../aft-bridge/dist/bridge.js
 var DEFAULT_BRIDGE_TIMEOUT_MS = 30000;
 var BRIDGE_HANG_TIMEOUT_THRESHOLD = 2;
@@ -8460,6 +8524,14 @@ class BridgeTransportTimeoutError extends Error {
     this.name = "BridgeTransportTimeoutError";
   }
 }
+
+class BridgeTransportUnavailableError extends Error {
+  code = "bridge_transport_unavailable";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "BridgeTransportUnavailableError";
+  }
+}
 function isBridgeTransportTimeout(err) {
   return err instanceof Error && err.code === "transport_timeout";
 }
@@ -8502,7 +8574,6 @@ class BinaryBridge {
   configureWarningClients = new Map;
   restartResetTimer = null;
   lastChildActivityAt = 0;
-  lastStatusBar;
   consecutiveRequestTimeouts = 0;
   errorPrefix;
   logger;
@@ -8602,6 +8673,20 @@ class BinaryBridge {
   isAlive() {
     return this.process !== null && this.process.exitCode === null && !this.process.killed;
   }
+  invalidateTransportProcess(error2) {
+    const proc = this.process;
+    if (!proc)
+      return;
+    this.process = null;
+    this.spawnedBinaryFingerprint = null;
+    if (proc.exitCode === null && !proc.killed) {
+      proc.kill("SIGKILL");
+    }
+    this.clearRestartResetTimer();
+    this.configured = false;
+    this.outstandingBackgroundTaskIds.clear();
+    this.rejectAllPending(error2);
+  }
   hasPendingRequests() {
     return this.pending.size > 0;
   }
@@ -8703,7 +8788,7 @@ class BinaryBridge {
         throw new Error(`${this.errorPrefix} Bridge is retiring after the on-disk binary changed; retry to respawn on the updated binary`);
       }
       if (this._shuttingDown) {
-        throw new Error(`${this.errorPrefix} Bridge is shutting down, cannot send "${command}"`);
+        throw new BridgeTransportUnavailableError(`${this.errorPrefix} Bridge is shutting down, cannot send "${command}"`);
       }
       if (Object.hasOwn(params, "id")) {
         throw new Error("params cannot contain reserved key 'id'");
@@ -8737,7 +8822,7 @@ class BinaryBridge {
                 await this.deliverConfigureWarnings(configResult, params, options);
                 await this.checkVersion(implicitTransportOptions);
                 if (!this.isAlive()) {
-                  throw new Error(`${this.errorPrefix} Bridge died during version check. Check logs: ${this.getLogFilePathVia()}`);
+                  throw new BridgeTransportUnavailableError(`${this.errorPrefix} Bridge died during version check. Check logs: ${this.getLogFilePathVia()}`);
                 }
                 this.configured = true;
               } finally {
@@ -8767,6 +8852,7 @@ class BinaryBridge {
 `;
       const keepBridgeOnTimeout = passive || options?.keepBridgeOnTimeout === true;
       let requestSentAt = Date.now();
+      const child = this.process;
       const response = await new Promise((resolve2, reject) => {
         const timer = setTimeout(() => {
           const entry = this.pending.get(id);
@@ -8803,21 +8889,27 @@ class BinaryBridge {
           this.handleTimeout(requestSessionId);
         }, effectiveTimeoutMs);
         this.pending.set(id, { resolve: resolve2, reject, timer, onProgress: options?.onProgress, command });
-        if (!this.process?.stdin?.writable) {
+        if (!child?.stdin?.writable) {
           this.pending.delete(id);
           clearTimeout(timer);
-          reject(new Error(`${this.errorPrefix} stdin not writable for command "${command}"`));
+          const error2 = new BridgeTransportUnavailableError(`${this.errorPrefix} stdin not writable for command "${command}"`);
+          reject(error2);
+          if (this.process === child)
+            this.invalidateTransportProcess(error2);
           return;
         }
         requestSentAt = Date.now();
-        this.process.stdin.write(line, (err) => {
+        child.stdin.write(line, (err) => {
           if (err) {
+            const error2 = new BridgeTransportUnavailableError(`${this.errorPrefix} Failed to write to stdin: ${err.message}`, { cause: err });
             const entry = this.pending.get(id);
             if (entry) {
               this.pending.delete(id);
               clearTimeout(entry.timer);
-              entry.reject(new Error(`${this.errorPrefix} Failed to write to stdin: ${err.message}`));
+              entry.reject(error2);
             }
+            if (this.process === child)
+              this.invalidateTransportProcess(error2);
           }
         });
       });
@@ -8977,13 +9069,15 @@ class BinaryBridge {
     });
   }
   ensureSpawned(triggeringSessionId) {
-    if (this.isAlive())
+    if (this.isAlive() && this.process?.stdin?.writable)
       return;
+    if (this.process !== null) {
+      this.invalidateTransportProcess(new BridgeTransportUnavailableError(`${this.errorPrefix} Child stdin is not writable`));
+    }
     this.spawnProcess(triggeringSessionId);
   }
   spawnProcess(triggeringSessionId) {
     this._retiringDueToBinaryChange = false;
-    this.lastStatusBar = undefined;
     if (triggeringSessionId) {
       this.sessionLogVia(triggeringSessionId, `Spawning binary: ${this.binaryPath} (cwd: ${this.cwd})`);
     } else {
@@ -9024,7 +9118,7 @@ class BinaryBridge {
         }
       }
     }
-    const child = spawn(this.binaryPath, [], {
+    const child = spawn2(this.binaryPath, [], {
       cwd: this.cwd,
       stdio: ["pipe", "pipe", "pipe"],
       env
@@ -9054,7 +9148,7 @@ class BinaryBridge {
       if (this.process !== currentChild)
         return;
       this.errorVia(`Process error: ${err.message}${this.formatStderrTail()}`);
-      this.handleCrash();
+      this.handleCrash(err);
     });
     child.on("exit", (code, signal) => {
       if (this.process !== currentChild)
@@ -9067,7 +9161,7 @@ class BinaryBridge {
         this.process = null;
         this.configured = false;
         this.clearRestartResetTimer();
-        this.rejectAllPending(new Error(`${this.errorPrefix} Binary killed by ${signal}`));
+        this.rejectAllPending(new BridgeTransportUnavailableError(`${this.errorPrefix} Binary killed by ${signal}`));
         return;
       }
       this.handleCrash();
@@ -9222,7 +9316,6 @@ class BinaryBridge {
         this.consecutiveRequestTimeouts = 0;
         this.scheduleRestartCountReset();
         this.accountForBashTaskResponse(entry.command, response);
-        this.captureStatusBar(response);
         entry.resolve(response);
       } else if (typeof response.type === "string") {
         this.logVia(`Ignoring unknown stdout push frame type: ${response.type}`);
@@ -9243,14 +9336,6 @@ class BinaryBridge {
       this.outstandingBackgroundTaskIds.add(taskId);
     }
   }
-  captureStatusBar(response) {
-    const parsed = parseStatusBarCounts(response.status_bar);
-    if (parsed)
-      this.lastStatusBar = parsed;
-  }
-  getStatusBar() {
-    return this.lastStatusBar;
-  }
   handleTimeout(triggeringSessionId) {
     this.consecutiveRequestTimeouts = 0;
     this.spawnedBinaryFingerprint = null;
@@ -9291,7 +9376,7 @@ class BinaryBridge {
     if (tail) {
       this.errorVia(`Binary crashed (restarts: ${this._restartCount})${cause ? `: ${cause.message}` : ""}.${tail}`);
     }
-    this.rejectAllPending(new Error(`${this.errorPrefix} Binary crashed (restarts: ${this._restartCount})${cause ? `: ${cause.message}` : ""} (see ${this.getLogFilePathVia()})`));
+    this.rejectAllPending(new BridgeTransportUnavailableError(`${this.errorPrefix} Binary crashed (restarts: ${this._restartCount})${cause ? `: ${cause.message}` : ""} (see ${this.getLogFilePathVia()})`, { cause }));
     if (this._retiringDueToBinaryChange) {
       this.logVia("Binary exited while retiring after an on-disk update; skipping auto-restart");
       return;
@@ -12640,6 +12725,12 @@ function projectRootKeyHash(dir) {
 }
 
 // ../aft-bridge/dist/subc-transport.js
+class SubcTransportShuttingDownError extends SubcCallError {
+  constructor() {
+    super("terminal", "subc transport is shutting down", "transport_shutting_down");
+    this.name = "SubcTransportShuttingDownError";
+  }
+}
 var AFT_MODULE_ID = "aft";
 var MAX_CONSECUTIVE_TRANSPORT_FAILURES = 3;
 var BG_STABLE_MS = 5000;
@@ -12981,7 +13072,6 @@ class SubcTransport {
   pool;
   projectRoot;
   generation;
-  lastStatusBar;
   cachedStatus = null;
   constructor(pool, projectRoot, generation) {
     this.pool = pool;
@@ -12997,20 +13087,12 @@ class SubcTransport {
   getConcretePoolId() {
     return this.pool.getConcretePoolId();
   }
-  getStatusBar() {
-    return this.lastStatusBar;
-  }
   getCachedStatus() {
     return this.cachedStatus;
   }
   cacheStatusSnapshot(snapshot) {
     this.cachedStatus = snapshot;
   }
-  captureStatusBar(response) {
-    const parsed = parseStatusBarCounts(response.status_bar);
-    if (parsed)
-      this.lastStatusBar = parsed;
-  }
   identityFor(session) {
     return {
       project_root: this.projectRoot,
@@ -13031,9 +13113,7 @@ class SubcTransport {
     if (preview === true)
       body.preview = true;
     const reply = await this.pool.routeRequest(this.identityFor(sessionId), body, timeoutMs, onProgress, this.generation);
-    const result = reliftReply(reply);
-    this.captureStatusBar(result);
-    return result;
+    return reliftReply(reply);
   }
   async send(command, params = {}, options) {
     this.assertCurrent();
@@ -13047,9 +13127,7 @@ class SubcTransport {
     if (editSlotSurvives !== undefined)
       body.edit_slot_survives = editSlotSurvives;
     const reply = await this.pool.routeRequest(this.identityFor(session), body, timeoutMs, onProgress, this.generation);
-    const response = reliftReply(reply);
-    this.captureStatusBar(response);
-    return response;
+    return reliftReply(reply);
   }
   splitOptions(options) {
     if (!options)
@@ -13320,7 +13398,7 @@ class SubcTransportPool {
   getBridge(projectRoot) {
     const root = this.canonicalRoot(projectRoot);
     if (this.shuttingDown && this.lifecycleEnabled()) {
-      throw new SubcCallError("terminal", "subc transport is shutting down");
+      throw new SubcTransportShuttingDownError;
     }
     if (!this.lifecycleEnabled())
       return this.makeFacade(root);
@@ -13620,7 +13698,7 @@ class SubcTransportPool {
   }
   async ensureClient() {
     if (this.shuttingDown)
-      throw new SubcCallError("terminal", "subc transport is shutting down");
+      throw new SubcTransportShuttingDownError;
     if (this.client)
       return this.client;
     if (this.connecting)
@@ -13634,7 +13712,7 @@ class SubcTransportPool {
         try {
           client.close();
         } catch {}
-        throw new SubcCallError("terminal", "subc transport is shutting down");
+        throw new SubcTransportShuttingDownError;
       }
       this.client = client;
       this.transportFailures = 0;
@@ -13899,8 +13977,24 @@ function isRouteGoodbyeError(error2) {
   }
   return error2.code === "route_closed" && error2.message.includes("route closed by subc");
 }
+function hasEngineResponse(error2) {
+  const response = error2.response;
+  if (response !== null && typeof response === "object")
+    return true;
+  const cause = error2.cause;
+  if (cause === null || typeof cause !== "object")
+    return false;
+  const causeResponse = cause.response;
+  return causeResponse !== null && typeof causeResponse === "object";
+}
+function isBashTransportDeadError(error2) {
+  if (!(error2 instanceof Error) || hasEngineResponse(error2) || isRouteGoodbyeError(error2)) {
+    return false;
+  }
+  return error2 instanceof BridgeTransportUnavailableError || error2 instanceof SubcTransportShuttingDownError || isConsumerReconnectTransient(error2) || error2 instanceof StaleRouteHandleError || error2 instanceof SubcRootGenerationExpiredError || error2 instanceof SubcRootReapedError;
+}
 function isTransportClassError(error2) {
-  return isBridgeTransportTimeout(error2) || isConsumerReconnectTransient(error2) || error2 instanceof StaleRouteHandleError || error2 instanceof SubcRootGenerationExpiredError || error2 instanceof SubcRootReapedError;
+  return isBridgeTransportTimeout(error2) || isBashTransportDeadError(error2);
 }
 function adaptToolError(command, error2) {
   if (!(error2 instanceof Error))
@@ -16451,9 +16545,6 @@ class RevivableProjectTransport {
   getCwd() {
     return this.projectRoot;
   }
-  getStatusBar() {
-    return this.owner.currentBridge(this.projectRoot)?.getStatusBar();
-  }
   getCachedStatus() {
     return this.owner.currentBridge(this.projectRoot)?.getCachedStatus() ?? null;
   }
@@ -17803,6 +17894,8 @@ async function callBridge(ctx, runtime, command, params = {}, options) {
   try {
     response = await bridgeFor(ctx, runtime).send(command, merged, Object.keys(sendOptions).length > 0 ? sendOptions : undefined);
   } catch (error3) {
+    if (command === "bash" && isBashTransportDeadError(error3))
+      throw error3;
     throw adaptToolError(command, error3);
   } finally {
     markBridgeEnd();
@@ -32230,6 +32323,7 @@ var BashFeaturesSchema = exports_external.object({
   rewrite: exports_external.boolean().optional(),
   compress: exports_external.boolean().optional(),
   background: exports_external.boolean().optional(),
+  host_fallback: exports_external.boolean().optional(),
   subagent_background: exports_external.boolean().optional(),
   long_running_reminder_enabled: exports_external.boolean().optional(),
   long_running_reminder_interval_ms: exports_external.number().int().positive().optional(),
@@ -32259,6 +32353,9 @@ var InspectConfigSchema = exports_external.object({
     expected_mirrors: exports_external.array(exports_external.tuple([exports_external.string().trim().min(1), exports_external.string().trim().min(1)])).optional()
   }).optional()
 });
+var WorktreeConfigSchema = exports_external.object({
+  ram_overlay: exports_external.boolean().optional()
+});
 var BackupConfigSchema = exports_external.object({
   enabled: exports_external.boolean().optional(),
   max_depth: exports_external.number().int().positive().optional(),
@@ -32284,6 +32381,7 @@ var AftConfigSchema = exports_external.preprocess((value) => stripHarnessSpecifi
   callgraph_chunk_size: exports_external.number().optional(),
   inspect: InspectConfigSchema.optional(),
   backup: BackupConfigSchema.optional(),
+  worktree: WorktreeConfigSchema.optional(),
   sandbox: SandboxConfigSchema.optional(),
   bash: BashConfigSchema.optional(),
   experimental: ExperimentalConfigSchema.optional(),
@@ -32311,6 +32409,7 @@ function resolveBashConfig(config2) {
     rewrite: false,
     compress: false,
     background: false,
+    host_fallback: false,
     subagent_background: false,
     long_running_reminder_enabled: reminderEnabled,
     long_running_reminder_interval_ms: reminderInterval,
@@ -32329,6 +32428,7 @@ function resolveBashConfig(config2) {
       rewrite: top.rewrite ?? true,
       compress: top.compress ?? true,
       background: top.background ?? true,
+      host_fallback: top.host_fallback ?? false,
       subagent_background: topSubagentBg
     };
   }
@@ -32609,6 +32709,15 @@ function mergeLspConfig(baseLsp, overrideLsp) {
   }
   return Object.fromEntries(Object.entries(lsp).filter(([, value]) => value !== undefined));
 }
+function mergeWorktreeConfig(baseWorktree, overrideWorktree) {
+  if (baseWorktree === undefined && overrideWorktree === undefined)
+    return;
+  if (overrideWorktree === undefined)
+    return baseWorktree;
+  if (baseWorktree === undefined)
+    return overrideWorktree;
+  return { ...baseWorktree, ...overrideWorktree };
+}
 function mergeInspectConfig(baseInspect, overrideInspect) {
   const inspect = {
     ...baseInspect,
@@ -32697,6 +32806,7 @@ var PROJECT_SAFE_TOP_LEVEL_FIELDS = new Set([
   "callgraph_store",
   "callgraph_chunk_size",
   "inspect",
+  "worktree",
   "experimental",
   "bash"
 ]);
@@ -32743,11 +32853,13 @@ function mergeConfigs(base, override) {
   const experimental = mergeExperimentalConfig(base.experimental, override.experimental);
   const bash = mergeBashConfig(base.bash, override.bash);
   const inspect = mergeInspectConfig(base.inspect, override.inspect);
+  const worktree = mergeWorktreeConfig(base.worktree, override.worktree);
   const sandbox = mergeSandboxConfig(base.sandbox, override.sandbox);
   const bridge = base.bridge;
   const safeOverride = pickProjectSafeFields(override);
   delete safeOverride.bash;
   delete safeOverride.inspect;
+  delete safeOverride.worktree;
   return {
     ...base,
     ...safeOverride,
@@ -32756,6 +32868,7 @@ function mergeConfigs(base, override) {
     ...lsp ? { lsp } : {},
     ...bash !== undefined ? { bash } : {},
     ...inspect !== undefined ? { inspect } : {},
+    ...worktree !== undefined ? { worktree } : {},
     ...sandbox !== undefined ? { sandbox } : {},
     experimental,
     semantic,
@@ -33393,7 +33506,7 @@ import {
 import { dirname as dirname8 } from "node:path";
 
 // src/hooks/auto-update-checker/cache.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { cpSync, existsSync as existsSync13, 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 join15 } from "node:path";
@@ -33805,7 +33918,7 @@ async function runNpmInstallSafe(installDir, options = {}) {
       warnNpmInstallFailure(reason, stderrTail);
       return { ok: false, reason };
     }
-    const proc = spawn2(npm.command, ["install", "--no-audit", "--no-fund", "--no-progress", "--ignore-scripts"], {
+    const proc = spawn3(npm.command, ["install", "--no-audit", "--no-fund", "--no-progress", "--ignore-scripts"], {
       cwd: installDir,
       stdio: ["ignore", "pipe", "pipe"],
       env: npmSpawnEnv(npm)
@@ -34134,7 +34247,7 @@ function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
 }
 
 // src/lsp-auto-install.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import {
   createReadStream,
@@ -34734,7 +34847,7 @@ function runInstall(spec, version2, cwd, signal) {
       return;
     }
     ensureInstallAnchor(cwd);
-    const child = spawn3(npm.command, ["install", "--no-save", "--ignore-scripts", "--silent", target], {
+    const child = spawn4(npm.command, ["install", "--no-save", "--ignore-scripts", "--silent", target], {
       stdio: ["ignore", "pipe", "pipe"],
       cwd,
       env: npmSpawnEnv(npm)
@@ -36441,14 +36554,23 @@ function readStatusBar(value) {
   if (typeof value !== "object" || value === null)
     return;
   const bar = asRecord(value);
+  const errors3 = readOptionalNumber(bar.errors);
+  const warnings = readOptionalNumber(bar.warnings);
+  const deadCode = readOptionalNumber(bar.dead_code);
+  const unusedExports = readOptionalNumber(bar.unused_exports);
+  const duplicates = readOptionalNumber(bar.duplicates);
+  const todos = readOptionalNumber(bar.todos);
+  if (errors3 === null && warnings === null && deadCode === null && unusedExports === null && duplicates === null && todos === null) {
+    return;
+  }
   return {
-    errors: readNumber(bar.errors),
-    warnings: readNumber(bar.warnings),
-    dead_code: readNumber(bar.dead_code),
-    unused_exports: readNumber(bar.unused_exports),
-    duplicates: readNumber(bar.duplicates),
-    todos: readNumber(bar.todos),
-    tier2_stale: readBoolean(bar.tier2_stale)
+    ...errors3 !== null ? { errors: errors3 } : {},
+    ...warnings !== null ? { warnings } : {},
+    ...deadCode !== null ? { dead_code: deadCode } : {},
+    ...unusedExports !== null ? { unused_exports: unusedExports } : {},
+    ...duplicates !== null ? { duplicates } : {},
+    ...todos !== null ? { todos } : {},
+    ...bar.tier2_stale === true ? { tier2_stale: true } : {}
   };
 }
 function formatFlag(enabled) {
@@ -36457,6 +36579,15 @@ function formatFlag(enabled) {
 function formatCount(value) {
   return value == null ? "—" : value.toLocaleString("en-US");
 }
+function formatCacheRoleLabel(role) {
+  if (role === "worktree") {
+    return "worktree — shared repo index (built by the main checkout)";
+  }
+  if (role === "read_only") {
+    return "read_only — sharing the repo index family (read-only borrow)";
+  }
+  return role;
+}
 function formatSemanticIndexStatus(status, stage) {
   if ((status === "loading" || status === "building") && stage === "fingerprint_change") {
     return "Rebuilding (model changed)";
@@ -36561,7 +36692,7 @@ function formatStatusMarkdown(status) {
     `- **Version:** \`${status.version}\``,
     `- **Project root:** \`${status.project_root ?? "(not configured)"}\``,
     `- **Canonical root:** \`${status.canonical_root ?? "(not configured)"}\``,
-    `- **Cache role:** \`${status.cache_role}\``,
+    `- **Cache role:** \`${formatCacheRoleLabel(status.cache_role)}\``,
     "",
     "### Enabled features",
     `- \`format_on_edit\`: ${formatFlag(status.features.format_on_edit)}`,
@@ -36608,7 +36739,19 @@ function formatStatusMarkdown(status) {
   }
   if (status.status_bar) {
     const sb = status.status_bar;
-    lines.push("", `### Code Health${sb.tier2_stale ? " (~ stale)" : ""}`, `- **Errors:** ${formatCount(sb.errors)}`, `- **Warnings:** ${formatCount(sb.warnings)}`, `- **Dead code:** ${formatCount(sb.dead_code)}`, `- **Unused exports:** ${formatCount(sb.unused_exports)}`, `- **Duplicates:** ${formatCount(sb.duplicates)}`, `- **TODOs:** ${formatCount(sb.todos)}`);
+    const rows = [
+      ["Errors", sb.errors],
+      ["Warnings", sb.warnings],
+      ["Dead code", sb.dead_code],
+      ["Unused exports", sb.unused_exports],
+      ["Duplicates", sb.duplicates],
+      ["TODOs", sb.todos]
+    ].filter((row) => typeof row[1] === "number");
+    if (rows.length > 0) {
+      lines.push("", `### Code Health${sb.tier2_stale ? " (~ stale)" : ""}`);
+      for (const [label, value] of rows)
+        lines.push(`- **${label}:** ${formatCount(value)}`);
+    }
   }
   lines.push("", "### Current session", `- **ID:** \`${status.session.id}\``, `- **Tracked files:** ${formatCount(status.session.tracked_files)}`, `- **Checkpoints:** ${formatCount(status.session.checkpoints)}`, `- **Project checkpoints (all sessions):** ${formatCount(status.checkpoints_total)}`);
   return lines.join(`
@@ -36695,27 +36838,6 @@ function registerShutdownCleanup(fn) {
   };
 }
 
-// src/status-bar-inject.ts
-var emitStateBySession = new Map;
-function statusBarSuffixForSession(sessionID, counts, force = false) {
-  if (!counts)
-    return "";
-  let state = emitStateBySession.get(sessionID);
-  if (!state) {
-    state = createStatusBarEmitState();
-    emitStateBySession.set(sessionID, state);
-  }
-  if (force) {
-    state.last = counts;
-    state.callsSinceEmit = 0;
-    return statusBarLine(counts);
-  }
-  return shouldEmitStatusBar(state, counts) ? statusBarLine(counts) : "";
-}
-function clearStatusBarSession(sessionID) {
-  emitStateBySession.delete(sessionID);
-}
-
 // src/sync-watch-abort.ts
 var abortFlags = new Map;
 function signalSyncWatchAbort(sessionID) {
@@ -37464,6 +37586,7 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
       const shellEnv = await ctx.plugin?.trigger?.("shell.env", { cwd, sessionID: context.sessionID, callID: getCallID(context) }, { env: {} });
       const removeAbortListener = listenForForegroundAbort(ctx, context, !effectiveBackground && !requestedPty);
       let data;
+      let usedHostFallback = false;
       try {
         data = await withPermissionLoop(ctx, context, {
           command,
@@ -37489,6 +37612,31 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
             metadata?.({ output: accumulatedOutput, description });
           }
         });
+      } catch (error53) {
+        if (!bashCfg.host_fallback || !isBashTransportDeadError(error53))
+          throw error53;
+        if (rawRequestedBackground) {
+          throw new Error(`${BASH_HOST_FALLBACK_REFUSAL}; background:true is unsupported.`);
+        }
+        if (rawRequestedPty) {
+          throw new Error(`${BASH_HOST_FALLBACK_REFUSAL}; pty:true is unsupported.`);
+        }
+        const projectRoot = projectRootFor(context);
+        const pattern = bashHostFallbackAskPattern(command, projectRoot);
+        await runAsk(context.ask({
+          permission: "bash",
+          patterns: [pattern],
+          always: [],
+          metadata: { command, cwd: projectRoot, host_fallback: true }
+        }));
+        data = await runBashHostFallback({
+          command,
+          projectRoot,
+          timeoutMs: rawTimeout,
+          signal: context.abort,
+          env: shellEnv?.env
+        });
+        usedHostFallback = true;
       } finally {
         removeAbortListener();
       }
@@ -37506,7 +37654,8 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
         metadata?.(metadataPayload2);
         return { output: rendered2, title: uiTitle, metadata: metadataPayload2 };
       }
-      const rendered = maybeAppendGrepSearchHint(data.output ?? "", command, aftSearchRegistered, projectRootFor(context));
+      const output = data.output ?? "";
+      const rendered = usedHostFallback ? output : maybeAppendGrepSearchHint(output, command, aftSearchRegistered, projectRootFor(context));
       const metadataPayload = foregroundMetadata(description, data, rendered);
       metadata?.(metadataPayload);
       return {
@@ -38870,6 +39019,125 @@ async function resolveAndGateScope(ctx, context, scope) {
   }
   return { scope: Array.isArray(scope) ? resolved : resolved[0] };
 }
+function asRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function asString(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function firstRecord(...values) {
+  for (const value of values) {
+    const record2 = asRecord2(value);
+    if (record2)
+      return record2;
+  }
+  return;
+}
+function firstString(...values) {
+  for (const value of values) {
+    const text = asString(value);
+    if (text !== undefined)
+      return text;
+  }
+  return;
+}
+function terminalKind(response) {
+  for (const value of [
+    response.inspect_terminal,
+    response.terminal,
+    response.outcome,
+    response.inspect_outcome,
+    response.status
+  ]) {
+    if (typeof value !== "string")
+      continue;
+    const normalized = value.toUpperCase().replaceAll("_", "-");
+    if (normalized === "FRESH" || normalized === "INTERRUPTED" || normalized === "PHASE-FAILED") {
+      return normalized;
+    }
+  }
+  return;
+}
+function parseInspectPhaseEntries(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((candidate) => {
+    const entry = asRecord2(candidate);
+    const id = asString(entry?.id);
+    if (!id)
+      return [];
+    const alsoSatisfied = Array.isArray(entry?.also_satisfied) ? entry.also_satisfied.filter((category) => typeof category === "string") : [];
+    return [
+      {
+        id,
+        producer: asString(entry?.producer),
+        category: asString(entry?.category),
+        alsoSatisfied
+      }
+    ];
+  });
+}
+function parseInspectTerminal(payload) {
+  const response = asRecord2(payload);
+  if (!response)
+    return;
+  const kind = terminalKind(response);
+  if (!kind)
+    return;
+  const waitStamp = firstRecord(response.wait_stamp, response.waitStamp, response.blocking_wait_stamp);
+  const phases = parseInspectPhaseEntries(kind === "FRESH" ? waitStamp?.phases ?? response.completed_phases ?? response.completedPhases ?? response.phases : response.completed_phases ?? response.completedPhases ?? response.phases);
+  if (kind !== "PHASE-FAILED") {
+    return {
+      kind,
+      phases,
+      waitStampText: kind === "FRESH" ? firstString(waitStamp?.text, waitStamp?.human_text) : undefined
+    };
+  }
+  const failedPhaseRecord = asRecord2(response.failed_phase);
+  const failedPhaseId = firstString(failedPhaseRecord?.id, response.failed_phase);
+  const failedPhase = failedPhaseId ? parseInspectPhaseEntries([
+    {
+      id: failedPhaseId,
+      producer: firstString(failedPhaseRecord?.producer, response.failed_phase_producer, response.producer),
+      category: firstString(failedPhaseRecord?.category, response.failed_phase_category, response.category)
+    }
+  ])[0] : undefined;
+  return {
+    kind,
+    phases,
+    failedPhase,
+    failureReason: asString(response.failure_reason),
+    failureDetail: asString(response.failure_detail)
+  };
+}
+function formatPhase(entry) {
+  const details = [
+    entry.producer ? `producer: ${entry.producer}` : undefined,
+    entry.category ? `category: ${entry.category}` : undefined,
+    entry.alsoSatisfied.length > 0 ? `also satisfied: ${entry.alsoSatisfied.join(", ")}` : undefined
+  ].filter((detail) => Boolean(detail));
+  return details.length > 0 ? `${entry.id} (${details.join("; ")})` : entry.id;
+}
+function renderInspectTerminal(terminal, serverText) {
+  const lines = [terminal.kind];
+  if (terminal.kind === "FRESH") {
+    lines.push(`wait-stamp: ${terminal.waitStampText ?? "not supplied"}`);
+  }
+  if (terminal.kind === "PHASE-FAILED") {
+    if (terminal.failedPhase)
+      lines.push(`failed phase: ${formatPhase(terminal.failedPhase)}`);
+    lines.push(`failure reason: ${terminal.failureReason ?? "not supplied"}`);
+    if (terminal.failureDetail)
+      lines.push(`failure detail: ${terminal.failureDetail}`);
+  }
+  lines.push(terminal.phases.length > 0 ? `completed phases:
+${terminal.phases.map((phase) => `- ${formatPhase(phase)}`).join(`
+`)}` : "completed phases: none");
+  if (serverText?.trim())
+    lines.push(serverText);
+  return lines.join(`
+`);
+}
 function inspectToolSurfaceEnabled(config2) {
   return (config2.tool_surface ?? "recommended") !== "minimal" && config2.inspect?.enabled !== false;
 }
@@ -38885,9 +39153,8 @@ function createInspectTier2IdleScheduler(options) {
     timers.delete(sessionID);
   };
   const clearAll = () => {
-    for (const timer of timers.values()) {
+    for (const timer of timers.values())
       clearTimer(timer);
-    }
     timers.clear();
   };
   const schedule = (sessionID) => {
@@ -38908,12 +39175,12 @@ function createInspectTier2IdleScheduler(options) {
 }
 function inspectTools(ctx) {
   const inspectTool = {
-    description: "Codebase health snapshot. One call returns summary stats for: TODOs, diagnostics, file/symbol metrics, dead code, unused exports, code duplicates, and TS/JS import cycles. Pass `sections` for per-category drill-down details.\n\n" + "Categories run in tiers — Tier 1 (todos, metrics) return synchronously from cache. Tier 2 (dead_code, unused_exports, duplicates, cycles) waits for a fresh reuse scan up to a short deadline; if a category is still scanning the response reports `complete: false` with `pending_categories: [...]` rather than a fabricated clean count. Rust module cycles are out of scope for `cycles`.\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. It does not reduce the fresh verification work. 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.")),
-      scope: arg(z10.union([z10.string(), z10.array(z10.string())]).optional().describe("Restrict scan/results to paths under this scope (file or directory, absolute or relative to project root). Tier 1 scopes the scan; Tier 2 scans project-wide and applies scope as a result filter.")),
+      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 reduce the blocking-fresh verification work.")),
       topK: arg(z10.number().int().positive().max(100).optional().describe("Max drill-down items per category. Default 20, max 100."))
     },
     execute: async (args, context) => {
@@ -38921,27 +39188,23 @@ function inspectTools(ctx) {
       const scoped = await resolveAndGateScope(ctx, context, normalizeStringOrArray(args.scope));
       if (scoped.denial)
         return permissionDeniedResponse(scoped.denial);
-      const scope = scoped.scope;
-      const topK = args.topK === undefined || args.topK === null ? undefined : args.topK;
       const rawArgs = {};
       if (sections !== undefined)
         rawArgs.sections = sections;
-      if (scope !== undefined)
-        rawArgs.scope = scope;
-      if (topK !== undefined)
-        rawArgs.topK = topK;
-      const response = await callToolCall(ctx, context, "inspect", rawArgs, {
-        keepBridgeOnTimeout: true
-      });
-      if (response.success === false) {
+      if (scoped.scope !== undefined)
+        rawArgs.scope = scoped.scope;
+      if (args.topK !== undefined && args.topK !== null)
+        rawArgs.topK = args.topK;
+      const response = await callToolCall(ctx, context, "inspect", rawArgs);
+      const terminal = parseInspectTerminal(response);
+      if (terminal)
+        return renderInspectTerminal(terminal, response.text);
+      if (response.success === false)
         throw new Error(response.message || "inspect failed");
-      }
       return response.text;
     }
   };
-  return {
-    aft_inspect: inspectTool
-  };
+  return { aft_inspect: inspectTool };
 }
 
 // src/tools/navigation.ts
@@ -39740,7 +40003,7 @@ function semanticTools(ctx) {
       query: arg3(z15.string().describe("Concept, regex, literal text, filename, or capability to find. Examples: 'fuzzy match with whitespace tolerance', '^export', 'Cargo.lock'.")),
       topK: arg3(optionalInt(1, 100).describe("Number of results (default: 10, max: 100)")),
       includeTests: arg3(z15.boolean().optional().describe("Include test files (*.test.*, *_test.rs, __tests__/, …) plus test-support, fixture, mock, snapshot, and corpus files. Defaults to false.")),
-      path: arg3(z15.string().optional().describe("Search a different project root (absolute or ~ path). Requires that project to have been indexed by AFT."))
+      path: arg3(z15.string().optional().describe("Only set this to search a different Git project (absolute or ~ path). Omit it for the current configured workspace, including non-Git workspace roots; this is not a subdirectory filter. Unindexed external projects use a bounded lexical fallback."))
     },
     execute: async (args, context) => {
       if (isEmptyParam(args.query) || typeof args.query !== "string" || args.query.trim().length === 0) {
@@ -39943,7 +40206,7 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.50.3";
+var ANNOUNCEMENT_VERSION = "0.51.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).",
@@ -40478,7 +40741,6 @@ Install: ${getManualInstallHint()}`).catch(() => {});
       const sessionID = extractSessionID(eventInput.event.properties);
       if (eventType === "session.deleted" && sessionID) {
         inspectTier2Idle.clear(sessionID);
-        clearStatusBarSession(sessionID);
         pool.closeSession(input.directory, sessionID).catch(() => {});
         return;
       }
@@ -40567,12 +40829,6 @@ Install: ${getManualInstallHint()}`).catch(() => {});
       }
       const sessionDir = getSessionDirectoryCached(toolInput.sessionID) ?? input.directory;
       await appendInTurnBgCompletions({ ctx, directory: sessionDir, sessionID: toolInput.sessionID }, output);
-      if (output.output !== undefined) {
-        const activeBridge = ctx.pool.getActiveBridgeForRoot(sessionDir);
-        const suffix = statusBarSuffixForSession(toolInput.sessionID, activeBridge?.getStatusBar(), toolInput.tool === "aft_inspect");
-        if (suffix)
-          output.output += suffix;
-      }
     },
     config: async (config2) => {
       if (!config2 || typeof config2 !== "object")