@cortexkit/aft-opencode 0.61.0 → 0.62.0

package/dist/entry/server.js

@@ -9402,7 +9402,7 @@ function resolvePluginLogPath(context = {}) {
 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";
+var BASH_HOST_FALLBACK_REFUSAL = "AFT module connection is down";
 var BASH_RUNON_DESCRIPTION = 'Run on a remote build server: `linux` (2 vCPUs), or `linux,Nc` for N vCPUs such as `linux,8c`; add ",net" for outbound internet (offline by default). `windows` runs the command in Git Bash on a Windows build machine (no vCPU or network options).';
 var BASH_RUNON_GUIDANCE = 'When remote runs are available, put `runon: "linux"` on build and test lines (cargo, bun test), including chains and pipes. Keep git, gh, interactive and file-editing commands local, and keep a line local if it needs macOS (Seatbelt, codesign, launchd, TCC, AppKit) or runs binaries built on this machine: a remote build leaves no binaries or target/ output in the local worktree. Add `,Nc` to request N vCPUs (`linux,4c`); without it the job gets 2 vCPUs. The job sees exactly the CPUs it gets, so ask for what the command uses: 2c (the default) for a single test binary or script, 4c for `cargo check`/clippy on one crate, 8c for a workspace test suite, and 16c for a large release build.';
 function pathKeyForPlatform(env, platform) {
@@ -11226,7 +11226,7 @@ function isEmptyParam(value) {
   return false;
 }
 function coerceJsonCollectionParam(value, field) {
-  const shape = field === "targets" ? "an array of {path, symbol}" : "a string or array of strings";
+  const shape = field !== "sections" ? "an array of {target, symbols}" : "a string or array of strings";
   if (typeof value === "string") {
     const trimmed = value.trim();
     if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
@@ -11235,13 +11235,13 @@ function coerceJsonCollectionParam(value, field) {
       } catch {
         throw new Error(`${field} must be ${shape} (got a string that is not valid JSON)`);
       }
-    } else if (field === "targets") {
+    } else if (field !== "sections") {
       throw new Error(`${field} must be ${shape} (got a string that is not valid JSON)`);
     }
   }
   if (value === undefined || value === null)
     return value;
-  if (field === "targets") {
+  if (field !== "sections") {
     if (Array.isArray(value) || typeof value === "object")
       return value;
   } else if (typeof value === "string" || Array.isArray(value) && value.every((entry) => typeof entry === "string")) {
@@ -11264,7 +11264,7 @@ function usableZoomTargets(targets) {
     if (typeof entry !== "object")
       return true;
     const record = entry;
-    return !(isBlankParam(record.path) && isBlankParam(record.filePath) && isBlankParam(record.symbol));
+    return !(isBlankParam(record.target) && isBlankParam(record.url) && isBlankParam(record.symbols) && isBlankParam(record.path) && isBlankParam(record.filePath) && isBlankParam(record.symbol));
   });
 }
 function isFindReplaceOnlyEdit(args) {
@@ -11448,6 +11448,7 @@ function aftLiveConfigKeys(resolveBash) {
   return [
     pathKey("configure_warnings_delivery"),
     pathKey("restrict_to_project_root"),
+    pathKey("revision_reads"),
     pathKey("inspect.diagnostics_timeout_ms"),
     pathKey("inspect.tier2_idle_minutes"),
     pathKey("lsp.idle_minutes"),
@@ -11465,7 +11466,8 @@ function aftLiveConfigKeys(resolveBash) {
     bashKey("runon_enabled", resolveBash),
     bashKey("subagent_background", resolveBash),
     bashKey("watch_sync_max_ms", resolveBash),
-    bashKey("worker_wait_max_ms", resolveBash)
+    bashKey("worker_wait_max_ms", resolveBash),
+    bashKey("env", resolveBash)
   ];
 }
 function sameValue(a, b) {
@@ -15342,6 +15344,47 @@ function isSocketDeathError(error, depth = 0) {
   }
   return isConsumerReconnectTransient(error) || isSubcClientClosedError(error);
 }
+var REQUEST_CONNECTION_LOSS_CODES = new Set(["ECONNABORTED", "ECONNRESET", "EPIPE"]);
+function hasRequestConnectionLossCode(error) {
+  if (typeof error !== "object" || error === null || !("code" in error))
+    return false;
+  return typeof error.code === "string" && REQUEST_CONNECTION_LOSS_CODES.has(error.code);
+}
+function hasRequestConnectionLossEvidence(error, depth = 0) {
+  if (error instanceof SocketClosedError)
+    return true;
+  if (error instanceof SubcError && error.closeReason === "connection_lost")
+    return true;
+  if (hasRequestConnectionLossCode(error))
+    return true;
+  if (!(error instanceof SubcCallError) || error.kind !== "outcome_unknown" || depth >= 4 || error.cause === undefined || error.cause === error) {
+    return false;
+  }
+  return hasRequestConnectionLossEvidence(error.cause, depth + 1);
+}
+function connectionClosedAfterDispatch(error) {
+  if (error instanceof SubcCallError && error.kind === "not_sent")
+    return error;
+  if (typeof error === "object" && error !== null && "kind" in error && error.kind === "not_sent") {
+    return error;
+  }
+  if (!hasRequestConnectionLossEvidence(error))
+    return error;
+  if (error instanceof SubcCallError)
+    return error;
+  if (!(error instanceof Error))
+    return error;
+  return Object.assign(error, { kind: "outcome_unknown" });
+}
+var dispatchedRequestDeadlines = new WeakSet;
+function noteDispatchedRequestDeadline(error) {
+  if (error instanceof SubcError && error.code === REQUEST_DEADLINE_CODE) {
+    dispatchedRequestDeadlines.add(error);
+  }
+}
+function isDispatchedRequestDeadlineError(error) {
+  return typeof error === "object" && error !== null && dispatchedRequestDeadlines.has(error);
+}
 function isUnansweredCallError(error) {
   if (isSocketDeathError(error))
     return false;
@@ -15948,7 +15991,24 @@ class SubcTransport {
       return {};
     const preview = options.preview;
     const timeoutMs = options.transportTimeoutMs ?? options.timeoutMs;
-    const onProgress = options.onProgress;
+    const callback = options.onProgress;
+    const onProgress = callback ? (body) => {
+      let frame;
+      try {
+        frame = JSON.parse(new TextDecoder().decode(body));
+      } catch {
+        return;
+      }
+      if (typeof frame !== "object" || frame === null)
+        return;
+      const progress = frame;
+      if (progress.type !== "progress" || typeof progress.chunk !== "string")
+        return;
+      callback({
+        kind: progress.kind === "stderr" ? "stderr" : "stdout",
+        text: progress.chunk
+      });
+    } : undefined;
     return { preview, timeoutMs, onProgress, abortSignal: options.abortSignal };
   }
 }
@@ -15960,7 +16020,7 @@ class SubcTransportPool {
   consumerIdentity;
   hostScopes;
   hostScopeCache = new Map;
-  hostScopeRefusals = new Set;
+  hostScopeRefusals = new Map;
   hostScopeOutcomes = new Map;
   connectFn;
   onBgEventsNudge;
@@ -16847,7 +16907,7 @@ class SubcTransportPool {
             this.resetRouteReopenBackoff();
           return reply;
         } catch (requestError) {
-          const error = frameReadTimeoutError(routeClosedMidCallError(requestError, routeAndEntry.entry, record));
+          const error = frameReadTimeoutError(routeClosedMidCallError(connectionClosedAfterDispatch(requestError), routeAndEntry.entry, record));
           if (this.isReapInduced(record))
             throw this.annotateReapError(error, record);
           const ownsRoute = this.isCurrentSession(key, record) && this.client === client;
@@ -16881,6 +16941,7 @@ class SubcTransportPool {
             continue;
           }
           handleRequestFailure(error, routeAndEntry.entry);
+          noteDispatchedRequestDeadline(error);
           throw error;
         }
       }
@@ -17014,20 +17075,38 @@ class SubcTransportPool {
     return { route: await opening, entry };
   }
   hostScope(client, identity) {
-    if (this.hostScopeRefusals.has(identity.session))
-      return Promise.resolve(undefined);
+    let lookupReason = "cache_miss";
+    const refused = this.hostScopeRefusals.get(identity.session);
+    if (refused) {
+      const previous = this.hostScopeCache.get(identity.session);
+      if (previous)
+        this.cancelHostScopeRetry(previous);
+      this.hostScopeCache.delete(identity.session);
+      this.hostScopeRefusals.delete(identity.session);
+      lookupReason = `previous_bind_refusal code=${refused}`;
+    }
     let state = this.hostScopeCache.get(identity.session);
     if (!state) {
       state = { retryAt: 0, retryMs: HOST_SCOPE_RETRY_FLOOR_MS };
       this.hostScopeCache.set(identity.session, state);
     }
     if (state.answer) {
-      return Promise.resolve(state.answer.result === "scope" && !state.scopeBindPending ? state.answer.scope : undefined);
+      const reason = state.scopeBindPending ? "scope_sync_pending" : `cached_${state.answer.result}`;
+      log(`subc head scope: session=${identity.session} lookup=skipped reason=${reason}`);
+      return Promise.resolve({
+        scope: state.answer.result === "scope" && !state.scopeBindPending ? state.answer.scope : undefined,
+        reason
+      });
     }
-    if (state.pending)
+    if (state.pending) {
+      log(`subc head scope: session=${identity.session} lookup=skipped reason=inflight_lookup`);
       return state.pending;
-    if (Date.now() < state.retryAt)
-      return Promise.resolve(undefined);
+    }
+    if (Date.now() < state.retryAt) {
+      log(`subc head scope: session=${identity.session} lookup=skipped reason=backoff retry_in=${state.retryAt - Date.now()}ms`);
+      return Promise.resolve({ reason: state.unscopedReason ?? "lookup_backoff" });
+    }
+    log(`subc head scope: session=${identity.session} lookup=started reason=${lookupReason}`);
     const current = state;
     clearTimeout(current.retryTimer);
     current.retryTimer = undefined;
@@ -17035,24 +17114,32 @@ class SubcTransportPool {
     current.lookupAbort = abort;
     const lookup = this.readHostScope(client, identity, abort.signal).then((outcome) => {
       if (this.hostScopeCache.get(identity.session) !== current)
-        return;
+        return { reason: "lookup_invalidated" };
       current.pending = undefined;
       current.lookupAbort = undefined;
       if (abort.signal.aborted)
-        return;
+        return { reason: "lookup_cancelled" };
       this.logHostScopeOutcome(identity.session, outcome);
+      const reason = outcome.result === "error" ? `lookup_error code=${outcome.code}` : `lookup_${outcome.result}`;
       if (outcome.result === "scope" || outcome.result === "no_scope") {
         current.answer = outcome;
         current.retryAt = 0;
         current.retryMs = HOST_SCOPE_RETRY_FLOOR_MS;
-        if (outcome.result === "scope")
-          this.promoteHostScope(identity.session);
+        if (outcome.result === "scope") {
+          current.promoteAfterBind = Boolean(refused);
+          if (!current.promoteAfterBind)
+            this.promoteHostScope(identity.session);
+        }
       } else {
+        current.unscopedReason = reason;
         current.retryAt = Date.now() + current.retryMs;
         current.retryMs = Math.min(current.retryMs * 2, HOST_SCOPE_RETRY_CAP_MS);
         this.scheduleHostScopeRetry(identity.session, current);
       }
-      return outcome.result === "scope" ? outcome.scope : undefined;
+      return {
+        scope: outcome.result === "scope" ? outcome.scope : undefined,
+        reason
+      };
     });
     current.pending = lookup;
     return lookup;
@@ -17099,7 +17186,7 @@ class SubcTransportPool {
         retry = this.hostScope(client, record.identity);
       }
       retry.catch((error) => {
-        warn(`subc head scope: background retry failed code=${error instanceof Error ? error.name : "Error"}`);
+        warn(`subc head scope: session=${session} background retry failed code=${error instanceof Error ? error.name : "Error"}`);
       });
     }, Math.max(0, state.retryAt - Date.now()));
     state.retryTimer.unref();
@@ -17115,8 +17202,8 @@ class SubcTransportPool {
   }
   refuseHostScopeBind(session, state, code) {
     if (!this.hostScopeRefusals.has(session)) {
-      this.hostScopeRefusals.add(session);
-      warn(`subc head scope: session=${session} scoped bind refused code=${code}; binding unscoped; retry stopped`);
+      this.hostScopeRefusals.set(session, code);
+      warn(`subc head scope: session=${session} scoped bind refused code=${code}; retry stopped until next bind lookup`);
     }
     if (state) {
       state.scopeBindPending = false;
@@ -17125,11 +17212,12 @@ class SubcTransportPool {
   }
   async retryHostScopeBind(client, identity, state, scope) {
     try {
-      const route = await client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, { consumerIdentity: this.consumerIdentity, scope });
+      const route = await this.bindHostToolRoute(client, identity, "scope_probe", "scope_sync_retry", scope);
       safeCloseRoute(client, route);
       if (this.hostScopeCache.get(identity.session) !== state || !state.scopeBindPending || this.shuttingDown || client !== this.client || !this.unscopedHostRecord(identity.session))
         return;
       state.scopeBindPending = false;
+      state.promoteAfterBind = false;
       state.retryAt = 0;
       state.retryMs = HOST_SCOPE_RETRY_FLOOR_MS;
       log(`subc head scope: session=${identity.session} scoped bind recovered ref=${scope.ref.slice(0, 8)} epoch=${scope.scopeEpoch}`);
@@ -17255,24 +17343,39 @@ class SubcTransportPool {
       signal.removeEventListener("abort", cancel);
     }
   }
-  openHostToolRoute(client, identity, record, entry) {
+  openHostToolRoute(client, identity, record, entry, channel = "tool") {
     if (!this.hostScopes || !["opencode", "pi"].includes(identity.harness) || identity.session === DEFAULT_SESSION_ID) {
-      return client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, {
-        consumerIdentity: this.consumerIdentity
-      });
+      const reason = !this.hostScopes ? "host_scopes_disabled" : identity.session === DEFAULT_SESSION_ID ? "default_session" : "unsupported_harness";
+      log(`subc head scope: session=${identity.session} lookup=skipped reason=${reason}`);
+      return this.bindHostToolRoute(client, identity, channel, reason);
     }
-    return this.openScopedHostToolRoute(client, identity, record, entry);
+    return this.openScopedHostToolRoute(client, identity, record, entry, channel);
   }
-  async openScopedHostToolRoute(client, identity, record, entry) {
-    const scope = await this.hostScope(client, identity);
+  bindHostToolRoute(client, identity, channel, reason, scope) {
+    log(`subc head scope: session=${identity.session} bind=${scope ? "scoped" : "unscoped"} channel=${channel} root=${identity.project_root} reason=${reason}` + (scope ? ` ref=${scope.ref.slice(0, 8)} epoch=${scope.scopeEpoch}` : ""));
+    return client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, {
+      consumerIdentity: this.consumerIdentity,
+      ...scope ? { scope } : {}
+    });
+  }
+  async openScopedHostToolRoute(client, identity, record, entry, channel = "tool") {
+    const decision = await this.hostScope(client, identity);
+    const scope = decision.scope;
+    let reason = decision.reason;
     this.assertRecordLive(record);
     if (scope) {
       try {
-        const route = await client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, { consumerIdentity: this.consumerIdentity, scope });
+        const route = await this.bindHostToolRoute(client, identity, channel, reason, scope);
         if (entry)
           entry.hostScope = scope;
+        const state = this.hostScopeCache.get(identity.session);
+        if (state?.promoteAfterBind && state.answer?.result === "scope" && state.answer.scope === scope) {
+          state.promoteAfterBind = false;
+          this.promoteHostScope(identity.session);
+        }
         return route;
       } catch (error) {
+        log(`subc head scope: session=${identity.session} bind=failed channel=${channel} reason=scoped_open_error code=${error instanceof SubcError ? error.code ?? error.name : "Error"}`);
         if (!(error instanceof SubcError) || !error.code || isSocketDeathError(error))
           throw error;
         if (isRouteOpenReloadWindowError(error))
@@ -17281,18 +17384,21 @@ class SubcTransportPool {
         const state = this.hostScopeCache.get(identity.session);
         if (state && isHostScopeSyncRefusal(error.code)) {
           this.deferHostScopeBind(identity.session, state, error.code);
+          reason = `scope_sync_pending code=${error.code}`;
         } else {
           this.refuseHostScopeBind(identity.session, state, error.code);
+          if (decision.reason === "cached_scope") {
+            return this.openScopedHostToolRoute(client, identity, record, entry, channel);
+          }
+          reason = `scoped_bind_refused code=${error.code}`;
         }
       }
     }
     this.assertRecordLive(record);
-    const route = await client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, {
-      consumerIdentity: this.consumerIdentity
-    });
+    const route = await this.bindHostToolRoute(client, identity, channel, reason);
     if (this.hostScopeCache.get(identity.session)?.answer?.result === "scope" && !this.hostScopeCache.get(identity.session)?.scopeBindPending && !this.hostScopeRefusals.has(identity.session)) {
       safeCloseRoute(client, route);
-      return this.openScopedHostToolRoute(client, identity, record, entry);
+      return this.openScopedHostToolRoute(client, identity, record, entry, channel);
     }
     return route;
   }
@@ -17389,7 +17495,7 @@ class SubcTransportPool {
     };
     sub = new BgSubscription(identity, () => this.ensureClient(), (client, cause) => this.dropClient(client, cause), (client) => {
       binding.hostScope = undefined;
-      return this.openHostToolRoute(client, identity, record, binding);
+      return this.openHostToolRoute(client, identity, record, binding, "bg_events");
     }, onNudge, this.bgBackoffSleep, () => this.rootCanAttach(record.canonicalRoot), (error) => {
       if (!isAbsentRootRouteError(error))
         return false;
@@ -17682,11 +17788,54 @@ function shellTimeoutDisposition(outcome) {
 var SUBC_MODULE_RESTART_DISPOSITION = "The AFT daemon module restarted while this call was in flight, so its outcome is UNKNOWN: it may or may not have executed. Verify actual state before re-running, and never blind-retry a mutation.";
 var BRIDGE_TRANSPORT_UNKNOWN_OUTCOME_DISPOSITION = "The standalone AFT transport failed after this call may have been sent, so its outcome is UNKNOWN: it may or may not have executed. Verify actual state before re-running, and never blind-retry a mutation.";
 var SUBC_ROUTE_CLOSED_MID_CALL_DISPOSITION = "The plugin closed this call's route while the call was in flight, so its outcome is UNKNOWN: it may or may not have executed. Verify actual state before re-running, and never blind-retry a mutation.";
+var SUBC_CONNECTION_CLOSED_MID_CALL_DISPOSITION = "The AFT module connection closed while this request was in flight, so its outcome is UNKNOWN: it may or may not have executed. Verify actual state before retrying, and never blindly retry a mutation.";
+function bashConnectionClosedDisposition(taskId) {
+  const taskFollowup = taskId ? `Use bash_status or bash_watch with task ID ${taskId} to check it.` : "If a task ID is available, use it with bash_status or bash_watch; otherwise wait for the completion notice.";
+  return `The command may have run or may still be running. AFT keeps commands running when the connection drops; a completion notice will follow if it ran. ${taskFollowup} Do not rerun it.`;
+}
+
+class AftModuleUnavailableError extends SubcCallError {
+  constructor(message, cause) {
+    super("not_sent", message, "aft_module_unavailable", cause);
+    this.name = "AftModuleUnavailableError";
+  }
+}
+function refuseAftModuleOptionWithoutFallback(error, option, refusalPrefix) {
+  return new AftModuleUnavailableError(`${refusalPrefix}; ${option} has no host fallback. Nothing was started, so it is safe to retry after the AFT module connection is restored.`, error);
+}
 var BASH_FRAME_READ_TIMEOUT_DISPOSITION = "The command's state is UNKNOWN: the transport timed out while reading the response frame, so it may or may not have executed. Check bash_status if a task ID could have been assigned, and do not re-run side-effecting commands blindly.";
 var SUBC_FRAME_READ_TIMEOUT_DISPOSITION = "The transport timed out while reading the response frame for this call, so its outcome is UNKNOWN: it may or may not have executed. Verify actual state before re-running, and never blind-retry a mutation.";
 function isRouteClosedMidCallError(error) {
   return error instanceof SubcRouteClosedMidCallError || isLocalRouteCloseRejection(error);
 }
+function isSubcConnectionClosedMidCallError(error) {
+  if (!(error instanceof Error))
+    return false;
+  const fields = error;
+  if (fields.kind !== "outcome_unknown")
+    return false;
+  if (error instanceof SocketClosedError)
+    return true;
+  if (error instanceof SubcError)
+    return error.closeReason === "connection_lost";
+  if (error instanceof SubcCallError) {
+    return error.closeReason === "connection_lost" || hasConnectionLossCause(error);
+  }
+  return hasConnectionLossCause(error);
+}
+var CONNECTION_LOSS_ERROR_CODES = new Set(["ECONNABORTED", "ECONNRESET", "EPIPE"]);
+function hasConnectionLossCause(error, depth = 0) {
+  if (error instanceof SocketClosedError)
+    return true;
+  if (error instanceof SubcError && error.closeReason === "connection_lost")
+    return true;
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" && CONNECTION_LOSS_ERROR_CODES.has(error.code)) {
+    return true;
+  }
+  if (!(error instanceof Error) || depth >= 4 || error.cause === undefined)
+    return false;
+  return hasConnectionLossCause(error.cause, depth + 1);
+}
 function isRouteGoodbyeError(error) {
   if (!(error instanceof SubcError))
     return false;
@@ -17741,6 +17890,8 @@ function classifyBashHostFallbackError(error) {
   if (!(error instanceof Error) || hasEngineResponse(error) || isRouteGoodbyeError(error)) {
     return;
   }
+  if (isSubcConnectionClosedMidCallError(error))
+    return;
   if (error instanceof BridgeTransportUnknownOutcomeError)
     return;
   if (isRouteClosedMidCallError(error))
@@ -17767,6 +17918,8 @@ function isBashTransportDeadError(error) {
 function adaptToolError(command, error) {
   if (!(error instanceof Error))
     return error;
+  if (error instanceof AftModuleUnavailableError)
+    return error;
   if (isSubcFrameReadTimeoutError(error)) {
     const typedError = error instanceof SubcFrameReadTimeoutError ? error : new SubcFrameReadTimeoutError(error);
     const disposition = command === "bash" ? BASH_FRAME_READ_TIMEOUT_DISPOSITION : SUBC_FRAME_READ_TIMEOUT_DISPOSITION;
@@ -17781,6 +17934,13 @@ function adaptToolError(command, error) {
     error.message = error.message ? `${error.message} ${BRIDGE_TRANSPORT_UNKNOWN_OUTCOME_DISPOSITION}` : BRIDGE_TRANSPORT_UNKNOWN_OUTCOME_DISPOSITION;
     return error;
   }
+  if (isSubcConnectionClosedMidCallError(error)) {
+    const disposition = command === "bash" ? bashConnectionClosedDisposition(taskIdFromError(error)) : SUBC_CONNECTION_CLOSED_MID_CALL_DISPOSITION;
+    if (error.message.includes(disposition))
+      return error;
+    error.message = error.message ? `${error.message} ${disposition}` : disposition;
+    return error;
+  }
   if (isRouteGoodbyeError(error)) {
     if (error.message.includes(SUBC_MODULE_RESTART_DISPOSITION))
       return error;
@@ -17793,6 +17953,13 @@ function adaptToolError(command, error) {
     error.message = error.message ? `${error.message} ${SUBC_ROUTE_CLOSED_MID_CALL_DISPOSITION}` : SUBC_ROUTE_CLOSED_MID_CALL_DISPOSITION;
     return error;
   }
+  if (command === "bash" && isDispatchedRequestDeadlineError(error)) {
+    const disposition = bashConnectionClosedDisposition(taskIdFromError(error));
+    if (error.message.includes(disposition))
+      return error;
+    error.message = error.message ? `${error.message} ${disposition}` : disposition;
+    return error;
+  }
   if ((command === "bash" || command === "powershell") && isBridgeTransportTimeout(error)) {
     const outcome = error.shellOutcome;
     const disposition = shellTimeoutDisposition(outcome);
@@ -17801,6 +17968,9 @@ function adaptToolError(command, error) {
     error.message = error.message ? `${error.message} ${disposition}` : disposition;
     return error;
   }
+  if (command !== "bash" && isBashTransportDeadError(error)) {
+    return new AftModuleUnavailableError("The AFT module connection is down or unavailable; this AFT-backed option has no host fallback. Nothing was started, so it is safe to retry after the connection is restored.", error);
+  }
   if (command !== "bash" || !isBashTransportDeadError(error))
     return error;
   if (error.message.includes(BASH_TRANSPORT_DISPOSITION))
@@ -17808,6 +17978,15 @@ function adaptToolError(command, error) {
   error.message = error.message ? `${error.message} ${BASH_TRANSPORT_DISPOSITION}` : BASH_TRANSPORT_DISPOSITION;
   return error;
 }
+function taskIdFromError(error) {
+  for (let current = error, depth = 0;current instanceof Error && depth < 5; current = current.cause, depth += 1) {
+    const fields = current;
+    const taskId = fields.taskId ?? fields.task_id;
+    if (typeof taskId === "string" && taskId.length > 0)
+      return taskId;
+  }
+  return;
+}
 // ../aft-bridge/dist/feature-config.js
 import { createHash as createHash4 } from "node:crypto";
 var CANONICAL_TOOLS = [
@@ -22993,39 +23172,70 @@ function validateOptionalCanonicalPath(record, property) {
   }
   pathValue(record, property);
 }
-function normalizeZoomTargets(record) {
-  if (!hasOwn(record, "targets"))
-    return;
-  const targets = record.targets;
-  const normalizeTarget = (target, index) => {
-    if (!target || typeof target !== "object" || Array.isArray(target)) {
-      throw new InvalidRequestError(`'targets[${index}].path' must be a non-empty string`);
-    }
-    const source = target;
-    const blank = (value) => value === undefined || value === null || typeof value === "string" && !value.trim();
-    const emptyTarget = blank(source.symbol) && blank(source.path) && blank(source.filePath);
-    if (emptyTarget)
-      return { ...source };
-    const normalized = { ...source };
-    try {
-      normalizeAliasPair(normalized, "path", "filePath", false);
-    } catch (error) {
-      if (error instanceof InvalidRequestError) {
-        throw new InvalidRequestError(error.message.replace("'filePath'", `'targets[${index}].filePath'`).replace("'path'", `'targets[${index}].path'`));
-      }
-      throw error;
+function normalizeZoomLocation(record, prefix = "") {
+  let first;
+  for (const key of ["target", "path", "filePath", "url"]) {
+    const value = record[key];
+    if (value === undefined || value === null || typeof value === "string" && !value.trim()) {
+      delete record[key];
+      continue;
     }
-    return normalized;
-  };
-  if (Array.isArray(targets)) {
-    if (targets.length === 0)
-      return;
-    record.targets = targets.map(normalizeTarget);
-    return;
-  }
-  if (targets && typeof targets === "object") {
-    record.targets = normalizeTarget(targets, 0);
+    const location = pathValue(record, key);
+    if (first && first.value !== location) {
+      throw new InvalidRequestError(`Conflicting '${prefix}${first.key}' location '${first.value}' and '${prefix}${key}' '${location}': provide the same location or only one target`);
+    }
+    first ??= { key, value: location };
   }
+  for (const alias of ["path", "filePath", "url"])
+    delete record[alias];
+  if (first)
+    record.target = first.value;
+}
+function normalizeZoomTargets(record) {
+  const normalizeEntry = (value, prefix) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new InvalidRequestError(`'${prefix}target' must be a non-empty string`);
+    }
+    const entry = { ...value };
+    normalizeZoomLocation(entry, prefix);
+    if (hasOwn(entry, "symbol")) {
+      if (!isBlankParam(entry.symbols) && JSON.stringify(entry.symbols) !== JSON.stringify(entry.symbol)) {
+        throw new InvalidRequestError(`Conflicting '${prefix}symbols' and '${prefix}symbol': provide the same symbols or only one spelling`);
+      }
+      if (isBlankParam(entry.symbols))
+        entry.symbols = entry.symbol;
+      delete entry.symbol;
+    }
+    entry.target ??= "";
+    entry.symbols ??= "";
+    return entry;
+  };
+  const batch = [];
+  if (hasOwn(record, "batch")) {
+    const entries = coerceJsonCollectionParam(record.batch, "batch");
+    if (!Array.isArray(entries) || entries.length === 0) {
+      throw new InvalidRequestError("'batch' must be a non-empty array of {target, symbols}");
+    }
+    batch.push(...entries.map((entry, index) => normalizeEntry(entry, `batch[${index}].`)));
+  }
+  normalizeZoomLocation(record);
+  if (!isBlankParam(record.target) || !isBlankParam(record.symbols)) {
+    const entry = {};
+    if (record.target !== undefined)
+      entry.target = record.target;
+    if (record.symbols !== undefined)
+      entry.symbols = record.symbols;
+    batch.unshift(normalizeEntry(entry, ""));
+  }
+  if (hasOwn(record, "targets")) {
+    const targets = coerceJsonCollectionParam(record.targets, "targets");
+    batch.push(...usableZoomTargets(targets).map((entry, index) => normalizeEntry(entry, `targets[${index}].`)));
+  }
+  for (const key of ["target", "symbols", "targets"])
+    delete record[key];
+  if (!batch.length)
+    throw new InvalidRequestError("'batch' must be a non-empty array of {target, symbols}");
+  record.batch = batch;
 }
 function bareToolName(toolName) {
   const bare = toolName.startsWith("aft_") ? toolName.slice(4) : toolName;
@@ -23052,7 +23262,6 @@ function prepareCanonicalPathArguments(toolName, rawArguments) {
       normalizeAliasPair(record, "path", "filePath", true);
       break;
     case "zoom":
-      normalizeAliasPair(record, "path", "filePath", false);
       normalizeZoomTargets(record);
       break;
     case "callgraph":
@@ -23473,6 +23682,19 @@ function copyOwnProperties(source) {
     copy[key] = source[key];
   return copy;
 }
+// ../aft-bridge/dist/revision-reads.js
+var REVISION_REF_DESCRIPTION = "Git revision to read the file at instead of the working tree: a branch, tag, full or short commit SHA, or a form like HEAD~2. Content comes from git's object store; the working tree, index and HEAD are not touched.";
+var REVISION_REF_TOOL_NOTE = "Pass `ref` to read the file as it is at a git revision (branch, tag, SHA, HEAD~2); the reply's first line names the commit it resolved to.";
+function revisionReadsOffered(config) {
+  return config.revision_reads === true;
+}
+function revisionRefArg(value) {
+  if (value === undefined || value === null)
+    return;
+  if (typeof value === "string" && value.trim().length === 0)
+    return;
+  return value;
+}
 // ../aft-bridge/dist/semantic-status.js
 var MISSING_ONNX_RUNTIME_MARKER = "ONNX Runtime not found.";
 var MISSING_ONNX_RUNTIME_LABEL = "unavailable — ONNX Runtime missing (npx @cortexkit/aft doctor --fix)";
@@ -28495,6 +28717,41 @@ var ExperimentalConfigSchema = object({
   }).optional(),
   lsp_ty: boolean2().optional()
 });
+var BLOCKED_BASH_ENV_NAMES = new Set([
+  "LD_PRELOAD",
+  "LD_LIBRARY_PATH",
+  "LD_AUDIT",
+  "DYLD_INSERT_LIBRARIES",
+  "DYLD_LIBRARY_PATH",
+  "DYLD_FALLBACK_LIBRARY_PATH",
+  "BASH_ENV",
+  "ENV",
+  "IFS",
+  "PATH",
+  "SHELLOPTS",
+  "BASHOPTS",
+  "PROMPT_COMMAND",
+  "PS4",
+  "PYTHONSTARTUP",
+  "PYTHONPATH",
+  "PYTHONHOME",
+  "PERL5OPT",
+  "PERL5LIB",
+  "PERLLIB",
+  "PERL5DB",
+  "RUBYOPT",
+  "RUBYLIB",
+  "NODE_OPTIONS",
+  "GCONV_PATH",
+  "LOCPATH",
+  "NLSPATH",
+  "HOSTALIASES",
+  "RESOLV_HOST_CONF"
+]);
+function isBlockedBashEnvKey(key) {
+  const normalized = process.platform === "win32" ? key.toUpperCase() : key;
+  return BLOCKED_BASH_ENV_NAMES.has(normalized) || normalized.startsWith("LD_") || normalized.startsWith("DYLD_") || normalized.startsWith("BASH_FUNC_");
+}
 var BashFeaturesSchema = object({
   enabled: boolean2().optional(),
   rewrite: boolean2().optional(),
@@ -28514,7 +28771,18 @@ var BashFeaturesSchema = object({
   }).optional(),
   linux_scope: boolean2().optional(),
   disclaim_privacy: boolean2().optional(),
-  powershell_tool: boolean2().optional()
+  powershell_tool: boolean2().optional(),
+  env: record(string2(), string2()).superRefine((env, context) => {
+    for (const key of Object.keys(env)) {
+      if (isBlockedBashEnvKey(key)) {
+        context.addIssue({
+          code: "custom",
+          path: [key],
+          message: `bash.env key ${key} is blocked because it can alter startup or protected process state`
+        });
+      }
+    }
+  }).optional()
 });
 var BashConfigSchema = union([boolean2(), BashFeaturesSchema]);
 var SandboxConfigSchema = object({
@@ -28603,6 +28871,7 @@ var AftConfigFieldsSchema = object({
   $schema: string2().optional(),
   edit_mode: _enum(["default", "hashline"]).optional(),
   format_on_edit: boolean2().optional(),
+  revision_reads: boolean2().optional(),
   formatter_timeout_secs: number2().int().min(1).max(600).optional(),
   validate_on_edit: _enum(["syntax", "full"]).optional(),
   formatter: record(string2(), FormatterEnum).optional(),
@@ -28727,7 +28996,8 @@ function resolveBashConfig(config) {
     foreground_wait_window_ms: foregroundWaitWindowMs,
     watch_sync_max_ms: watchSyncMaxMs,
     worker_wait_max_ms: (typeof top === "object" && top !== null ? top.worker_wait_max_ms : undefined) ?? DEFAULT_WORKER_WAIT_MAX_MS,
-    powershell_tool: typeof top === "object" && top !== null ? top.powershell_tool ?? false : false
+    powershell_tool: typeof top === "object" && top !== null ? top.powershell_tool ?? false : false,
+    env: typeof top === "object" && top !== null ? { ...top.env ?? {} } : {}
   };
   if (top === false) {
     return base;
@@ -29057,6 +29327,7 @@ function getProjectLspStrippedKeys(lsp) {
 var PROJECT_SAFE_TOP_LEVEL_FIELDS = new Set([
   "edit_mode",
   "format_on_edit",
+  "revision_reads",
   "validate_on_edit",
   "configure_warnings_delivery",
   "views",
@@ -29111,6 +29382,8 @@ function getStrippedTopLevelKeys(override, base) {
   }
   if (typeof override.bash === "object" && override.bash.disclaim_privacy === false)
     stripped.push("bash.disclaim_privacy");
+  if (typeof override.bash === "object" && override.bash.env !== undefined)
+    stripped.push("bash.env");
   if (override.sandbox?.write_allow !== undefined)
     stripped.push("sandbox.write_allow");
   if (override.subc !== undefined)
@@ -29158,8 +29431,10 @@ function mergeConfigs(base, override) {
   const projectBash = typeof override.bash === "object" ? { ...override.bash } : override.bash;
   if (typeof projectBash === "object" && projectBash.disclaim_privacy !== true)
     delete projectBash.disclaim_privacy;
-  if (typeof projectBash === "object")
+  if (typeof projectBash === "object") {
     delete projectBash.runon_enabled;
+    delete projectBash.env;
+  }
   const bash = mergeBashConfig(base.bash, projectBash);
   const inspect = mergeInspectConfig(base.inspect, override.inspect);
   const worktree = mergeWorktreeConfig(base.worktree, override.worktree);
@@ -29699,7 +29974,7 @@ var wakeConfirmationWindowMs = DEFAULT_WAKE_CONFIRMATION_WINDOW_MS;
 var busyWakeDeferCeilingMs = BUSY_WAKE_DEFER_CEILING_MS;
 var lastWakeMessageTimestamp = 0;
 var wakeMessageCounter = 0;
-var subcNudgesInFlight = new Map;
+var subcNudgesInFlight = new WeakMap;
 var subcNudgeLogState = new Map;
 var deferredBusyWakes = new Map;
 function consumeBgCompletion(sessionID, taskId) {
@@ -29781,7 +30056,7 @@ function markExplicitControl(sessionID, taskId, trackOutstanding = true) {
   if (idx >= 0) {
     const completion = state.pendingCompletions[idx];
     state.pendingCompletions.splice(idx, 1);
-    queuePendingPatternMatch(state, completionToExitPattern(completion, true));
+    queuePendingPatternMatch(state, completionToExitPattern(completion, sessionID, true));
     state.wakeDeferredTaskIds.delete(taskId);
   }
 }
@@ -29818,7 +30093,7 @@ function queuePendingPatternMatch(state, entry) {
   }
   state.pendingPatternMatches.push(normalized);
 }
-function routeExplicitControlCompletions(state) {
+function routeExplicitControlCompletions(state, sessionID) {
   if (state.pendingCompletions.length === 0)
     return;
   const remaining = [];
@@ -29827,7 +30102,7 @@ function routeExplicitControlCompletions(state) {
       state.outstandingTaskIds.delete(completion.task_id);
       state.explicitControlTasks.delete(completion.task_id);
       state.wakeDeferredTaskIds.delete(completion.task_id);
-      queuePendingPatternMatch(state, completionToExitPattern(completion, true));
+      queuePendingPatternMatch(state, completionToExitPattern(completion, sessionID, true));
     } else {
       remaining.push(completion);
     }
@@ -29859,7 +30134,7 @@ function ingestBgCompletions(sessionID, completions) {
     if (state.explicitControlTasks.has(completion.task_id)) {
       state.outstandingTaskIds.delete(completion.task_id);
       state.explicitControlTasks.delete(completion.task_id);
-      queuePendingPatternMatch(state, completionToExitPattern(completion, true));
+      queuePendingPatternMatch(state, completionToExitPattern(completion, sessionID, true));
       continue;
     }
     if (isDeliveringOrAwaitingAck(state, completion.task_id)) {
@@ -29901,7 +30176,7 @@ async function appendInTurnBgCompletions(drainContext, output) {
   if (state.outstandingTaskIds.size > 0 || !state.forcedDrainCompleted) {
     await drainCompletions(drainContext);
   }
-  routeExplicitControlCompletions(state);
+  routeExplicitControlCompletions(state, drainContext.sessionID);
   if (state.pendingCompletions.length === 0 && state.pendingLongRunning.length === 0 && state.pendingPatternMatches.length === 0)
     return;
   const deliveredCompletions = [...state.pendingCompletions];
@@ -29917,6 +30192,9 @@ async function appendInTurnBgCompletions(drainContext, output) {
     reminder_chars: reminder.length
   });
   state.pendingCompletions = [];
+  for (const completion of deliveredCompletions) {
+    consumeBgCompletion(drainContext.sessionID, completion.task_id);
+  }
   state.heldWorkerCompletions = false;
   for (const completion of deliveredCompletions) {
     state.wakeDeferredTaskIds.delete(completion.task_id);
@@ -29940,17 +30218,22 @@ async function handleIdleBgCompletions(drainContext) {
 }
 function handleSubcBgEventsNudge(drainContext) {
   const key = `${drainContext.directory}\x00${drainContext.sessionID}`;
-  const inFlight = subcNudgesInFlight.get(key);
+  let poolNudges = subcNudgesInFlight.get(drainContext.ctx.pool);
+  if (!poolNudges) {
+    poolNudges = new Map;
+    subcNudgesInFlight.set(drainContext.ctx.pool, poolNudges);
+  }
+  const inFlight = poolNudges.get(key);
   if (inFlight) {
     logSubcNudgeLifecycle(drainContext, "coalesced-in-flight", "nudge coalesced cause=handler-already-in-flight");
     return inFlight;
   }
   logSubcNudgeLifecycle(drainContext, "handler-entry", "nudge handler entered");
   const handling = handleSubcBgEventsNudgeOnce(drainContext);
-  subcNudgesInFlight.set(key, handling);
+  poolNudges.set(key, handling);
   const clear = () => {
-    if (subcNudgesInFlight.get(key) === handling)
-      subcNudgesInFlight.delete(key);
+    if (poolNudges.get(key) === handling)
+      poolNudges.delete(key);
   };
   handling.then(clear, clear);
   return handling;
@@ -29959,9 +30242,62 @@ async function handleSubcBgEventsNudgeOnce(drainContext) {
   bridgeForDrain(drainContext);
   const state = stateFor(drainContext.sessionID);
   state.wakeDeferredTaskIds.clear();
+  if (drainContext.delivery) {
+    await drainCompletions(drainContext);
+    await deliverDrainedNotifications(drainContext, drainContext.delivery);
+    return;
+  }
   rearmHardStoppedWake(state, drainContext);
   await triggerWakeIfPending(drainContext, false, true, true, true);
 }
+async function deliverDrainedNotifications(drainContext, delivery) {
+  const state = stateFor(drainContext.sessionID);
+  routeExplicitControlCompletions(state, drainContext.sessionID);
+  const completions = state.pendingCompletions.splice(0);
+  const matches = state.pendingPatternMatches.splice(0);
+  const taskIds = [...new Set([...completions, ...matches].map((item) => item.task_id))];
+  markDelivering(state, taskIds);
+  const bridge = bridgeForDrain(drainContext);
+  const items = [...completions, ...matches];
+  for (const [index, item] of items.entries()) {
+    const isMatch = isPatternMatchEntry(item);
+    try {
+      if (!isMatch && state.consumedTaskIds.has(item.task_id))
+        continue;
+      const admitted = isMatch ? await delivery.patternMatch(item, bridge) : await delivery.completion(item, bridge);
+      if (!admitted) {
+        if (isMatch)
+          queuePendingPatternMatch(state, item);
+        else if (!state.consumedTaskIds.has(item.task_id))
+          state.pendingCompletions.push(item);
+        continue;
+      }
+      if (!isMatch)
+        consumeBgCompletion(drainContext.sessionID, item.task_id);
+      markDeliveredAwaitingAck(state, [item.task_id]);
+      const acked = await ackCompletions(drainContext, [
+        { task_id: item.task_id, status: "unknown", exit_code: null, command: "" }
+      ]);
+      if (acked)
+        confirmAcked(state, [item.task_id]);
+    } catch (error) {
+      if (isMatch)
+        queuePendingPatternMatch(state, item);
+      else
+        state.pendingCompletions.push(item);
+      for (const remaining of items.slice(index + 1)) {
+        if (isPatternMatchEntry(remaining))
+          queuePendingPatternMatch(state, remaining);
+        else
+          state.pendingCompletions.push(remaining);
+      }
+      clearDelivering(state, taskIds);
+      throw error;
+    } finally {
+      clearDelivering(state, [item.task_id]);
+    }
+  }
+}
 function logSubcNudgeLifecycle(drainContext, kind, message) {
   logDeliveryHop(drainContext, kind, message, {
     event: "subc_bg_nudge_delivery",
@@ -30275,7 +30611,7 @@ async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredComp
   if (!skipDrain && (forceDrain || state.outstandingTaskIds.size > 0 || !state.forcedDrainCompleted) && (forceDrain || hasTrackedOrPendingWork || idleDrainMayFindWork(state, drainContext))) {
     await drainCompletions(drainContext);
   }
-  routeExplicitControlCompletions(state);
+  routeExplicitControlCompletions(state, drainContext.sessionID);
   if (!hasWakeEligiblePending(state, includeDeferredCompletions))
     return;
   if (deferWhileBusy && state.hostStatus === "busy") {
@@ -30768,7 +31104,7 @@ function ingestDrainedBgCompletions(sessionID, completions) {
     state.outstandingTaskIds.delete(completion.task_id);
     if (state.explicitControlTasks.has(completion.task_id)) {
       state.explicitControlTasks.delete(completion.task_id);
-      queuePendingPatternMatch(state, completionToExitPattern(completion, true));
+      queuePendingPatternMatch(state, completionToExitPattern(completion, sessionID, true));
       continue;
     }
     if (state.consumedTaskIds.has(completion.task_id))
@@ -30809,12 +31145,12 @@ function bufferUnknownCompletion(state, completion) {
 function pruneUnknownCompletions(state, now) {
   state.unknownCompletions = state.unknownCompletions.filter((entry) => now - entry.receivedAt <= UNKNOWN_COMPLETION_TTL_MS);
 }
-function completionToExitPattern(completion, ackCompletionOnDelivery = false) {
+function completionToExitPattern(completion, sessionID, ackCompletionOnDelivery = false) {
   const status = formatStatus(completion);
   const preview = formatOutputPreview(completion).replace(/^ {4}/gm, "").slice(-300);
   const entry = {
     task_id: completion.task_id,
-    session_id: "",
+    session_id: sessionID || DEFAULT_SESSION_ID2,
     watch_id: "exit",
     match_text: "",
     match_offset: 0,
@@ -44086,6 +44422,10 @@ async function callToolCall(ctx, runtime, name, rawArgs = {}, options) {
     const opts = Object.keys(sendOptions).length > 0 ? sendOptions : undefined;
     response = ctx.pool.toolCallForCanonicalRoot ? await ctx.pool.toolCallForCanonicalRoot(root, runtime.sessionID, name, rawArgs, opts) : await ctx.pool.getBridge(root).toolCall(runtime.sessionID, name, rawArgs, opts);
   } catch (error) {
+    const noFallbackOption = name === "bash" ? rawArgs.runon !== undefined ? "runon" : rawArgs.pty === true ? "pty:true" : rawArgs.background === true ? "background:true" : undefined : undefined;
+    if (noFallbackOption && isBashTransportDeadError(error)) {
+      throw refuseAftModuleOptionWithoutFallback(error, noFallbackOption, BASH_HOST_FALLBACK_REFUSAL);
+    }
     throw adaptToolError(name, error);
   } finally {
     markBridgeEnd();
@@ -45343,17 +45683,19 @@ ${BASH_RUNON_GUIDANCE}`, "");
         });
       } catch (error) {
         const fallbackCause = classifyBashHostFallbackError(error);
-        if (!bashCfg.host_fallback || fallbackCause === undefined)
+        if (fallbackCause === undefined)
           throw error;
         if (!backgroundDisabled && rawRequestedBackground) {
-          throw new Error(`${BASH_HOST_FALLBACK_REFUSAL}; background:true is unsupported.`);
+          throw refuseAftModuleOptionWithoutFallback(error, "background:true", BASH_HOST_FALLBACK_REFUSAL);
         }
         if (requestedPty) {
-          throw new Error(`${BASH_HOST_FALLBACK_REFUSAL}; pty:true is unsupported.`);
+          throw refuseAftModuleOptionWithoutFallback(error, "pty:true", BASH_HOST_FALLBACK_REFUSAL);
         }
         if (runon !== undefined) {
-          throw new Error(`${BASH_HOST_FALLBACK_REFUSAL}; runon is unsupported, and the command was not run locally.`);
+          throw refuseAftModuleOptionWithoutFallback(error, "runon", BASH_HOST_FALLBACK_REFUSAL);
         }
+        if (!bashCfg.host_fallback)
+          throw error;
         const projectRoot = projectRootFor(context);
         const pattern = bashHostFallbackAskPattern(command, projectRoot, fallbackCause);
         await runAsk(context.ask({
@@ -45761,14 +46103,22 @@ function runtimeFor(name, location, context, signal, consumers, onStepAbort) {
 }
 function projectV2Tool(name, definition, location, consumers = {}) {
   const hostName = v2HostToolName(name);
-  const input = tool.schema.object(projectArguments(name, definition));
-  assertV2Contract(hostName, input);
+  const currentInput = () => {
+    const input = tool.schema.object(projectArguments(name, definition));
+    assertV2Contract(hostName, input);
+    return input;
+  };
+  currentInput();
   const sharedOptions = definition.options;
   const permission = hostPermission(name);
   return {
     name: hostName,
-    description: renameV2ToolReferences(definition.description),
-    input,
+    get description() {
+      return renameV2ToolReferences(["read", "write", "edit"].includes(name) ? definition.description.replaceAll("filePath", "path") : definition.description);
+    },
+    get input() {
+      return currentInput();
+    },
     options: {
       ...sharedOptions,
       ...permission ? { permission } : {},
@@ -46369,14 +46719,12 @@ function buildUnifiedDiff(fp, before, after) {
 `);
   const afterLines = after.split(`
 `);
-  const LINE_CAP = 5000;
-  if (beforeLines.length > LINE_CAP || afterLines.length > LINE_CAP) {
-    const limit = Math.max(beforeLines.length, afterLines.length);
+  const ops = diffLines(beforeLines, afterLines);
+  if (ops === null) {
     return `Index: ${fp}
-(diff skipped: file has ${limit} lines, above ${LINE_CAP}-line diff cap)
+(diff skipped: changed region exceeds the diff-work budget)
 `;
   }
-  const ops = diffLines(beforeLines, afterLines);
   if (ops.every((op) => op.tag === "eq")) {
     return `Index: ${fp}
 ===================================================================
@@ -46402,6 +46750,9 @@ function buildUnifiedDiff(fp, before, after) {
   }
   return diff;
 }
+var LCS_TABLE_CELL_BUDGET = 25010001;
+var MYERS_TRACE_CELL_BUDGET = 1500000;
+var MYERS_WORK_BUDGET = 25000000;
 function diffLines(a, b) {
   const n = a.length;
   const m = b.length;
@@ -46417,6 +46768,26 @@ function diffLines(a, b) {
   const innerM = m - prefix - suffix;
   const w = innerM + 1;
   const cells = (innerN + 1) * w;
+  if (cells > LCS_TABLE_CELL_BUDGET) {
+    const middle = myersDiff(a.slice(prefix, n - suffix), b.slice(prefix, m - suffix), prefix);
+    if (middle === null)
+      return null;
+    const ops = [];
+    for (let i = 0;i < prefix; i++) {
+      ops.push({ tag: "eq", beforeIdx: i, afterIdx: i, line: a[i] });
+    }
+    for (const op of middle)
+      ops.push(op);
+    for (let i = 0;i < suffix; i++) {
+      ops.push({
+        tag: "eq",
+        beforeIdx: n - suffix + i,
+        afterIdx: m - suffix + i,
+        line: a[n - suffix + i]
+      });
+    }
+    return ops;
+  }
   diffTableCells += cells;
   const inner = Math.min(innerN, innerM) < 65535 ? new Uint16Array(cells) : new Uint32Array(cells);
   for (let i = 1;i <= innerN; i++) {
@@ -46459,6 +46830,103 @@ function diffLines(a, b) {
   ops.reverse();
   return ops;
 }
+function myersDiff(a, b, baseIndex) {
+  const n = a.length;
+  const m = b.length;
+  const max = n + m;
+  const maxDepth = Math.min(max, Math.floor((Math.sqrt(1 + 8 * MYERS_TRACE_CELL_BUDGET) - 1) / 2));
+  const offset = maxDepth + 1;
+  const frontier = new Int32Array(2 * maxDepth + 3);
+  frontier[offset + 1] = 0;
+  const trace = [];
+  let traceCells = 0;
+  let work = 0;
+  for (let d = 0;d <= maxDepth; d++) {
+    let reachedEnd = false;
+    for (let k = -d;k <= d; k += 2) {
+      if (++work > MYERS_WORK_BUDGET)
+        return null;
+      let x;
+      if (k === -d || k !== d && frontier[offset + k - 1] < frontier[offset + k + 1]) {
+        x = frontier[offset + k + 1];
+      } else {
+        x = frontier[offset + k - 1] + 1;
+      }
+      let y = x - k;
+      while (x < n && y < m && a[x] === b[y]) {
+        if (++work > MYERS_WORK_BUDGET)
+          return null;
+        x++;
+        y++;
+      }
+      frontier[offset + k] = x;
+      if (x >= n && y >= m) {
+        reachedEnd = true;
+        break;
+      }
+    }
+    if (reachedEnd) {
+      const reversed = [];
+      let x = n;
+      let y = m;
+      for (let depth = d;depth > 0; depth--) {
+        const previous = trace[depth - 1];
+        const k = x - y;
+        const insert = k === -depth || k !== depth && previous[(k - 1 + depth - 1) / 2] < previous[(k + 1 + depth - 1) / 2];
+        const previousK = insert ? k + 1 : k - 1;
+        const previousX = previous[(previousK + depth - 1) / 2];
+        const previousY = previousX - previousK;
+        while (x > previousX && y > previousY) {
+          reversed.push({
+            tag: "eq",
+            beforeIdx: baseIndex + x - 1,
+            afterIdx: baseIndex + y - 1,
+            line: a[x - 1]
+          });
+          x--;
+          y--;
+        }
+        if (x === previousX) {
+          reversed.push({ tag: "ins", afterIdx: baseIndex + y - 1, line: b[y - 1] });
+          y--;
+        } else {
+          reversed.push({ tag: "del", beforeIdx: baseIndex + x - 1, line: a[x - 1] });
+          x--;
+        }
+      }
+      while (x > 0 && y > 0 && a[x - 1] === b[y - 1]) {
+        reversed.push({
+          tag: "eq",
+          beforeIdx: baseIndex + x - 1,
+          afterIdx: baseIndex + y - 1,
+          line: a[x - 1]
+        });
+        x--;
+        y--;
+      }
+      while (x > 0) {
+        reversed.push({ tag: "del", beforeIdx: baseIndex + x - 1, line: a[x - 1] });
+        x--;
+      }
+      while (y > 0) {
+        reversed.push({ tag: "ins", afterIdx: baseIndex + y - 1, line: b[y - 1] });
+        y--;
+      }
+      reversed.reverse();
+      return reversed;
+    }
+    const snapshotSize = d + 1;
+    if (traceCells + snapshotSize > MYERS_TRACE_CELL_BUDGET)
+      return null;
+    const snapshot = new Array(snapshotSize);
+    let index = 0;
+    for (let k = -d;k <= d; k += 2)
+      snapshot[index++] = frontier[offset + k];
+    trace.push(snapshot);
+    traceCells += snapshotSize;
+  }
+  return null;
+}
 function groupIntoHunks(ops, context, gap, beforeLen, afterLen) {
   const changeIdx = [];
   for (let k = 0;k < ops.length; k++) {
@@ -46559,6 +47027,9 @@ Examples:
   Read 30 lines from line 200: { "path": "src/app.ts", "offset": 200, "limit": 30 }
   List directory: { "path": "src/" }
 `;
+function v1FileParameterDescription(description) {
+  return description.replaceAll("`path`", "`filePath`").replaceAll('"path":', '"filePath":');
+}
 function readDescription(ghReadEnabled) {
   const githubDescription = whenGhReadEnabled(ghReadEnabled, ISSUE_AND_PR_READ_DESCRIPTION);
   if (!githubDescription)
@@ -46569,16 +47040,38 @@ ${githubDescription}
 
 Examples:`);
 }
+function withRevisionNote(description) {
+  if (description.includes(`
+Examples:`)) {
+    return description.replace(`
+Examples:`, `
+${REVISION_REF_TOOL_NOTE}
+
+Examples:`);
+  }
+  return `${description}
+
+${REVISION_REF_TOOL_NOTE}`;
+}
+var revisionRefArgSchema = {
+  ref: z7.string().optional().describe(REVISION_REF_DESCRIPTION)
+};
 function createReadTool(ctx) {
+  const baseDescription = v1FileParameterDescription(readDescription(resolveGithubConfig(ctx.config).read));
+  const baseArgs = {
+    filePath: z7.string().describe("Path to file or directory (absolute or relative to project root)"),
+    startLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line or directory entry to start reading from"),
+    endLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line or directory entry to stop reading at (inclusive)"),
+    limit: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Max lines (default: 2000) or directory entries (default and cap: 1000) to return"),
+    offset: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line or directory entry to start reading from (use with limit). Ignored if startLine is provided")
+  };
   return prepareToolMap({
     read: {
-      description: readDescription(resolveGithubConfig(ctx.config).read),
-      args: {
-        filePath: z7.string().describe("Path to file or directory (absolute or relative to project root)"),
-        startLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line or directory entry to start reading from"),
-        endLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line or directory entry to stop reading at (inclusive)"),
-        limit: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Max lines (default: 2000) or directory entries (default and cap: 1000) to return"),
-        offset: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line or directory entry to start reading from (use with limit). Ignored if startLine is provided")
+      get description() {
+        return revisionReadsOffered(ctx.config) ? withRevisionNote(baseDescription) : baseDescription;
+      },
+      get args() {
+        return revisionReadsOffered(ctx.config) ? { ...baseArgs, ...revisionRefArgSchema } : baseArgs;
       },
       execute: async (args, context) => {
         const file = args.path;
@@ -46616,6 +47109,9 @@ function createReadTool(ctx) {
           rawArgs.offset = offset;
         if (limit !== undefined)
           rawArgs.limit = limit;
+        const ref = revisionRefArg(args.ref);
+        if (ref !== undefined)
+          rawArgs.ref = ref;
         const mediaCandidate = isGithubResourcePath(file) || /\.(png|jpe?g|gif|webp|pdf)$/i.test(filePath) && await stat2(filePath).then((info) => info.isFile(), () => false);
         const visionCapability = mediaCandidate ? await measurePreStage("capability", () => currentSessionVisionCapability(ctx.client, context.sessionID)) : undefined;
         if (visionCapability !== undefined)
@@ -46664,11 +47160,11 @@ function githubWriteDisabledError(tool2, address) {
 function getWriteDescription(ctx, editToolName) {
   const backupText = ctx.config.backup?.enabled === false ? "Backup capture is disabled by user config." : "Existing files are backed up before overwriting (undo via aft_safety).";
   const githubText = resolveGithubConfig(ctx.config).write ? ' When enabled, `write("issue://N", content)` or `write("pr://N", content)` publishes a new comment.' : "";
-  return `Write content to a file, creating it and parent directories automatically. ${backupText} Auto-formats when the project has a formatter configured. Use it to create files or replace whole contents; for partial edits, use the \`${editToolName}\` tool. Write very large new files in parts: a single call can exceed the model's output limit and is then aborted with empty arguments.${githubText}`;
+  return `Write content to a file, creating it and parent directories automatically. Use \`path\` for the file location. ${backupText} Auto-formats when the project has a formatter configured. Use it to create files or replace whole contents; for partial edits, use the \`${editToolName}\` tool. Write very large new files in parts: a single call can exceed the model's output limit and is then aborted with empty arguments.${githubText}`;
 }
 function createWriteTool(ctx, editToolName = "edit") {
   return {
-    description: getWriteDescription(ctx, editToolName),
+    description: v1FileParameterDescription(getWriteDescription(ctx, editToolName)),
     args: {
       filePath: z7.string().describe("Path to the file to write (absolute or relative to project root)"),
       content: z7.string().describe("The full content to write to the file; for issue://N / pr://N, the comment body to post")
@@ -46862,7 +47358,7 @@ function createEditTool(ctx, writeToolName = "write") {
   if (ctx.hashlineEffective === true)
     return createHashlineEditTool(ctx);
   return {
-    description: getEditDescription(ctx, writeToolName),
+    description: v1FileParameterDescription(getEditDescription(ctx, writeToolName)),
     args: {
       filePath: z7.string().describe("Path to the file to edit (absolute or relative to project root)"),
       symbol: z7.string().optional().describe("Named symbol to replace; only meaningful together with `content`. A call carrying one without the other is incomplete."),
@@ -47623,28 +48119,14 @@ var MAX_OUTLINE_READ_ROUNDS = 8;
 function isGithubPathArg(value) {
   return typeof value === "string" && (value.startsWith("issue://") || value.startsWith("pr://"));
 }
+function isUrl(value) {
+  return value.startsWith("http://") || value.startsWith("https://");
+}
 function buildZoomTitle(args) {
-  const targets = args.targets;
-  if (!isEmptyParam(targets)) {
-    if (Array.isArray(targets)) {
-      if (targets.length === 1) {
-        return `${targets[0].path}#${targets[0].symbol}`;
-      }
-      return `${targets.length} targets across files`;
-    }
-    if (targets && typeof targets === "object") {
-      return `${targets.path}#${targets.symbol}`;
-    }
-  }
-  const path = args.path ?? args.url ?? "";
-  if (typeof args.symbols === "string")
-    return path ? `${path}#${args.symbols}` : args.symbols;
-  if (Array.isArray(args.symbols) && args.symbols.length > 0) {
-    if (args.symbols.length === 1)
-      return path ? `${path}#${args.symbols[0]}` : args.symbols[0];
-    return path ? `${path} (${args.symbols.length} symbols)` : `${args.symbols.length} symbols`;
-  }
-  return path || "(no target)";
+  if (args.batch.length !== 1)
+    return `${args.batch.length} locations`;
+  const entry = args.batch[0];
+  return `${entry.target}#${Array.isArray(entry.symbols) ? entry.symbols.join(", ") : entry.symbols}`;
 }
 function outlineFocusSteer(config) {
   const zoomEnabled = toolEnabled(config, "aft_zoom");
@@ -47657,31 +48139,53 @@ function readingTools(ctx) {
   const zoomEnabled = toolEnabled(ctx.config, "aft_zoom");
   const ghReadEnabled = resolveGithubConfig(ctx.config).read;
   const githubOutlineDescription = whenGhReadEnabled(ghReadEnabled, "GitHub issues and pull requests can be outlined with `issue://NUMBER` or `pr://NUMBER` (including `OWNER/REPO` forms).");
-  const githubZoomDescription = whenGhReadEnabled(ghReadEnabled, "GitHub issue and pull-request discussion ordinals can be zoomed with `path: issue://…` or `path: pr://…` and `symbols`.");
-  const tools = prepareToolMap({
-    aft_outline: {
-      description: "Structural outline of source code, documentation files, or remote URLs. For code, returns symbols (functions, classes, types) with line ranges. For Markdown and HTML, returns heading hierarchy. Use this to explore structure before reading specific sections with " + (zoomEnabled ? "aft_zoom" : "read") + ". With `files: true`, the outline is breadth-first with directory rollups; drill in by outlining a subdirectory. Rows show language, symbol count, and line count.\n\n" + outlineFocusSteer(ctx.config) + `
+  const githubZoomDescription = whenGhReadEnabled(ghReadEnabled, "Batch targets may use `issue://NUMBER` or `pr://NUMBER` (including `OWNER/REPO` forms) to inspect GitHub discussion ordinals.");
+  const outlineDescription = "Structural outline of source code, documentation files, or remote URLs. For code, returns symbols (functions, classes, types) with line ranges. For Markdown and HTML, returns heading hierarchy. Use this to explore structure before reading specific sections with " + (zoomEnabled ? "aft_zoom" : "read") + ". With `files: true`, the outline is breadth-first with directory rollups; drill in by outlining a subdirectory. Rows show language, symbol count, and line count.\n\n" + outlineFocusSteer(ctx.config) + `
 
 ` + "Pass a single `target`:\n" + `  • file path → outline that file (with signatures)
 ` + `  • directory path → outline source files under it
 ` + `  • URL (http:// or https://) → fetch and outline a remote HTML/Markdown document
 ` + "  • array of paths → outline multiple files in one call; with files:true, every path must be a directory" + (githubOutlineDescription ? `
 
-${githubOutlineDescription}` : "") + "\n\nWhen a list is cut, the reply ends with `shown N of M <unit> (<reason>) · narrow: <knobs>`; absence of that line means the list is complete.",
-      args: {
-        target: z11.union([z11.string(), z11.array(z11.string())]).describe("What to outline: a file path, directory path, URL, or array of paths. The mode is auto-detected: URLs by `http://`/`https://` prefix, directories by stat, arrays as multi-file."),
-        files: z11.boolean().optional().describe("Directory-only mode: when true, target must be a directory or array of directories and the result is a breadth-first file tree with directory rollups plus language, symbol, and line counts."),
-        includeTests: z11.boolean().optional().describe("Directory outline only: include test files. Defaults to false; tests are hidden.")
+${githubOutlineDescription}` : "") + "\n\nWhen a list is cut, the reply ends with `shown N of M <unit> (<reason>) · narrow: <knobs>`; absence of that line means the list is complete.";
+  const outlineArgs = {
+    target: z11.union([z11.string(), z11.array(z11.string())]).describe("What to outline: a file path, directory path, URL, or array of paths. The mode is auto-detected: URLs by `http://`/`https://` prefix, directories by stat, arrays as multi-file."),
+    files: z11.boolean().optional().describe("Directory-only mode: when true, target must be a directory or array of directories and the result is a breadth-first file tree with directory rollups plus language, symbol, and line counts."),
+    includeTests: z11.boolean().optional().describe("Directory outline only: include test files. Defaults to false; tests are hidden.")
+  };
+  const zoomDescription = 'Inspect code symbols or documentation sections. Pass lookups in `batch: [{ target, symbols }]`; a single lookup is a one-entry batch. Mix files and URLs in one batch, for example `batch: [{ target: "src/app.ts", symbols: "run" }, { target: "https://example.com/docs", symbols: "Overview" }]`. Each target is auto-detected as a file path or an HTTP/HTTPS URL. `symbols` is a string or string array. Markdown and HTML lookups return the section under the heading. Top-level `contextLines` and `callgraph` apply to every entry; callgraph adds calls-out and called-by annotations. Each failed lookup reports its own error line.' + (githubZoomDescription ? `
+
+${githubZoomDescription}` : "");
+  const zoomArgs = {
+    batch: z11.array(z11.object({
+      target: z11.string().describe("File path (absolute or project-relative) or HTTP/HTTPS URL, auto-detected; issue://N or pr://N when GitHub reads are enabled"),
+      symbols: z11.union([z11.string(), z11.array(z11.string())]).describe("Symbol name for code or heading text for Markdown/HTML; a string or array of strings")
+    })).min(1).describe("One or more lookups; entries may mix file paths and URLs"),
+    contextLines: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Lines of context before/after each symbol (default: 3)"),
+    callgraph: z11.boolean().optional().describe("Include call-graph annotations for every entry (default: false)")
+  };
+  const offered = () => revisionReadsOffered(ctx.config);
+  const tools = prepareToolMap({
+    aft_outline: {
+      get description() {
+        return offered() ? `${outlineDescription}
+
+${REVISION_REF_TOOL_NOTE} Only a single file can be outlined at a revision.` : outlineDescription;
+      },
+      get args() {
+        return offered() ? { ...outlineArgs, ...revisionRefArgSchema } : outlineArgs;
       },
       execute: async (args, context) => {
         const target = coerceTargetParam(args.target);
         const filesMode = coerceBoolean(args.files);
         const hasIncludeTests = !isEmptyParam(args.includeTests);
         const includeTests = coerceBoolean(args.includeTests);
+        const ref = revisionRefArg(args.ref);
         const rawArgs = {
           target,
           ...filesMode ? { files: true } : {},
-          ...hasIncludeTests ? { includeTests } : {}
+          ...hasIncludeTests ? { includeTests } : {},
+          ...ref !== undefined ? { ref } : {}
         };
         const checkedReads = new Map;
         let directoryOutline = filesMode;
@@ -47753,152 +48257,73 @@ ${excluded.size} files left out by read rules.` : "");
       }
     },
     aft_zoom: {
-      description: "Inspect code symbols or documentation sections. For code, returns the full source of a symbol. Pass `callgraph: true` to also include call-graph annotations (calls-out / called-by within the same file). For Markdown and HTML, returns the section content under the given heading.\n\nUse `{ path, symbols }` or `{ url, symbols }` for one file/URL. `symbols` can be a string or array (one or many lookups in the same file/URL). Use `targets` for cross-file batches: `{ path, symbol }` or an array of them. Sending both merges them into one batch; a lookup that fails reports its own error line." + (githubZoomDescription ? `
+      get description() {
+        return offered() ? `${zoomDescription}
 
-${githubZoomDescription}` : ""),
-      args: {
-        path: z11.string().optional().describe("Path to file (absolute or relative to project root)"),
-        url: z11.string().optional().describe("HTTP/HTTPS URL of an HTML or Markdown document to fetch and zoom into"),
-        symbols: z11.union([z11.string(), z11.array(z11.string())]).optional().describe("Symbol name for code, or heading text for Markdown/HTML. Pass a string for one lookup or an array for batched lookups in the same file/URL."),
-        targets: z11.union([
-          z11.object({
-            path: z11.string().describe("Path to file (absolute or relative to project root)"),
-            symbol: z11.string().describe("Symbol name in that file")
-          }),
-          z11.array(z11.object({
-            path: z11.string().describe("Path to file (absolute or relative to project root)"),
-            symbol: z11.string().describe("Symbol name in that file")
-          }))
-        ]).optional().describe("Cross-file batch: `{ path, symbol }` or an array of them. May be combined with path/url + symbols; all lookups are answered in one batch."),
-        contextLines: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Lines of context before/after the symbol (default: 3)"),
-        callgraph: z11.boolean().optional().describe("Include call-graph annotations (calls-out / called-by within the same file). Default false; off keeps zoom output minimal.")
+${REVISION_REF_TOOL_NOTE} Every file of the call is read at that revision; URLs do not have revisions.` : zoomDescription;
+      },
+      get args() {
+        return offered() ? { ...zoomArgs, ...revisionRefArgSchema } : zoomArgs;
       },
       execute: async (args, context) => {
-        const targetsInput = coerceJsonCollectionParam(args.targets, "targets");
-        const targetEntries = usableZoomTargets(targetsInput);
-        const hasFilePath = !isBlankParam(args.path);
-        const hasUrl = !isBlankParam(args.url);
-        const hasTargets = targetEntries.length > 0;
-        const hasSymbols = !isBlankParam(args.symbols);
-        const wantCallgraph = coerceBoolean(args.callgraph);
-        const contextLines = coerceOptionalInt(args.contextLines, "contextLines", 1, Number.MAX_SAFE_INTEGER);
-        const zoomTitle = buildZoomTitle({
-          ...args,
-          targets: hasTargets ? targetEntries : undefined
+        if (!Array.isArray(args.batch) || args.batch.length === 0)
+          throw new Error("'batch' must be a non-empty array of {target, symbols}");
+        const ref = revisionRefArg(args.ref);
+        if (ref !== undefined && args.batch.some((entry) => isUrl(entry.target)))
+          throw new Error("'ref' cannot be used with a URL target: a URL has no revision");
+        const localPaths = args.batch.map((entry) => entry.target).filter((target) => target && !isGithubPathArg(target) && !isUrl(target));
+        const resolved = await Promise.all(localPaths.map((target) => resolvePathArg(ctx, context, target)));
+        const resolvedByInput = new Map(localPaths.map((input, index) => [input, resolved[index]]));
+        const deniedPaths = new Map;
+        const distinctFiles = [...new Set(resolved)];
+        if (context.hostVersion === 2) {
+          const outcomes = await checkReadPaths(context, distinctFiles, (file, batchContext) => assertPathReadPermissions(ctx, batchContext, file));
+          for (const [file, denial] of outcomes)
+            if (denial)
+              deniedPaths.set(file, denial);
+        } else {
+          for (const file of distinctFiles) {
+            const denial = await assertPathReadPermissions(ctx, context, file);
+            if (denial)
+              return permissionDeniedResponse(denial);
+          }
+        }
+        const allowed = args.batch.filter((entry) => {
+          const file = resolvedByInput.get(entry.target);
+          return file === undefined || !deniedPaths.has(file);
         });
-        const zoomDisplay = { title: zoomTitle };
-        if (hasFilePath)
-          zoomDisplay.path = args.path;
-        if (hasUrl)
-          zoomDisplay.url = args.url;
-        if (hasSymbols) {
-          zoomDisplay.symbols = typeof args.symbols === "string" ? args.symbols : JSON.stringify(args.symbols);
-        }
-        if (hasTargets)
-          zoomDisplay.targets = JSON.stringify(targetEntries);
+        const deniedText = args.batch.flatMap((entry) => {
+          const file = resolvedByInput.get(entry.target);
+          const denial = file === undefined ? undefined : deniedPaths.get(file);
+          return denial ? [`${entry.target}: ${denial}`] : [];
+        }).join(`
+`);
+        const rawArgs = { batch: allowed };
+        if (ref !== undefined)
+          rawArgs.ref = ref;
+        const contextLines = coerceOptionalInt(args.contextLines, "contextLines", 1, Number.MAX_SAFE_INTEGER);
         if (contextLines !== undefined)
-          zoomDisplay.contextLines = contextLines;
-        if (wantCallgraph)
-          zoomDisplay.callgraph = true;
+          rawArgs.contextLines = contextLines;
+        if (coerceBoolean(args.callgraph))
+          rawArgs.callgraph = true;
+        const title = buildZoomTitle({ batch: args.batch });
         const withMeta = (output) => ({
           output,
-          title: zoomTitle,
-          metadata: zoomDisplay
+          title,
+          metadata: { title, ...rawArgs, batch: JSON.stringify(args.batch) }
         });
-        if (hasTargets) {
-          if (hasFilePath && hasUrl) {
-            throw new Error("Provide exactly ONE of 'path' or 'url' — not both");
-          }
-          const targets = targetEntries.map((entry, i) => {
-            if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-              throw new Error(`targets[${i}].path must be a non-empty string`);
-            }
-            const record = entry;
-            const targetPath = isBlankParam(record.path) ? record.filePath : record.path;
-            return {
-              path: typeof targetPath === "string" ? targetPath : "",
-              symbol: typeof record.symbol === "string" ? record.symbol : ""
-            };
-          });
-          const localPaths = targets.map((target) => target.path).filter((path) => path.trim().length > 0 && !isGithubPathArg(path));
-          if (hasFilePath && !isGithubPathArg(args.path))
-            localPaths.push(args.path);
-          const resolvedTargets = await Promise.all(localPaths.map((path) => resolvePathArg(ctx, context, path)));
-          const deniedPaths = new Map;
-          const resolvedByInput = new Map(localPaths.map((input, index) => [input, resolvedTargets[index]]));
-          const isDenied = (input) => {
-            const resolved = resolvedByInput.get(input);
-            return resolved !== undefined && deniedPaths.has(resolved);
-          };
-          const distinctFiles = [...new Set(resolvedTargets)];
-          if (context.hostVersion === 2) {
-            const outcomes = await checkReadPaths(context, distinctFiles, (file, batchContext) => assertPathReadPermissions(ctx, batchContext, file));
-            for (const [file, denial] of outcomes)
-              if (denial)
-                deniedPaths.set(file, denial);
-          } else {
-            for (const file of distinctFiles) {
-              const denial = await assertPathReadPermissions(ctx, context, file);
-              if (denial)
-                return permissionDeniedResponse(denial);
-            }
-          }
-          const rawArgs = {
-            targets: targets.filter((target) => !isDenied(target.path)).map((target) => ({
-              filePath: target.path,
-              symbol: target.symbol
-            }))
-          };
-          const deniedPrimary = hasFilePath && isDenied(args.path);
-          if (!deniedPrimary) {
-            if (hasFilePath)
-              rawArgs.filePath = args.path;
-            else if (hasUrl)
-              rawArgs.url = args.url;
-          }
-          if (hasSymbols && !deniedPrimary)
-            rawArgs.symbols = args.symbols;
-          if (contextLines !== undefined)
-            rawArgs.contextLines = contextLines;
-          if (wantCallgraph)
-            rawArgs.callgraph = true;
-          const deniedText = [...deniedPaths].map(([file, denial]) => `${file}: ${denial}`).join(`
-`);
-          if (!rawArgs.targets.length && !(hasFilePath && !deniedPrimary) && !hasUrl)
-            return withMeta(deniedText);
-          const response = await callToolCall(ctx, context, "zoom", rawArgs);
-          if (response.success === false) {
-            throw new Error(response.text || response.message || "zoom failed");
-          }
-          return withMeta([response.text, deniedText].filter(Boolean).join(`
-
-`));
-        }
-        if (!hasFilePath && !hasUrl) {
-          throw new Error("Provide exactly one of 'path', 'url', or 'targets'");
-        }
-        if (hasFilePath && hasUrl) {
-          throw new Error("Provide exactly ONE of 'path' or 'url' — not both");
-        }
-        const githubPath = hasFilePath && isGithubPathArg(args.path) || hasUrl && isGithubPathArg(args.url);
-        if (!hasUrl && !githubPath) {
-          const file = await resolvePathArg(ctx, context, args.path);
-          const permissionDenied = await assertPathReadPermissions(ctx, context, file);
-          if (permissionDenied)
-            return permissionDeniedResponse(permissionDenied);
+        if (!allowed.length) {
+          const denial = deniedPaths.values().next().value;
+          if (args.batch.length === 1 && denial)
+            return permissionDeniedResponse(denial);
+          return withMeta(deniedText);
         }
-        const rawArgs = hasUrl ? { url: args.url } : { filePath: args.path };
-        if (hasSymbols)
-          rawArgs.symbols = args.symbols;
-        if (contextLines !== undefined)
-          rawArgs.contextLines = contextLines;
-        if (wantCallgraph)
-          rawArgs.callgraph = true;
         const response = await callToolCall(ctx, context, "zoom", rawArgs);
-        if (response.success === false) {
+        if (response.success === false)
           throw new Error(response.text || response.message || "zoom failed");
-        }
-        return withMeta(response.text);
+        return withMeta([response.text, deniedText].filter(Boolean).join(`
+
+`));
       }
     }
   });
@@ -47984,6 +48409,7 @@ async function assertPathReadPermissions(ctx, context, target, kind = "file", ch
 }
 
 // src/tools/safety.ts
+import * as fs5 from "node:fs";
 import * as path5 from "node:path";
 var z12 = tool.schema;
 function responsePaths(response) {
@@ -48015,22 +48441,23 @@ function safetyTools(ctx) {
 ` + `Ops:
 ` + `- 'undo': Undo the entire last tool call when 'path' is omitted (typical), or undo the last edit to one file when 'path' is provided. Note: pops from the undo stack (irreversible, no redo). Use 'history' to inspect per-file history before undoing.
 ` + `- 'history': List all edit snapshots for a file. Requires 'path'.
-` + `- 'checkpoint': Save a named snapshot. Explicit 'files' may be untracked or gitignored; omit them to snapshot backup-tracked files. Checkpoints are session-scoped and lost on bridge or daemon restart. Requires 'name'.
+` + `- 'checkpoint': Save a named snapshot (on disk across restarts; expires in 14 days; may contain secrets). Explicit files may be untracked/gitignored; omit for backup-tracked files. Requires 'name'.
 ` + `- 'restore': Restore files to a previously saved checkpoint. Optional 'path'/'files' scopes the restore; omitted scope restores the whole checkpoint. Requires 'name'.
 ` + `- 'list': List all available named checkpoints. No extra params needed.
+` + `- 'purge': Permanently delete this session's undo backups and checkpoint copies of 'path' (a file, or everything under a directory); cannot be undone.
 
 ` + `Each op requires specific parameters — see parameter descriptions for requirements.
 
 ` + "Use checkpoint before risky multi-file changes. Use undo for quick single-file rollback.",
       args: {
-        op: z12.enum(["undo", "history", "checkpoint", "restore", "list"]).describe("Safety operation"),
-        path: z12.string().optional().describe("File path (required for history, optional for undo, optional for checkpoint — snapshots only that file when files is omitted, optional for restore — restores only that file). Absolute or relative to project root"),
+        op: z12.enum(["undo", "history", "checkpoint", "restore", "list", "purge"]).describe("Safety operation"),
+        path: z12.string().optional().describe("File path (required for history, optional for undo, optional for checkpoint — snapshots only that file when files is omitted, optional for restore — restores only that file, required for purge — a file or directory). Absolute or relative to project root"),
         name: z12.string().optional().describe("Checkpoint name (required for checkpoint, restore)"),
         files: z12.array(z12.string()).optional().describe("Specific files to include in checkpoint, or to restore from a checkpoint (optional; restore without path/files restores the whole checkpoint; explicit checkpoint files may be untracked or gitignored)")
       },
       execute: async (args, context) => {
         const op = args.op;
-        if (op === "history" && typeof args.path !== "string") {
+        if ((op === "history" || op === "purge") && typeof args.path !== "string") {
           throw new Error(`'path' is required for '${op}' op`);
         }
         if ((op === "checkpoint" || op === "restore") && typeof args.name !== "string") {
@@ -48100,6 +48527,42 @@ function safetyTools(ctx) {
           if (permissionError)
             return permissionDeniedResponse(permissionError);
         }
+        if (op === "purge") {
+          const absolutePath = resolveAbsolutePath(context, args.path);
+          let isDirectory = false;
+          try {
+            isDirectory = fs5.statSync(absolutePath).isDirectory();
+          } catch {}
+          const denial = await assertExternalDirectoryPermission(ctx, context, absolutePath, {
+            kind: isDirectory ? "directory" : "file"
+          });
+          if (denial)
+            return permissionDeniedResponse(denial);
+          const preview = await callBridge(ctx, context, "safety_purge_paths", {
+            file: expandTilde2(args.path)
+          });
+          if (preview.success === false) {
+            throw new Error(bridgeErrorMessage(preview, "purge path preview failed"));
+          }
+          const previewPaths = Array.from(new Set(responsePaths(preview)));
+          for (const savedPath of previewPaths) {
+            const previewDenial = await assertExternalDirectoryPermission(ctx, context, savedPath);
+            if (previewDenial)
+              return permissionDeniedResponse(previewDenial);
+          }
+          const pattern = resolveRelativePatternFromAbsolute(context, absolutePath);
+          const patterns = isDirectory ? [pattern, path5.join(pattern, "*")] : [pattern];
+          for (const previewPattern of relativePatternsFromPaths(context, previewPaths)) {
+            if (!patterns.includes(previewPattern))
+              patterns.push(previewPattern);
+          }
+          const permissionError = await askEditPermission(context, patterns, {
+            filepath: absolutePath,
+            operation: "purge"
+          });
+          if (permissionError)
+            return permissionDeniedResponse(permissionError);
+        }
         const rawArgs = { op };
         if (args.name !== undefined)
           rawArgs.name = args.name;
@@ -48120,7 +48583,7 @@ function safetyTools(ctx) {
 }
 
 // src/tools/search.ts
-import * as fs5 from "node:fs";
+import * as fs6 from "node:fs";
 import * as path6 from "node:path";
 function arg2(schema) {
   return schema;
@@ -48129,7 +48592,7 @@ function absoluteSearchPath(projectRoot, target) {
   return resolvePathFromProjectRoot(projectRoot, expandTilde2(target));
 }
 function searchPathExists(projectRoot, target) {
-  return fs5.existsSync(absoluteSearchPath(projectRoot, target));
+  return fs6.existsSync(absoluteSearchPath(projectRoot, target));
 }
 function splitSearchPathArg(projectRoot, raw) {
   if (searchPathExists(projectRoot, raw) || !/\s/.test(raw)) {
@@ -48172,7 +48635,7 @@ ${note}` : note;
 }
 function searchPathKind(projectRoot, target, defaultKind) {
   try {
-    const stat = fs5.lstatSync(absoluteSearchPath(projectRoot, target));
+    const stat = fs6.lstatSync(absoluteSearchPath(projectRoot, target));
     if (defaultKind === "file") {
       return stat.isDirectory() ? "directory" : "file";
     }
@@ -48379,7 +48842,7 @@ function semanticTools(ctx) {
       topK: arg3(optionalInt(1, 50).describe("Number of results (default: 10, max: 50)")),
       offset: arg3(optionalInt(0, 1e5).describe("Zero-based result offset (default: 0, max: 100000).")),
       includeTests: arg3(z13.boolean().optional().describe("Include test files (*.test.*, *_test.rs, __tests__/, …) plus test-support, fixture, mock, snapshot, and corpus files. Defaults to false.")),
-      path: arg3(z13.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."))
+      path: arg3(z13.string().optional().describe("Only set this to search a different project or plain folder (absolute or ~ path). Omit it for the current configured workspace, including non-Git workspace roots; this is not a subdirectory filter. Unindexed external folders use a bounded lexical fallback; filesystem roots, home and its ancestors are refused."))
     },
     execute: async (args, context) => {
       const hasQuery = typeof args.query === "string" && args.query.trim().length > 0;
@@ -48974,7 +49437,7 @@ function startOpenCodeLiveConfigReload(options) {
 // src/notifications.ts
 import { existsSync as existsSync17, readFileSync as readFileSync14 } from "node:fs";
 import { homedir as homedir14, platform } from "node:os";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 function isTuiMode() {
   return process.env.OPENCODE_CLIENT === "cli";
 }
@@ -48996,15 +49459,15 @@ function getDesktopStatePath() {
   const os = platform();
   const home = homedir14();
   if (os === "darwin") {
-    return join22(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
+    return join23(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os === "linux") {
-    const xdgConfig = process.env.XDG_CONFIG_HOME || join22(home, ".config");
-    return join22(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join23(home, ".config");
+    return join23(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os === "win32") {
-    const appData = process.env.APPDATA || join22(home, "AppData", "Roaming");
-    return join22(appData, "ai.opencode.desktop", "opencode.global.dat");
+    const appData = process.env.APPDATA || join23(home, "AppData", "Roaming");
+    return join23(appData, "ai.opencode.desktop", "opencode.global.dat");
   }
   return null;
 }
@@ -49522,7 +49985,7 @@ import {
   readFileSync as readFileSync17,
   renameSync as renameSync10,
   rmSync as rmSync8,
-  statSync as statSync16,
+  statSync as statSync17,
   writeFileSync as writeFileSync11
 } from "node:fs";
 import { dirname as dirname16 } from "node:path";
@@ -49530,30 +49993,30 @@ import { dirname as dirname16 } from "node:path";
 // src/hooks/auto-update-checker/cache.ts
 import { cpSync, existsSync as existsSync19, mkdtempSync, readFileSync as readFileSync16, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename6, dirname as dirname15, join as join25 } from "node:path";
+import { basename as basename6, dirname as dirname15, join as join26 } from "node:path";
 var import_comment_json3 = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/checker.ts
-import { existsSync as existsSync18, readFileSync as readFileSync15, statSync as statSync15, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync15, statSync as statSync16, writeFileSync as writeFileSync9 } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { homedir as homedir15 } from "node:os";
-import { dirname as dirname14, isAbsolute as isAbsolute13, join as join24, resolve as resolve15 } from "node:path";
+import { dirname as dirname14, isAbsolute as isAbsolute13, join as join25, resolve as resolve15 } from "node:path";
 import { fileURLToPath } from "node:url";
 var import_comment_json2 = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/constants.ts
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 var PACKAGE_NAME = "@cortexkit/aft-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var NPM_FETCH_TIMEOUT = 1e4;
 function cacheDir() {
-  return join23(getOpenCodeCacheRoot(), "packages");
+  return join24(getOpenCodeCacheRoot(), "packages");
 }
 function userOpenCodeConfig() {
-  return join23(getOpenCodeConfigRoot(), "opencode.json");
+  return join24(getOpenCodeConfigRoot(), "opencode.json");
 }
 function userOpenCodeConfigJsonc() {
-  return join23(getOpenCodeConfigRoot(), "opencode.jsonc");
+  return join24(getOpenCodeConfigRoot(), "opencode.jsonc");
 }
 
 // src/hooks/auto-update-checker/types.ts
@@ -49612,8 +50075,8 @@ function extractChannel(version) {
 }
 function getConfigPaths(directory) {
   return [
-    join24(directory, ".opencode", "opencode.json"),
-    join24(directory, ".opencode", "opencode.jsonc"),
+    join25(directory, ".opencode", "opencode.json"),
+    join25(directory, ".opencode", "opencode.jsonc"),
     userOpenCodeConfig(),
     userOpenCodeConfigJsonc()
   ];
@@ -49656,10 +50119,10 @@ function getLocalDevPath(directory) {
 }
 function findPackageJsonUp(startPath) {
   try {
-    const stat = statSync15(startPath);
+    const stat = statSync16(startPath);
     let dir = stat.isDirectory() ? startPath : dirname14(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = join24(dir, "package.json");
+      const pkgPath = join25(dir, "package.json");
       if (existsSync18(pkgPath)) {
         try {
           const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync15(pkgPath, "utf-8")));
@@ -49725,7 +50188,7 @@ function findPluginEntry(directory) {
 }
 var cachedPackageVersion = null;
 function getSpecCachePackageJsonPath(spec) {
-  return join24(cacheDir(), spec, "node_modules", PACKAGE_NAME, "package.json");
+  return join25(cacheDir(), spec, "node_modules", PACKAGE_NAME, "package.json");
 }
 function getCachedVersion(spec) {
   if (!spec && cachedPackageVersion)
@@ -49734,7 +50197,7 @@ function getCachedVersion(spec) {
     getCurrentRuntimePackageJsonPath(),
     spec ? getSpecCachePackageJsonPath(spec) : null,
     getSpecCachePackageJsonPath(`${PACKAGE_NAME}@latest`),
-    join24(getOpenCodeCacheRoot(), "node_modules", PACKAGE_NAME, "package.json")
+    join25(getOpenCodeCacheRoot(), "node_modules", PACKAGE_NAME, "package.json")
   ].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
@@ -49805,7 +50268,7 @@ async function registryWithoutNpm(directory) {
   for (let current = directory;; current = dirname14(current)) {
     if (scoped)
       break;
-    const path = join24(current, ".npmrc");
+    const path = join25(current, ".npmrc");
     visited.add(path);
     const settings = await readRegistrySettings(path);
     scoped ??= settings["@cortexkit:registry"];
@@ -49815,7 +50278,7 @@ async function registryWithoutNpm(directory) {
   }
   const explicitUserConfig = process.env.npm_config_userconfig ?? process.env.NPM_CONFIG_USERCONFIG;
   const home = (process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME) ?? homedir15();
-  const userConfig = explicitUserConfig ?? join24(home, ".npmrc");
+  const userConfig = explicitUserConfig ?? join25(home, ".npmrc");
   if (!scoped && !visited.has(userConfig)) {
     const settings = await readRegistrySettings(userConfig, explicitUserConfig !== undefined);
     scoped = settings["@cortexkit:registry"];
@@ -49901,10 +50364,10 @@ async function getLatestVersion(channel = "latest", options = {}) {
 var pendingSnapshots = new Map;
 var quarantinedInstallDirs = new Set;
 function createAutoUpdateSnapshot(installDir, packageJsonPath, packageName) {
-  const packageDir = join25(installDir, "node_modules", packageName);
-  const lockfilePath = join25(installDir, "package-lock.json");
-  const tempDir = mkdtempSync(join25(tmpdir5(), "aft-auto-update-"));
-  const stagedPackageDir = existsSync19(packageDir) ? join25(tempDir, "package") : null;
+  const packageDir = join26(installDir, "node_modules", packageName);
+  const lockfilePath = join26(installDir, "package-lock.json");
+  const tempDir = mkdtempSync(join26(tmpdir5(), "aft-auto-update-"));
+  const stagedPackageDir = existsSync19(packageDir) ? join26(tempDir, "package") : null;
   if (stagedPackageDir)
     cpSync(packageDir, stagedPackageDir, { recursive: true });
   return {
@@ -49945,7 +50408,7 @@ function stripPackageNameFromPath(pathValue, packageName) {
   return current;
 }
 function removeFromPackageLock(installDir, packageName) {
-  const lockPath = join25(installDir, "package-lock.json");
+  const lockPath = join26(installDir, "package-lock.json");
   if (!existsSync19(lockPath))
     return false;
   try {
@@ -50001,7 +50464,7 @@ function restorePendingSnapshot(installDir) {
   restoreAutoUpdateSnapshot(snapshot);
 }
 function removeInstalledPackage(installDir, packageName) {
-  const packageDir = join25(installDir, "node_modules", packageName);
+  const packageDir = join26(installDir, "node_modules", packageName);
   if (!existsSync19(packageDir))
     return false;
   rmSync7(packageDir, { recursive: true, force: true });
@@ -50014,14 +50477,14 @@ function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackage
     const nodeModulesDir = stripPackageNameFromPath(packageDir, PACKAGE_NAME);
     if (nodeModulesDir && basename6(nodeModulesDir) === "node_modules") {
       const installDir = dirname15(nodeModulesDir);
-      const packageJsonPath = join25(installDir, "package.json");
+      const packageJsonPath = join26(installDir, "package.json");
       if (existsSync19(packageJsonPath))
         return { installDir, packageJsonPath };
     }
     return null;
   }
   const cacheRoot = dirname15(cacheDir());
-  const legacyPackageJsonPath = join25(cacheRoot, "package.json");
+  const legacyPackageJsonPath = join26(cacheRoot, "package.json");
   if (existsSync19(legacyPackageJsonPath)) {
     return { installDir: cacheRoot, packageJsonPath: legacyPackageJsonPath };
   }
@@ -50294,7 +50757,7 @@ function isOrphanedCheckLock(lockPath) {
   }
 }
 function readCheckLockState(lockPath) {
-  const fallbackStartedMs = statSync16(lockPath).mtimeMs;
+  const fallbackStartedMs = statSync17(lockPath).mtimeMs;
   try {
     const parsed = JSON.parse(readFileSync17(lockPath, "utf-8"));
     const pid = Number.isSafeInteger(parsed.pid) && (parsed.pid ?? 0) > 0 ? parsed.pid ?? null : null;
@@ -50535,16 +50998,16 @@ import {
   writeFileSync as writeFileSync12
 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname17, join as join27 } from "node:path";
+import { dirname as dirname17, join as join28 } from "node:path";
 
 // src/shared/rpc-utils.ts
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 function projectHash(directory) {
   return projectRootKeyHash(directory);
 }
 function rpcPortFileDir(storageDir, directory) {
   const hash = projectHash(directory);
-  return join26(storageDir, "rpc", hash, "ports");
+  return join27(storageDir, "rpc", hash, "ports");
 }
 function isPidAlive(pid) {
   if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
@@ -50618,7 +51081,7 @@ class AftRpcServer {
   constructor(storageDir, directory) {
     this.portsDir = rpcPortFileDir(storageDir, directory);
     this.instanceId = randomBytes5(8).toString("hex");
-    this.portFilePath = join27(this.portsDir, `${this.instanceId}.json`);
+    this.portFilePath = join28(this.portsDir, `${this.instanceId}.json`);
   }
   handle(method, handler) {
     this.handlers.set(method, handler);
@@ -50706,7 +51169,7 @@ class AftRpcServer {
     for (const entry of entries) {
       if (!entry.endsWith(".json"))
         continue;
-      const filePath = join27(this.portsDir, entry);
+      const filePath = join28(this.portsDir, entry);
       if (filePath === this.portFilePath)
         continue;
       try {
@@ -51335,7 +51798,7 @@ function buildWorkflowHints(opts) {
 `));
   }
   if (hasOutline && hasZoom) {
-    sections.push(`**Web/URL access**: \`aft_outline({ target: url })\` first for structure, then \`aft_zoom({ url, symbols: "<heading>" })\` for the specific section.`);
+    sections.push(`**Web/URL access**: \`aft_outline({ target: url })\` first for structure, then \`aft_zoom({ batch: [{ target: url, symbols: "<heading>" }] })\` for the specific section.`);
   }
   if (hasOutline && (hasGrep || hasSearch) && (hasZoom || hasRead)) {
     const searchName = hasSearch ? "aft_search" : grepName;
@@ -51452,13 +51915,13 @@ function throwSentinel(command) {
   throw sentinel;
 }
 var PLUGIN_VERSION = resolvePluginVersion(import.meta.url);
-var ANNOUNCEMENT_VERSION = "0.61.0";
+var ANNOUNCEMENT_VERSION = "0.62.0";
 var ANNOUNCEMENT_FEATURES = [
-  "OpenCode 2 now hands every AFT permission decision to OpenCode, so your permission rules and plugins apply to AFT tools too.",
-  "Shell sandboxing has per-role profiles: `sandbox.profile` (`off`, `relaxed`, `strict`) replaces `sandbox.enabled`, and `npx @cortexkit/aft doctor --fix` migrates your config.",
-  "Edits keep files' permissions and ownership, replacing them atomically when that is safe, and `apply_patch` rejects malformed or ambiguous patches before writing anything.",
-  "Much lighter background work: less CPU, disk and memory use, and no indexing of your home folder or drive roots.",
-  "Long shell waits keep their replies, remote `runon` jobs survive build-server restarts, and many reported issues are fixed."
+  "Linux dev containers work again: a project at a bind-mount target such as `/workspace` is no longer refused as too broad.",
+  "Read a file as it is at any git revision with the opt-in `ref` argument on `read`, `aft_outline` and `aft_zoom` (set `revision_reads: true`).",
+  "`aft_safety` has a `purge` op that permanently removes a file from this session's undo backups and checkpoints, such as a secret written by mistake.",
+  "`aft_zoom` takes one `batch` of lookups mixing files and URLs, and OpenCode shows diffs for edits to files over 5,000 lines.",
+  "Idle OpenCode 2 sessions wake again when a background command finishes, and many reported issues are fixed."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/DSa65w8wuf";
 var plugin = async (input) => initializePluginForDirectory(input);
@@ -51951,7 +52414,7 @@ Install: ${getManualInstallHint()}`);
 var src_default = plugin;
 
 // src/entry/server-runtime.mjs
-import { Effect as Effect14 } from "effect";
+import { Effect as Effect15 } from "effect";
 
 // src/rpc/register.ts
 import { Effect as Effect8 } from "effect";
@@ -52220,7 +52683,7 @@ class V2SessionDelivery {
     return Effect9.suspend(() => {
       if (this.disposed)
         return Effect9.succeed(false);
-      const keys = [...new Set(input.taskIDs)].map((taskID) => `${input.sessionID}\x00${taskID}`);
+      const keys = [...new Set(input.taskIDs)].map((taskID) => `${input.sessionID}\x00${taskID}\x00${input.notificationID ?? "completion"}`);
       if (keys.length === 0 || keys.every((key) => this.admittedCompletions.has(key))) {
         return Effect9.succeed(false);
       }
@@ -52379,6 +52842,11 @@ function registerV2ToolHooks(context, runtime, registeredTools, bashDescription)
   return Effect11.gen(function* () {
     if (typeof host.tool?.hook === "function") {
       yield* host.tool.hook("execute.after", (event) => Effect11.promise(async () => {
+        if (runtime.drainBgNotifications && event.status === "completed" && !hasHeldBgCompletions(event.sessionID)) {
+          await runtime.drainBgNotifications(event.sessionID);
+          if (!hasHeldBgCompletions(event.sessionID))
+            return;
+        }
         if (!runtime.pool || event.status !== "completed" || !hasHeldBgCompletions(event.sessionID))
           return;
         const content = event.result.content;
@@ -52527,6 +52995,17 @@ function holdUnrouted(completion, bridge) {
   tasks.set(completion.task_id, { completion, bridge });
   unrouted.set(completion.session_id, tasks);
 }
+function forgetUnroutedCompletion(sessionID, taskID) {
+  const state = wakeRouteState();
+  const held = state.unrouted.get(sessionID);
+  if (!held)
+    return;
+  held.delete(taskID);
+  if (held.size === 0) {
+    state.unrouted.delete(sessionID);
+    state.warnedUnrouted.delete(sessionID);
+  }
+}
 function warnUnroutedOnce(sessionID, message) {
   const { warnedUnrouted } = wakeRouteState();
   if (warnedUnrouted.has(sessionID))
@@ -52534,20 +53013,25 @@ function warnUnroutedOnce(sessionID, message) {
   warnedUnrouted.add(sessionID);
   warn2(message);
 }
-async function routeCompletion(completion, bridge) {
+async function routeCompletion(completion, bridge, acknowledge = true) {
   const route = wakeRouteState().routes.get(completion.session_id);
   if (route) {
     try {
-      await route.completion(completion, bridge);
-      return;
+      const admitted = await route.completion(completion, bridge, acknowledge) === true;
+      if (admitted)
+        forgetUnroutedCompletion(completion.session_id, completion.task_id);
+      return admitted;
     } catch (error) {
-      holdUnrouted(completion, bridge);
+      if (acknowledge)
+        holdUnrouted(completion, bridge);
       warn2(`[bash_completion] delivery of task ${completion.task_id} to session ${completion.session_id} failed: ${error instanceof Error ? error.message : String(error)}`);
-      return;
+      return false;
     }
   }
-  holdUnrouted(completion, bridge);
+  if (acknowledge)
+    holdUnrouted(completion, bridge);
   warnUnroutedOnce(completion.session_id, `[bash_completion] no OpenCode Location has session ${completion.session_id} registered; completion of task ${completion.task_id} is held unacknowledged until the session registers`);
+  return false;
 }
 async function routeLongRunning(reminder, _bridge) {
   const route = wakeRouteState().routes.get(reminder.session_id);
@@ -52555,7 +53039,7 @@ async function routeLongRunning(reminder, _bridge) {
     return route.longRunning(reminder);
   warnUnroutedOnce(reminder.session_id, `[bash_long_running] no OpenCode Location has session ${reminder.session_id} registered; long-running reminder for task ${reminder.task_id} was not delivered`);
 }
-function deliverUnrouted(sessionID) {
+function deliverUnrouted(sessionID, replacementBridge) {
   const state = wakeRouteState();
   state.warnedUnrouted.delete(sessionID);
   const held = state.unrouted.get(sessionID);
@@ -52563,11 +53047,15 @@ function deliverUnrouted(sessionID) {
     return;
   state.unrouted.delete(sessionID);
   for (const { completion, bridge } of held.values()) {
-    routeCompletion(completion, bridge);
+    if (replacementBridge && bridge.getCwd() !== replacementBridge.getCwd())
+      continue;
+    routeCompletion(completion, replacementBridge ?? bridge);
   }
 }
 var sharedBridgeOptions = {
-  onBashCompletion: routeCompletion,
+  onBashCompletion: async (completion, bridge) => {
+    await routeCompletion(completion, bridge);
+  },
   onBashLongRunning: routeLongRunning
 };
 function detachWaitsForCompletion(sessionID, text, bridge, config) {
@@ -52582,15 +53070,17 @@ function detachWaitsForCompletion(sessionID, text, bridge, config) {
 function createV2RuntimeConsumer(context, getConfig = () => ({})) {
   const delivery = new V2SessionDelivery(context.session);
   const sessions = new Set;
+  let disposed = false;
+  let subcPool;
   const route = {
-    completion: async (completion, bridge) => {
+    completion: async (completion, bridge, acknowledge = true) => {
       if (await resolveIsSubagent(context, completion.session_id)) {
         await awaitV2ExecutionSettlement(context, completion.session_id);
       }
       if (await resolveIsSubagent(context, completion.session_id) && !v2WatchWakeAllowed(context, completion.session_id, completion.task_id)) {
         holdBgCompletion(completion.session_id, completion, v2SubagentStopped(context, completion.session_id));
         forgetV2Watch(context, completion.session_id, completion.task_id);
-        return;
+        return false;
       }
       const text = formatSystemReminder([completion]);
       const admitted = await Effect13.runPromise(delivery.completion({
@@ -52605,13 +53095,52 @@ function createV2RuntimeConsumer(context, getConfig = () => ({})) {
         }
       }));
       if (!admitted)
-        return;
+        return false;
       detachWaitsForCompletion(completion.session_id, text, bridge, getConfig());
-      await bridge.send("bash_ack_completions", {
-        session_id: completion.session_id,
-        task_ids: [completion.task_id]
-      });
+      if (acknowledge) {
+        if (subcPool) {
+          consumeBgCompletion(completion.session_id, completion.task_id);
+          await markBgCompletionDelivered({
+            ctx: { pool: subcPool() },
+            directory: bridge.getCwd(),
+            sessionID: completion.session_id,
+            resolvedBridge: bridge
+          }, completion.task_id);
+        } else {
+          await bridge.send("bash_ack_completions", {
+            session_id: completion.session_id,
+            task_ids: [completion.task_id]
+          });
+        }
+      }
       forgetV2Watch(context, completion.session_id, completion.task_id);
+      return true;
+    },
+    patternMatch: async (match, bridge) => {
+      if (await resolveIsSubagent(context, match.session_id)) {
+        await awaitV2ExecutionSettlement(context, match.session_id);
+        if (!v2WatchWakeAllowed(context, match.session_id, match.task_id))
+          return false;
+      }
+      const text = formatPatternMatchReminder([match]);
+      const admitted = await Effect13.runPromise(delivery.completion({
+        sessionID: match.session_id,
+        taskIDs: [match.task_id],
+        notificationID: `match\x00${match.watch_id}\x00${match.match_offset}`,
+        text,
+        metadata: {
+          source: "aft",
+          kind: "bash_pattern_match",
+          task_ids: [match.task_id],
+          watch_id: match.watch_id
+        }
+      }));
+      if (admitted) {
+        detachWaitsForCompletion(match.session_id, text, bridge, getConfig());
+        if (match.reason === "task_exit")
+          forgetUnroutedCompletion(match.session_id, match.task_id);
+      }
+      return admitted;
     },
     longRunning: (reminder) => Effect13.runPromise(delivery.status({
       sessionID: reminder.session_id,
@@ -52624,23 +53153,74 @@ function createV2RuntimeConsumer(context, getConfig = () => ({})) {
       }
     }))
   };
-  const registerSession = (sessionID) => {
-    if (!sessionID)
+  const registerSession = (sessionID, bridge) => {
+    if (!sessionID || disposed)
       return;
     sessions.add(sessionID);
     const { routes } = wakeRouteState();
     routes.set(sessionID, route);
-    deliverUnrouted(sessionID);
+    deliverUnrouted(sessionID, bridge);
   };
   return {
     bridgeOptions: sharedBridgeOptions,
     registerSession,
+    subcWakes: (getPool, directory) => {
+      subcPool = getPool;
+      const root = canonicalizeProjectRoot(directory);
+      const drain = (sessionID, nudgeRef, resolvedBridge) => {
+        if (disposed)
+          return Promise.resolve();
+        return handleSubcBgEventsNudge({
+          ctx: { pool: getPool() },
+          directory: root,
+          sessionID,
+          client: context,
+          nudgeRef,
+          resolvedBridge,
+          delivery: {
+            completion: (completion, bridge) => routeCompletion({ ...completion, type: "bash_completed", session_id: sessionID }, bridge, false),
+            patternMatch: async (match, bridge) => {
+              if (match.session_id !== sessionID)
+                return false;
+              return await wakeRouteState().routes.get(sessionID)?.patternMatch?.(match, bridge) ?? false;
+            }
+          }
+        });
+      };
+      return {
+        handlers: {
+          onBgEventsNudge: (projectRoot, sessionID) => {
+            if (canonicalizeProjectRoot(projectRoot) === root)
+              return drain(sessionID);
+          },
+          onBgEventsNudgeRef: (ref) => {
+            if (ref.canonicalRoot === root)
+              return drain(ref.session, ref);
+          }
+        },
+        drainSession: (sessionID) => {
+          if (disposed)
+            return Promise.resolve();
+          const bridge = getPool().getBridge(root);
+          registerSession(sessionID, bridge);
+          return drain(sessionID, undefined, bridge);
+        },
+        restoreSession: async (sessionID) => {
+          if (disposed)
+            return;
+          const bridge = getPool().getBridge(root);
+          registerSession(sessionID, bridge);
+          await drain(sessionID, undefined, bridge);
+        }
+      };
+    },
     onToolAbort: (sessionID) => noteV2ToolAbort(context, sessionID),
     executeBash: (execution) => {
       registerSession(execution.context.sessionID);
       return executeV2Bash(execution);
     },
     dispose: () => {
+      disposed = true;
       delivery.dispose();
       const { routes } = wakeRouteState();
       for (const sessionID of sessions) {
@@ -52652,6 +53232,34 @@ function createV2RuntimeConsumer(context, getConfig = () => ({})) {
   };
 }
 
+// src/wakes/subc-recovery.ts
+import { DateTime, Effect as Effect14 } from "effect";
+var RECENT_SESSION_LIMIT = 20;
+var RECENT_SESSION_WINDOW_MS = 24 * 60 * 60 * 1000;
+function recoverV2SubcSessions(context, directory, restoreSession) {
+  const host = context;
+  return Effect14.gen(function* () {
+    if (typeof host.session?.list !== "function")
+      return;
+    yield* Effect14.sleep("10 millis");
+    const sessions = yield* host.session.list({
+      directory,
+      order: "desc",
+      limit: RECENT_SESSION_LIMIT
+    });
+    const cutoff = Date.now() - RECENT_SESSION_WINDOW_MS;
+    for (const session of sessions.data.slice(0, RECENT_SESSION_LIMIT)) {
+      if (session.location.directory !== directory || DateTime.toEpochMillis(session.time.updated) < cutoff)
+        continue;
+      yield* Effect14.tryPromise({
+        try: () => restoreSession(session.id),
+        catch: (error) => error
+      }).pipe(Effect14.catch((error) => Effect14.sync(() => warn2(`[bash_completion] session recovery failed: ${String(error)}`))));
+      yield* Effect14.sleep("10 millis");
+    }
+  }).pipe(Effect14.timeout("30 seconds"), Effect14.catch((error) => Effect14.sync(() => warn2(`[bash_completion] recent session discovery failed: ${String(error)}`))));
+}
+
 // src/entry/server-runtime.mjs
 var defaults = {
   ...defaultBridgeBootstrapDependencies,
@@ -52692,6 +53300,7 @@ async function bootLocation(context, location, dependencies) {
   let liveConfig = config;
   const consumers = dependencies.toolConsumers(context, config, () => liveConfig);
   const isProjectEnabled = createProjectAcceptance(directory, dependencies);
+  const subcWakes = config.subc?.connection_file?.trim() ? consumers.subcWakes?.(() => pool, directory) : undefined;
   const pool = await dependencies.acquireBridge(canonicalDirectory, {
     harness: "opencode",
     binaryPath: environment.binaryPath,
@@ -52707,7 +53316,8 @@ async function bootLocation(context, location, dependencies) {
       ...consumers.bridgeOptions
     },
     configOverrides: environment.configOverrides,
-    subcConnectionFile: config.subc?.connection_file
+    subcConnectionFile: config.subc?.connection_file,
+    ...subcWakes?.handlers
   });
   environment.attach(pool);
   const toolContext = {
@@ -52717,7 +53327,8 @@ async function bootLocation(context, location, dependencies) {
     hashlineEffective: openCodeHashlineEffective(config),
     hostToolNames: V2_HOST_TOOL_NAMES,
     storageDir: environment.storageDir,
-    isProjectEnabled
+    isProjectEnabled,
+    drainBgNotifications: subcWakes?.drainSession
   };
   const tools = dependencies.buildToolMap(toolContext, config, unknownDisabledToolsReporter(notify));
   const registeredTools = new Set(Object.keys(tools));
@@ -52737,7 +53348,7 @@ async function bootLocation(context, location, dependencies) {
     },
     notify
   });
-  return { consumers, pool, tools, liveConfigReload, toolContext, directory, hintsBlock };
+  return { consumers, pool, tools, liveConfigReload, toolContext, directory, hintsBlock, subcWakes };
 }
 var runningByDirectory = new Map;
 var startsInProcess = 0;
@@ -52764,30 +53375,30 @@ function makeServerEffect(overrides = {}) {
     const location = context.location;
     if (typeof location?.directory !== "string") {
       debug2("V2 effect skipped: host context has no location");
-      return Effect14.void;
+      return Effect15.void;
     }
     if (typeof context.permission?.assert !== "function") {
       throw new Error("AFT requires OpenCode 2.0.29 or newer: this V2 host has no permission.assert. Upgrade OpenCode before loading AFT.");
     }
-    return Effect14.gen(function* () {
+    return Effect15.gen(function* () {
       const logRuntimeStop = logRuntimeStart(location);
-      yield* Effect14.addFinalizer(() => Effect14.sync(logRuntimeStop));
-      const runtime = yield* Effect14.promise(() => bootLocation(context, location, dependencies));
+      yield* Effect15.addFinalizer(() => Effect15.sync(logRuntimeStop));
+      const runtime = yield* Effect15.promise(() => bootLocation(context, location, dependencies));
       if (!runtime)
         return;
       if (runtime.configError !== undefined) {
         const rpc = yield* dependencies.registerConfigErrorRpc(context, runtime.configError);
-        yield* Effect14.addFinalizer(() => Effect14.promise(() => rpc.dispose()));
+        yield* Effect15.addFinalizer(() => Effect15.promise(() => rpc.dispose()));
         yield* dependencies.registerTools(context, location, runtime.tools, runtime.consumers);
         return;
       }
-      yield* Effect14.addFinalizer(() => Effect14.promise(async () => {
+      yield* Effect15.addFinalizer(() => Effect15.promise(async () => {
         runtime.liveConfigReload?.stop();
         runtime.consumers.dispose?.();
         await dependencies.releaseBridge(runtime.pool);
       }));
       const rpc = yield* dependencies.registerRpc(context, location, runtime.pool);
-      yield* Effect14.addFinalizer(() => Effect14.promise(() => rpc.dispose()));
+      yield* Effect15.addFinalizer(() => Effect15.promise(() => rpc.dispose()));
       yield* registerV2SessionLifecycle(context, runtime.toolContext);
       yield* dependencies.registerPromptHook(context, {
         pool: runtime.pool,
@@ -52798,6 +53409,9 @@ function makeServerEffect(overrides = {}) {
       yield* dependencies.registerTools(context, location, runtime.tools, runtime.consumers);
       yield* dependencies.registerToolHooks(context, runtime.toolContext, new Set(Object.keys(runtime.tools)), runtime.tools.bash?.description);
       yield* dependencies.registerWorkflowHints(context, runtime.hintsBlock);
+      if (runtime.subcWakes) {
+        yield* Effect15.forkScoped(recoverV2SubcSessions(context, runtime.directory, runtime.subcWakes.restoreSession));
+      }
     });
   };
 }