@cortexkit/aft-opencode 0.58.1 → 0.58.2

package/dist/entry/server.js

@@ -9574,29 +9574,84 @@ function isTerminalStatus(status) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function monotonicNowMs() {
-  return performance.now();
-}
 // ../aft-bridge/dist/bash-hints.js
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 var DEFAULT_PRIMARY_WATCH_TIMEOUT_MS = 30000;
-var WATCH_TIMEOUT_PARAM_DESCRIPTION = "Sync-only timeout in milliseconds. Default 30000 (the configured maximum for delegated sessions); max `bash.watch_sync_max_ms` (120000 by default).";
+var MAX_WATCH_TIMEOUT_MS = 1800000;
+var LONGEST_TIMER_DELAY_MS = 2147483647;
+var WATCH_SYNC_DEFAULTS_DESCRIPTION = "Sync waits default to 30s in a main session (max `bash.watch_sync_max_ms`, 120s by default); in a delegated session a sync wait without a timeout waits until the command finishes";
+var WATCH_TIMEOUT_PARAM_DESCRIPTION = "Sync-only timeout in milliseconds. In a main session: default 30000, max `bash.watch_sync_max_ms` (120000 by default). In a delegated session: omit it to wait until the command finishes; a value you pass is used as given.";
 function resolveWatchTimeoutMs(requestedMs, role, capMs) {
-  const fallback = role === "worker" ? capMs : DEFAULT_PRIMARY_WATCH_TIMEOUT_MS;
-  return Math.min(requestedMs ?? fallback, capMs);
+  if (role === "worker")
+    return requestedMs;
+  return Math.min(requestedMs ?? DEFAULT_PRIMARY_WATCH_TIMEOUT_MS, capMs);
+}
+function maxWatchTimeoutMs(role, capMs) {
+  return role === "worker" ? MAX_WATCH_TIMEOUT_MS : capMs;
+}
+function watchPollDelayMs(elapsedMs) {
+  if (elapsedMs < 5000)
+    return 100;
+  if (elapsedMs < 30000)
+    return 250;
+  if (elapsedMs < 120000)
+    return 500;
+  return 1000;
+}
+var watchClock = {
+  now: () => performance.now(),
+  sleep: abortableSleep
+};
+function abortableSleep(ms, signal) {
+  if (signal?.aborted)
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    signal?.addEventListener("abort", done, { once: true });
+  });
 }
 function formatWatchWaited(elapsedMs, limitMs, capMs) {
-  const limit = limitMs >= capMs ? `limit ${limitMs}ms, the bash.watch_sync_max_ms cap` : `limit ${limitMs}ms`;
+  let limit;
+  if (limitMs === undefined)
+    limit = "no limit: waits until the command finishes";
+  else if (capMs !== undefined && limitMs >= capMs)
+    limit = `limit ${limitMs}ms, the bash.watch_sync_max_ms cap`;
+  else
+    limit = `limit ${limitMs}ms`;
   return `Waited ${Math.round(elapsedMs)}ms (${limit})`;
 }
-function watchTimeoutSteer(role, capMs, timeoutParam = "timeoutMs") {
+function watchTimeoutSteer(role, timeoutParam = "timeoutMs") {
   if (role === "worker") {
-    return `The command is still running; this is not a failure. Watch again (${timeoutParam} up to ${capMs}) and don't report a result until it finishes.`;
+    return `The command is still running; this is not a failure. Watch again and don't report a result until it finishes; a bash_watch without ${timeoutParam} waits until the command finishes.`;
   }
   return "The command is still running; this is not a failure. Watch again, do other work, or end your turn: the completion reminder wakes you.";
 }
+var WATCH_UNAVAILABLE_GIVE_UP_MS = 120000;
+var WORKER_KEEP_WAITING = "Call bash_watch again to keep waiting; don't report a result until the command finishes.";
+function interruptedWatchTail(role, primaryTail) {
+  return role === "worker" ? `The task is still running. ${WORKER_KEEP_WAITING}` : primaryTail;
+}
+function workerBackgroundTaskNote(taskId, taskIdArg = "taskId") {
+  return `
+
+NOTE (subagent session): Continue with other work if you have it. If you don't, call bash_watch({ ${taskIdArg}: "${taskId}" }) to wait for completion before returning to the parent; without a timeout it waits until the command finishes. Subagents don't survive turn-end and won't be woken when the command finishes.`;
+}
+function runningTaskStatusHint(role) {
+  return role === "worker" ? "To wait for it, call bash_watch; don't poll." : "A completion reminder will be delivered automatically; don't poll.";
+}
+function watchUnavailableSteer(role) {
+  const unknown = "the bridge was busy, so task state is unknown.";
+  if (role === "worker")
+    return `${unknown} ${WORKER_KEEP_WAITING}`;
+  return `${unknown} Do not poll; let the task's completion notification wake the session, or use one bash_status snapshot on the next normal tool call.`;
+}
 var CONFLICT_HINT = `
 
 [Hint] Use aft_conflicts to see all conflict regions across files in a single call.`;
@@ -10455,6 +10510,9 @@ function isPassiveCommand(command) {
   return PASSIVE_COMMANDS.has(command);
 }
 
+// ../aft-bridge/dist/transport.js
+var WORKER_SESSION_FIELD = "worker_session";
+
 // ../aft-bridge/dist/bridge.js
 var DEFAULT_BRIDGE_TIMEOUT_MS = 30000;
 var BRIDGE_HANG_TIMEOUT_THRESHOLD = 2;
@@ -10873,9 +10931,11 @@ class BinaryBridge {
       params.edit_slot_survives = editSlotSurvives;
       this.logHashlineRegistrationCarrier("tool_call", sessionId, editSlotSurvives);
     }
-    const { preview, ...sendOptions } = options ?? {};
+    const { preview, workerSession, ...sendOptions } = options ?? {};
     if (preview === true)
       params.preview = true;
+    if (workerSession === true)
+      params[WORKER_SESSION_FIELD] = true;
     return await this.send("tool_call", params, Object.keys(sendOptions).length > 0 ? sendOptions : undefined);
   }
   async sendWithVersionMismatchRetry(command, params, options, canRetryAfterVersionSwap) {
@@ -10944,7 +11004,7 @@ class BinaryBridge {
       if (command === "cancel_request" || Object.hasOwn(params, "command") || Object.hasOwn(params, "method")) {
         const nested = { ...params };
         const reserved = {};
-        for (const key of ["session_id", "lsp_hints"]) {
+        for (const key of ["session_id", "lsp_hints", WORKER_SESSION_FIELD]) {
           if (Object.hasOwn(nested, key)) {
             reserved[key] = nested[key];
             delete nested[key];
@@ -11722,6 +11782,35 @@ function coerceJsonCollectionParam(value, field) {
   }
   throw new Error(`${field} must be ${shape} (got an invalid type)`);
 }
+function isBlankParam(value) {
+  if (typeof value === "string")
+    return value.trim().length === 0;
+  return isEmptyParam(value);
+}
+function usableZoomTargets(targets) {
+  if (isEmptyParam(targets))
+    return [];
+  const entries = Array.isArray(targets) ? targets : [targets];
+  return entries.filter((entry) => {
+    if (entry === null || entry === undefined)
+      return false;
+    if (typeof entry !== "object")
+      return true;
+    const record = entry;
+    return !(isBlankParam(record.path) && isBlankParam(record.filePath) && isBlankParam(record.symbol));
+  });
+}
+function isFindReplaceOnlyEdit(args) {
+  const absent = (value) => value === undefined || value === null || value === "";
+  const absentLine = (value) => absent(value) || value === 0;
+  const edits = args.edits;
+  return Array.isArray(edits) && edits.length > 0 && absent(args.appendContent) && absent(args.symbol) && absent(args.content) && edits.every((entry) => {
+    if (entry === null || typeof entry !== "object")
+      return false;
+    const item = entry;
+    return typeof item.oldString === "string" && (absent(item.newString) || typeof item.newString === "string") && absentLine(item.startLine) && absentLine(item.endLine) && absent(item.content);
+  });
+}
 // ../aft-bridge/dist/config-error.js
 import { homedir as homedir5 } from "node:os";
 import { isAbsolute as isAbsolute2, join as join6 } from "node:path";
@@ -14984,6 +15073,13 @@ class SubcTransportShuttingDownError extends SubcCallError {
     this.name = "SubcTransportShuttingDownError";
   }
 }
+
+class ReconnectKeyChangedError extends Error {
+  constructor() {
+    super("the subc daemon restarted and its connection key changed; the reconnect did not complete within the deadline, retry");
+    this.name = "ReconnectKeyChangedError";
+  }
+}
 function isSubcClientClosedError(error) {
   return error instanceof SubcError && error.message === "client closed";
 }
@@ -15486,6 +15582,8 @@ class SubcTransport {
       body.edit_slot_survives = editSlotSurvives;
     if (preview === true)
       body.preview = true;
+    if (options?.workerSession === true)
+      body[WORKER_SESSION_FIELD] = true;
     const reply = await this.pool.routeRequest(this.identityFor(sessionId), body, timeoutMs, onProgress, this.generation, abortSignal);
     return reliftReply(reply);
   }
@@ -15496,7 +15594,10 @@ class SubcTransport {
     }
     const { timeoutMs, onProgress, abortSignal } = this.splitOptions(options);
     const session = typeof params.session_id === "string" ? params.session_id : undefined;
-    const body = { name: command, arguments: params };
+    const { [WORKER_SESSION_FIELD]: workerSession, ...args } = params;
+    const body = { name: command, arguments: args };
+    if (workerSession === true)
+      body[WORKER_SESSION_FIELD] = true;
     const editSlotSurvives = this.pool.getEditSlotSurvives();
     if (editSlotSurvives !== undefined)
       body.edit_slot_survives = editSlotSurvives;
@@ -15533,6 +15634,7 @@ class SubcTransportPool {
   lifecycleRegistration = null;
   outerFacadeEvictor;
   client = null;
+  hadWorkingClient = false;
   connecting = null;
   routeReopenRetryDelayMs = RECONNECT_RETRY_FLOOR_MS;
   routeReopenRetry = null;
@@ -15977,6 +16079,10 @@ class SubcTransportPool {
   }
   async routeRequest(identity, body, timeoutMs, onProgress, expectedGeneration, abortSignal) {
     const callStartedAt = performance.now();
+    const callDeadlineMs = timeoutMs ?? SUBC_DEFAULT_REQUEST_TIMEOUT_MS;
+    let scheduledDelayMs = 0;
+    const spentMs = () => Math.max(performance.now() - callStartedAt, scheduledDelayMs);
+    const remainingMs = () => callDeadlineMs - spentMs();
     const root = asCanonicalRootPath(identity.project_root);
     let generation = expectedGeneration;
     if (this.lifecycleEnabled()) {
@@ -15992,7 +16098,49 @@ class SubcTransportPool {
     try {
       let client;
       try {
-        client = await this.ensureClient();
+        let keyChanged;
+        while (true) {
+          const remaining = remainingMs();
+          if (remaining <= 0)
+            throw keyChanged ?? callDeadlinePassedError(undefined, callDeadlineMs);
+          let timer;
+          try {
+            const acquired = await Promise.race([
+              this.ensureClient(),
+              new Promise((resolve) => {
+                timer = setTimeout(() => resolve(CALL_DEADLINE_EXPIRED), remaining);
+              })
+            ]);
+            if (acquired === CALL_DEADLINE_EXPIRED) {
+              throw keyChanged ?? callDeadlinePassedError(undefined, callDeadlineMs);
+            }
+            client = acquired;
+            break;
+          } catch (error) {
+            if (!(error instanceof ReconnectKeyChangedError))
+              throw error;
+            keyChanged = error;
+            if (spentMs() + this.nextRouteReopenDelayMs() >= callDeadlineMs)
+              throw error;
+          } finally {
+            clearTimeout(timer);
+          }
+          const { delayMs, wait } = this.waitForRouteReopenBackoff();
+          scheduledDelayMs = spentMs() + delayMs;
+          let retryTimer;
+          try {
+            const waited = await Promise.race([
+              wait,
+              new Promise((resolve) => {
+                retryTimer = setTimeout(() => resolve(CALL_DEADLINE_EXPIRED), callDeadlineMs - (performance.now() - callStartedAt));
+              })
+            ]);
+            if (waited === CALL_DEADLINE_EXPIRED)
+              throw keyChanged;
+          } finally {
+            clearTimeout(retryTimer);
+          }
+        }
         this.assertRecordLive(record);
       } catch (error) {
         throw this.annotateReapError(error, record);
@@ -16027,12 +16175,8 @@ class SubcTransportPool {
           throw error;
         }
       };
-      const callDeadlineMs = timeoutMs ?? SUBC_DEFAULT_REQUEST_TIMEOUT_MS;
       const reloadWaitBudgetMs = Math.min(callDeadlineMs, ROUTE_OPEN_RELOAD_WAIT_CEILING_MS);
-      let scheduledDelayMs = 0;
       let lastRefusal;
-      const spentMs = () => Math.max(performance.now() - callStartedAt, scheduledDelayMs);
-      const remainingMs = () => callDeadlineMs - spentMs();
       const openRouteWithinDeadline = async () => {
         const remaining = remainingMs();
         if (remaining <= 0)
@@ -16235,10 +16379,14 @@ class SubcTransportPool {
         throw new SubcTransportShuttingDownError;
       }
       this.client = client;
+      this.hadWorkingClient = true;
       this.transportFailures = 0;
       return client;
     }).catch((error) => {
       this.connecting = null;
+      if (this.hadWorkingClient && error instanceof AuthError) {
+        throw new ReconnectKeyChangedError;
+      }
       throw error;
     });
     return this.connecting;
@@ -17930,6 +18078,7 @@ async function acquireBridge(locationDirectory, options, dependencies = {}) {
       let owner = state.standalone;
       if (!owner) {
         const configByRoot = new Map;
+        const versionMismatchHandlers = new Map;
         const configuredLoader = options.poolOptions.projectConfigLoader;
         const pool = await createPool({
           ...options,
@@ -17939,21 +18088,29 @@ async function acquireBridge(locationDirectory, options, dependencies = {}) {
             projectConfigLoader: (projectRoot) => ({
               ...configuredLoader?.(projectRoot) ?? {},
               ...configByRoot.get(canonicalizeProjectRoot(projectRoot)) ?? {}
-            })
+            }),
+            onVersionMismatch: (binaryVersion, minVersion) => [...versionMismatchHandlers.values()].at(-1)?.(binaryVersion, minVersion) ?? null
           }
         });
-        owner = { pool, configByRoot, referencesByRoot: new Map, references: 0 };
+        owner = {
+          pool,
+          configByRoot,
+          versionMismatchHandlers,
+          referencesByRoot: new Map,
+          references: 0
+        };
         state.standalone = owner;
       }
       owner.references += 1;
       owner.referencesByRoot.set(directory, (owner.referencesByRoot.get(directory) ?? 0) + 1);
       owner.configByRoot.set(directory, { ...options.configOverrides });
       const acquiredOwner = owner;
-      return new LocationBridgeLease(directory, mode, owner.pool, async () => {
+      const lease = new LocationBridgeLease(directory, mode, owner.pool, async () => {
         await withLock(directory, () => withLock(OWNER_LOCK, async () => {
           const current = lifecycleState().standalone;
           if (current !== acquiredOwner)
             return;
+          current.versionMismatchHandlers?.delete(lease);
           current.references -= 1;
           const rootReferences = (current.referencesByRoot.get(directory) ?? 1) - 1;
           if (rootReferences > 0)
@@ -17968,6 +18125,10 @@ async function acquireBridge(locationDirectory, options, dependencies = {}) {
           await current.pool.shutdown();
         }));
       });
+      const onVersionMismatch = options.poolOptions.onVersionMismatch;
+      if (onVersionMismatch)
+        owner.versionMismatchHandlers?.set(lease, onVersionMismatch);
+      return lease;
     });
   });
 }
@@ -17988,6 +18149,14 @@ var STANDALONE_DETACH_KEYWORDS_PATTERN = new RegExp(STANDALONE_DETACH_KEYWORD_SO
 function containsStandaloneDetachKeyword(messageText) {
   return STANDALONE_DETACH_KEYWORD_PATTERN.test(messageText);
 }
+function standaloneDetachKeywordRanges(messageText) {
+  const ranges = [];
+  for (const match of messageText.matchAll(STANDALONE_DETACH_KEYWORDS_PATTERN)) {
+    const start = (match.index ?? 0) + (match[1]?.length ?? 0);
+    ranges.push([start, start + BASH_WAIT_DETACH_MAGIC_KEYWORD.length]);
+  }
+  return ranges;
+}
 function stripStandaloneDetachKeywords(messageText) {
   return messageText.replace(STANDALONE_DETACH_KEYWORDS_PATTERN, "$1");
 }
@@ -19379,31 +19548,36 @@ var ORT_PLATFORM_MAP = {
     arm64: {
       assetName: `onnxruntime-osx-arm64-${ORT_VERSION}`,
       libName: "libonnxruntime.dylib",
-      archiveType: "tgz"
+      archiveType: "tgz",
+      librarySha256: "872533f130f1839a5bc01788ddb4f75c83a189763441ba1178788ed965449289"
     }
   },
   linux: {
     x64: {
       assetName: `onnxruntime-linux-x64-${ORT_VERSION}`,
       libName: "libonnxruntime.so",
-      archiveType: "tgz"
+      archiveType: "tgz",
+      librarySha256: "d132535d051344ff5c64c9c200004150559049a81ed330eb4422c1962fb6b7e4"
     },
     arm64: {
       assetName: `onnxruntime-linux-aarch64-${ORT_VERSION}`,
       libName: "libonnxruntime.so",
-      archiveType: "tgz"
+      archiveType: "tgz",
+      librarySha256: "52b2a0e75e79468404284fec38ad5ee1a7a996232274f5e1b84f3e793fb07554"
     }
   },
   win32: {
     x64: {
       assetName: `onnxruntime-win-x64-${ORT_VERSION}`,
       libName: "onnxruntime.dll",
-      archiveType: "zip"
+      archiveType: "zip",
+      librarySha256: "b95efb2113b603bbbf3f191061c5516a871ed546893c820e4f3b7b6c358dbf2a"
     },
     arm64: {
       assetName: `onnxruntime-win-arm64-${ORT_VERSION}`,
       libName: "onnxruntime.dll",
-      archiveType: "zip"
+      archiveType: "zip",
+      librarySha256: "724d81ac50b11bfaa01ab3ce01b99fb6734a4b762259a8be4395ca662ce99fe6"
     }
   }
 };
@@ -19893,6 +20067,9 @@ async function downloadOnnxRuntime(info, targetDir) {
     copyOnnxLibraries(info, extractedDir, stagedInstallDir, realFiles, symlinks);
     const libPath = join14(stagedInstallDir, info.libName);
     const libHash = sha256File2(libPath);
+    if (libHash !== info.librarySha256) {
+      throw new Error(`onnx runtime library hash mismatch at ${libPath}: sha256 ${libHash}, ` + `expected the pinned ${info.librarySha256} for ${info.assetName}`);
+    }
     writeOnnxInstalledMeta(stagedInstallDir, ORT_VERSION, libHash, archiveSha256);
     publishOnnxRuntime(stagedInstallDir, targetDir);
     rmSync3(tmpDir, { recursive: true, force: true });
@@ -20235,12 +20412,13 @@ function normalizeZoomTargets(record) {
       throw new InvalidRequestError(`'targets[${index}].path' must be a non-empty string`);
     }
     const source = target;
-    const emptyTarget = source.symbol === "" && (hasOwn(source, "path") && source.path === "" || hasOwn(source, "filePath") && source.filePath === "");
+    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", true);
+      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'`));
@@ -25686,6 +25864,10 @@ var SubcConfigSchema = object({
   connection_file: string2().optional(),
   client_reaper: boolean2().optional()
 });
+var OpenCodeHostConfigSchema = object({
+  server_url: string2().optional(),
+  server_password_env: string2().optional()
+});
 var GhShimConfigSchema = object({
   binary_path: string2().trim().refine(isAbsolute7, "gh_shim.binary_path must be absolute").optional()
 });
@@ -25775,6 +25957,7 @@ var AftConfigFieldsSchema = object({
   auto_update: boolean2().optional(),
   bridge: BridgeConfigSchema.optional(),
   subc: SubcConfigSchema.optional(),
+  opencode: OpenCodeHostConfigSchema.optional(),
   github: GithubConfigSchema.optional(),
   gh_shim: GhShimConfigSchema.optional(),
   git: GitConfigSchema.optional(),
@@ -26364,6 +26547,8 @@ function getStrippedTopLevelKeys(override) {
     stripped.push("sandbox.write_allow");
   if (override.subc !== undefined)
     stripped.push("subc");
+  if (override.opencode !== undefined)
+    stripped.push("opencode");
   if (override.github !== undefined)
     stripped.push("github");
   if (override.gh_shim !== undefined)
@@ -40223,6 +40408,14 @@ function formatDuration(completion) {
 }
 
 // src/shared/session-directory.ts
+import { Effect } from "effect";
+function isV2PluginContext(client) {
+  if (!client || typeof client !== "object")
+    return false;
+  const candidate = client;
+  return typeof candidate.location?.directory === "string" && typeof candidate.session?.get === "function";
+}
+var V2_SESSION_LOOKUP_TIMEOUT_MS = 3000;
 var CACHE_MAX_ENTRIES = 200;
 var cache = new Map;
 async function getSessionDirectory(client, sessionId, fallbackDirectory) {
@@ -40234,6 +40427,8 @@ async function getSessionDirectory(client, sessionId, fallbackDirectory) {
     cache.set(sessionId, cached);
     return cached.directory;
   }
+  if (isV2PluginContext(client))
+    return lookupV2SessionDirectory(client, sessionId);
   const c = client;
   const sessionApi = c?.session;
   if (!sessionApi || typeof sessionApi.get !== "function") {
@@ -40254,6 +40449,25 @@ async function getSessionDirectory(client, sessionId, fallbackDirectory) {
   setCache(sessionId, dir);
   return dir;
 }
+async function lookupV2SessionDirectory(context, sessionId) {
+  let dir = null;
+  let failure;
+  try {
+    const session = await Effect.runPromise(Effect.timeout(context.session.get({ sessionID: sessionId }), V2_SESSION_LOOKUP_TIMEOUT_MS));
+    const directory = session?.location?.directory;
+    if (typeof directory === "string" && directory.length > 0)
+      dir = directory;
+    else
+      failure = "the session record has no location.directory";
+  } catch (err) {
+    failure = err instanceof Error ? err.message || err.name : String(err);
+  }
+  if (failure !== undefined) {
+    sessionWarn(sessionId, `[aft-plugin] OpenCode 2 session lookup failed (${failure}); tool paths and bash use the Location directory ${context.location.directory} for this session`);
+  }
+  setCache(sessionId, dir);
+  return dir;
+}
 function setCache(sessionId, directory) {
   if (cache.has(sessionId))
     cache.delete(sessionId);
@@ -40312,6 +40526,108 @@ async function verifySessionDirectory(client, sessionId) {
   return dir;
 }
 
+// src/shared/subagent-detect.ts
+import { Effect as Effect2 } from "effect";
+var CACHE_MAX_ENTRIES2 = 200;
+var LOOKUP_TIMEOUT_MS = 1000;
+var FAILED_LOOKUP_RETRY_MS = 30000;
+var cache2 = new Map;
+var inflight = new Map;
+var now = () => Date.now();
+async function resolveIsSubagent(client, sessionId, _fallbackDirectory) {
+  if (!sessionId) {
+    sessionLog(undefined, "[subagent-detect] no sessionId provided → primary");
+    return false;
+  }
+  const cached = cache2.get(sessionId);
+  if (cached && (cached.retryAfter === undefined || now() < cached.retryAfter)) {
+    cache2.delete(sessionId);
+    cache2.set(sessionId, cached);
+    return cached.isSubagent;
+  }
+  const pending = inflight.get(sessionId);
+  if (pending)
+    return pending;
+  const lookup = boundedLookup(client, sessionId).finally(() => {
+    inflight.delete(sessionId);
+  });
+  inflight.set(sessionId, lookup);
+  return lookup;
+}
+async function boundedLookup(client, sessionId) {
+  let timer;
+  const timedOut = new Promise((resolve) => {
+    timer = setTimeout(() => resolve("timeout"), LOOKUP_TIMEOUT_MS);
+  });
+  let answer;
+  try {
+    answer = await Promise.race([lookupSession(client, sessionId), timedOut]);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (typeof answer === "boolean") {
+    setCache2(sessionId, answer);
+    return answer;
+  }
+  if (answer === "timeout") {
+    sessionWarn(sessionId, `[subagent-detect] session lookup did not answer within ${LOOKUP_TIMEOUT_MS}ms → primary for now`);
+  }
+  setCache2(sessionId, false, now() + FAILED_LOOKUP_RETRY_MS);
+  return false;
+}
+async function lookupSession(client, sessionId) {
+  if (isV2PluginContext2(client))
+    return resolveV2(client, sessionId);
+  const c = client;
+  const sessionApi = c?.session;
+  if (!sessionApi || typeof sessionApi.get !== "function") {
+    sessionLog(sessionId, `[subagent-detect] client.session.get unavailable (client=${typeof client}, session=${typeof sessionApi}, get=${typeof sessionApi?.get}) → caching as primary`);
+    return false;
+  }
+  sessionLog(sessionId, `[subagent-detect] cache miss, calling client.session.get(id=${sessionId})`);
+  try {
+    const result = await sessionApi.get({
+      path: { id: sessionId }
+    });
+    const session = result?.data ?? result;
+    const parentIdRaw = session?.parentID;
+    const isSubagent = session !== undefined && typeof session.parentID === "string" && session.parentID.length > 0;
+    sessionLog(sessionId, `[subagent-detect] SDK returned session=${session !== undefined ? "present" : "undefined"}, parentID=${JSON.stringify(parentIdRaw)} → isSubagent=${isSubagent}`);
+    return isSubagent;
+  } catch (err) {
+    sessionWarn(sessionId, `[subagent-detect] SDK lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    return "failed";
+  }
+}
+function isV2PluginContext2(client) {
+  if (!client || typeof client !== "object")
+    return false;
+  const candidate = client;
+  return typeof candidate.location?.directory === "string" && typeof candidate.session?.get === "function";
+}
+async function resolveV2(context, sessionId) {
+  let session;
+  try {
+    session = await Effect2.runPromise(context.session.get({ sessionID: sessionId }));
+  } catch (err) {
+    sessionWarn(sessionId, `[subagent-detect] OpenCode 2 session lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    return "failed";
+  }
+  const isSubagent = typeof session?.parentID === "string" && session.parentID.length > 0;
+  sessionLog(sessionId, `[subagent-detect] OpenCode 2 session parentID=${JSON.stringify(session?.parentID)} → isSubagent=${isSubagent}`);
+  return isSubagent;
+}
+function setCache2(sessionId, isSubagent, retryAfter) {
+  if (cache2.has(sessionId))
+    cache2.delete(sessionId);
+  cache2.set(sessionId, retryAfter === undefined ? { isSubagent } : { isSubagent, retryAfter });
+  if (cache2.size > CACHE_MAX_ENTRIES2) {
+    const oldest = cache2.keys().next().value;
+    if (oldest !== undefined)
+      cache2.delete(oldest);
+  }
+}
+
 // src/tool-perf.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 var perfStore = new AsyncLocalStorage;
@@ -40387,7 +40703,7 @@ function projectRootFor(runtime) {
   if (typeof cached === "string" && cached.length > 0) {
     return canonicalizeDirectory(cached);
   }
-  const raw = runtime.worktree ?? runtime.directory;
+  const raw = runtime.directoryIsSessionRoot ? runtime.directory : runtime.worktree ?? runtime.directory;
   return canonicalizeDirectory(raw);
 }
 async function resolveProjectRoot(ctx, runtime) {
@@ -40423,6 +40739,11 @@ function bridgeFor(ctx, runtime) {
   }
   return ctx.pool.getBridge(projectRoot);
 }
+async function isWorkerRuntime(ctx, runtime) {
+  if (!runtime.sessionID)
+    return false;
+  return resolveIsSubagent(ctx.client, runtime.sessionID, runtime.directory);
+}
 async function callBridge(ctx, runtime, command, params = {}, options) {
   if (runtime.sessionID && getSessionDirectoryCached(runtime.sessionID) === undefined) {
     await getSessionDirectory(ctx.client, runtime.sessionID, runtime.directory);
@@ -40431,6 +40752,9 @@ async function callBridge(ctx, runtime, command, params = {}, options) {
   if (runtime.sessionID) {
     merged.session_id = runtime.sessionID;
   }
+  if (await isWorkerRuntime(ctx, runtime)) {
+    merged[WORKER_SESSION_FIELD] = true;
+  }
   const timeoutMs = timeoutForCommand(command);
   const sendOptions = {
     ...timeoutMs !== undefined ? { timeoutMs } : {},
@@ -40457,10 +40781,12 @@ async function callToolCall(ctx, runtime, name, rawArgs = {}, options) {
     await getSessionDirectory(ctx.client, runtime.sessionID, runtime.directory);
   }
   const timeoutMs = timeoutForCommand(name);
+  const workerSession = await isWorkerRuntime(ctx, runtime);
   const sendOptions = {
     ...timeoutMs !== undefined ? { timeoutMs } : {},
     configureWarningClient: ctx.client,
     ...runtime.effectAbort ? { abortSignal: runtime.effectAbort } : {},
+    ...workerSession ? { workerSession: true } : {},
     ...options
   };
   markBridgeStart();
@@ -41011,7 +41337,8 @@ var NPM_LSP_TABLE = [
     npm: "typescript",
     binary: "tsserver",
     extensions: ["ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts"],
-    rootMarkers: ["tsconfig.json", "jsconfig.json", "package.json"]
+    rootMarkers: ["tsconfig.json", "jsconfig.json", "package.json"],
+    supportedMajor: 5
   },
   {
     id: "python",
@@ -41085,6 +41412,15 @@ var NPM_LSP_TABLE = [
     rootMarkers: ["biome.json", "biome.jsonc"]
   }
 ];
+function majorVersionOf(version) {
+  const match = /^v?(\d+)(?:\.|$)/.exec(version.trim());
+  return match ? Number(match[1]) : null;
+}
+function isVersionSupported(spec, version) {
+  if (spec.supportedMajor === undefined)
+    return true;
+  return majorVersionOf(version) === spec.supportedMajor;
+}
 
 // src/lsp-project-relevance.ts
 import { existsSync as existsSync14, readdirSync as readdirSync4, readFileSync as readFileSync12 } from "node:fs";
@@ -41181,10 +41517,11 @@ function extensionOf(fileName) {
 
 // src/lsp-registry-probe.ts
 var NPM_REGISTRY_BASE = "https://registry.npmjs.org";
-function pickEligibleVersion(response, graceDays, now = Date.now()) {
+function pickEligibleVersion(response, graceDays, now = Date.now(), accept = () => true) {
   const times = response.time || {};
   const cutoff = now - graceDays * 24 * 60 * 60 * 1000;
   const candidates = [];
+  let releaseCount = 0;
   for (const [version, publishedAt] of Object.entries(times)) {
     if (version === "created" || version === "modified")
       continue;
@@ -41195,6 +41532,9 @@ function pickEligibleVersion(response, graceDays, now = Date.now()) {
     const ts = Date.parse(publishedAt);
     if (Number.isNaN(ts))
       continue;
+    releaseCount += 1;
+    if (!accept(version))
+      continue;
     candidates.push({ version, publishedAt, ts });
   }
   candidates.sort((a, b) => b.ts - a.ts);
@@ -41203,10 +41543,11 @@ function pickEligibleVersion(response, graceDays, now = Date.now()) {
   return {
     version: eligible[0]?.version ?? null,
     blockedByGrace,
+    outsideSupportedRange: releaseCount > 0 && candidates.length === 0,
     eligible: eligible.map(({ version, publishedAt }) => ({ version, publishedAt }))
   };
 }
-async function probeRegistry(npmPackage, graceDays, fetchImpl = fetch) {
+async function probeRegistry(npmPackage, graceDays, fetchImpl = fetch, accept) {
   const encoded = encodeURIComponent(npmPackage).replace(/^%40/, "@");
   const url = `${NPM_REGISTRY_BASE}/${encoded}`;
   try {
@@ -41219,7 +41560,7 @@ async function probeRegistry(npmPackage, graceDays, fetchImpl = fetch) {
       return null;
     }
     const json = await res.json();
-    return pickEligibleVersion(json, graceDays);
+    return pickEligibleVersion(json, graceDays, Date.now(), accept);
   } catch (err) {
     warn2(`[lsp] registry probe failed for ${npmPackage}: ${err}`);
     return null;
@@ -41270,11 +41611,11 @@ async function resolveTargetVersion(spec, config, fetchImpl = fetch) {
   }
   const cached = readVersionCheck(spec.npm);
   const weeklyMs = config.graceDays * 24 * 60 * 60 * 1000;
-  const cachedSafe = isSafeVersion(cached?.latest_eligible ?? null);
+  const cachedSafe = isSafeVersion(cached?.latest_eligible ?? null) && isVersionSupported(spec, cached?.latest_eligible);
   if (cached && !shouldRecheckVersion(cached, weeklyMs) && cachedSafe) {
     return { version: cached.latest_eligible, pinned: false, probe: null };
   }
-  const probe = await probeRegistry(spec.npm, config.graceDays, fetchImpl);
+  const probe = await probeRegistry(spec.npm, config.graceDays, fetchImpl, (candidate) => isVersionSupported(spec, candidate));
   if (!probe) {
     return {
       version: cachedSafe ? cached?.latest_eligible ?? null : null,
@@ -41409,11 +41750,16 @@ async function ensureServerInstalled(spec, config, fetchImpl, signal) {
     const { version, probe } = await resolveTargetVersion(spec, config, fetchImpl);
     if (!version) {
       const installed = isInstalled(spec.npm, spec.binary);
-      if (installed) {
+      if (installed && installedVersionAllowed(spec, config)) {
         warn2(`[lsp] no eligible version of ${spec.npm} (grace=${config.graceDays}d); keeping existing install`);
         return { started: false, reason: "kept existing install" };
       }
-      const blocked = probe?.blockedByGrace ? `all versions are within ${config.graceDays}-day grace window` : "registry probe failed";
+      const blocked = probe?.blockedByGrace ? `all versions are within ${config.graceDays}-day grace window` : probe?.outsideSupportedRange ? `no ${spec.supportedMajor}.x release on the registry` : "registry probe failed";
+      if (installed) {
+        const reason = `cached ${spec.npm} ${readInstalledMeta(spec.npm)?.version ?? "(unknown version)"} is outside the supported ${spec.supportedMajor}.x line and no replacement is available: ${blocked}`;
+        warn2(`[lsp] ${reason}`);
+        return { started: false, reason };
+      }
       warn2(`[lsp] skipping ${spec.npm}: ${blocked}`);
       return { started: false, reason: blocked };
     }
@@ -41538,6 +41884,15 @@ function validateCachedNpmInstall(spec) {
   }
   return true;
 }
+function installedVersionAllowed(spec, config) {
+  const installed = readInstalledMeta(spec.npm)?.version;
+  if (!installed)
+    return spec.supportedMajor === undefined;
+  return isVersionSupported(spec, installed) || config.versions[spec.npm] === installed;
+}
+function cachedInstallUsable(spec, config) {
+  return isInstalled(spec.npm, spec.binary) && validateCachedNpmInstall(spec) && installedVersionAllowed(spec, config);
+}
 function runAutoInstall(projectRoot, config, fetchImpl = fetch) {
   const cachedBinDirs = [];
   const skipped = [];
@@ -41550,7 +41905,7 @@ function runAutoInstall(projectRoot, config, fetchImpl = fetch) {
     return projectExtensions;
   };
   for (const spec of NPM_LSP_TABLE) {
-    if (isInstalled(spec.npm, spec.binary) && validateCachedNpmInstall(spec)) {
+    if (cachedInstallUsable(spec, config)) {
       cachedBinDirs.push(lspBinDir(spec.npm));
     }
     if (config.disabled.has(spec.id) || spec.id === "typescript-sdk" && config.disabled.has("typescript")) {
@@ -41590,7 +41945,7 @@ function runAutoInstall(projectRoot, config, fetchImpl = fetch) {
     },
     skipped,
     installsComplete: Promise.all(installPromises).then(() => {}),
-    getCachedBinDirs: () => NPM_LSP_TABLE.filter((spec) => isInstalled(spec.npm, spec.binary) && validateCachedNpmInstall(spec)).map((spec) => lspBinDir(spec.npm))
+    getCachedBinDirs: () => NPM_LSP_TABLE.filter((spec) => cachedInstallUsable(spec, config)).map((spec) => lspBinDir(spec.npm))
   };
 }
 async function pushLspPathsAfterAutoInstall(pool, projectRoot, cachedBinDirs) {
@@ -43141,391 +43496,8 @@ function astTools(ctx) {
   };
 }
 
-// src/tools/conflicts.ts
-var z3 = tool.schema;
-function conflictTools(ctx) {
-  return {
-    aft_conflicts: {
-      description: "Show all git merge conflicts across the repository — returns line-numbered conflict regions with context for every conflicted file in a single call. Conflicts are discovered from the git repository's top level. By default it inspects the session's project repository; pass `path` to inspect a different repository or git worktree (e.g. where a rebase/merge is running).",
-      args: {
-        path: z3.string().describe("Optional path inside the git repository or worktree to inspect (absolute or relative to project root). Conflicts are discovered from that repository's top level. Defaults to the session project root.").optional()
-      },
-      execute: async (args, context) => {
-        const rawArgs = {};
-        if (!isEmptyParam(args?.path)) {
-          const expanded = expandTilde2(String(args.path));
-          const projectRoot = await resolveProjectRoot(ctx, context);
-          const resolved = resolvePathFromProjectRoot(projectRoot, expanded);
-          const denied = await assertExternalDirectoryPermission(ctx, context, resolved, {
-            kind: "directory"
-          });
-          if (denied)
-            return permissionDeniedResponse(denied);
-          rawArgs.path = resolved;
-        }
-        const response = await callToolCall(ctx, context, "conflicts", rawArgs);
-        if (response.success === false) {
-          throw new Error(response.message || "git_conflicts failed");
-        }
-        return response.text;
-      }
-    }
-  };
-}
-
-// src/tools/definitions/v2.ts
-import { Effect } from "effect";
-var V2_TOOL_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
-var V2_PATH_HEADER_TOOLS = new Set(["read", "write", "edit"]);
-var V2_BASH_TOOLS = new Set(["bash"]);
-var V2_SHELL_PERMISSION = "shell";
-var ROOT_COMBINATORS = ["anyOf", "oneOf", "allOf"];
-function failure(error) {
-  if (error instanceof Error)
-    return error;
-  const detail = (() => {
-    try {
-      return JSON.stringify(error) ?? String(error);
-    } catch {
-      return String(error);
-    }
-  })();
-  return new Error(`V2 tool execution rejected with a non-Error value: ${detail}`);
-}
-function isPlainObject3(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function jsonSafeMetadata(value) {
-  if (Array.isArray(value)) {
-    return value.map((entry) => entry === undefined ? null : jsonSafeMetadata(entry));
-  }
-  if (!isPlainObject3(value))
-    return value;
-  const cleaned = {};
-  for (const [key, entry] of Object.entries(value)) {
-    if (entry === undefined)
-      continue;
-    cleaned[key] = jsonSafeMetadata(entry);
-  }
-  return cleaned;
-}
-function resultContent(result) {
-  if (typeof result === "string")
-    return { content: result };
-  const attachments = (result.attachments ?? []).map((attachment) => ({
-    type: "file",
-    uri: attachment.url,
-    mime: attachment.mime,
-    ...attachment.filename ? { name: attachment.filename } : {}
-  }));
-  const content = attachments.length ? [{ type: "text", text: result.output }, ...attachments] : result.output;
-  const metadata = jsonSafeMetadata({
-    ...result.metadata ?? {},
-    ...result.title ? { title: result.title } : {}
-  });
-  return {
-    content,
-    ...Object.keys(metadata).length ? { metadata } : {}
-  };
-}
-function failureEnvelopeMessage(result) {
-  const output = typeof result === "string" ? result : result.output;
-  if (typeof output !== "string")
-    return;
-  const trimmed = output.trim();
-  if (!trimmed.startsWith("{") || !trimmed.includes('"success"'))
-    return;
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch {
-    return;
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-    return;
-  const envelope = parsed;
-  if (envelope.success !== false)
-    return;
-  for (const field of [envelope.message, envelope.error, envelope.code]) {
-    if (typeof field === "string" && field.length > 0)
-      return field;
-  }
-  return "The tool call failed.";
-}
-function bareToolName3(name) {
-  return name.startsWith("aft_") ? name.slice(4) : name;
-}
-function projectArguments(name, definition) {
-  if (!V2_PATH_HEADER_TOOLS.has(bareToolName3(name)) || !("filePath" in definition.args)) {
-    return { ...definition.args };
-  }
-  const { filePath, ...rest } = definition.args;
-  return { path: filePath, ...rest };
-}
-function executionArguments(name, input) {
-  if (!V2_PATH_HEADER_TOOLS.has(bareToolName3(name)) || !("path" in input))
-    return input;
-  const { path, ...rest } = input;
-  return { filePath: path, ...rest };
-}
-function hostPermission(name) {
-  const bare = bareToolName3(name);
-  if (new Set(["read", "glob", "grep"]).has(bare))
-    return bare;
-  if (V2_BASH_TOOLS.has(name))
-    return V2_SHELL_PERMISSION;
-  if (new Set([
-    "write",
-    "edit",
-    "apply_patch",
-    "delete",
-    "move",
-    "ast_grep_replace",
-    "import",
-    "safety"
-  ]).has(bare)) {
-    return "edit";
-  }
-  return;
-}
-function assertV2Contract(name, input) {
-  if (!V2_TOOL_NAME.test(name)) {
-    throw new Error(`Invalid V2 tool name ${JSON.stringify(name)}; expected ${V2_TOOL_NAME.source}`);
-  }
-  const schema = tool.schema.toJSONSchema(input, { io: "input" });
-  if (schema.type !== "object") {
-    throw new Error(`V2 tool ${name} must have an object-rooted input schema`);
-  }
-  for (const keyword of ROOT_COMBINATORS) {
-    if (keyword in schema) {
-      throw new Error(`V2 tool ${name} input schema cannot use root ${keyword}`);
-    }
-  }
-}
-function v2PermissionRequest(name, request) {
-  if (!V2_BASH_TOOLS.has(name) || request.permission !== "bash")
-    return request;
-  return { ...request, permission: V2_SHELL_PERMISSION };
-}
-function runtimeFor(name, location, context, signal, consumers) {
-  const directory = location.directory;
-  const worktree = location.project?.canonical ?? location.project?.directory ?? directory;
-  return {
-    sessionID: context.sessionID,
-    messageID: context.messageID,
-    agent: context.agent,
-    directory,
-    worktree,
-    abort: signal,
-    effectAbort: signal,
-    metadata: (update) => {
-      Effect.runPromise(context.progress(jsonSafeMetadata({
-        ...update.metadata ?? {},
-        ...update.title ? { title: update.title } : {}
-      })));
-    },
-    ask: (asked) => {
-      const request = v2PermissionRequest(name, asked);
-      if (consumers.requestPermission)
-        return consumers.requestPermission(request, context);
-      return Promise.reject(new Error(`The "${request.permission}" operation was refused because this AFT runtime has no permission evaluator bound, so the host's permission rules for it could not be consulted.`));
-    },
-    progress: context.progress
-  };
-}
-function projectV2Tool(name, definition, location, consumers = {}) {
-  const input = tool.schema.object(projectArguments(name, definition));
-  assertV2Contract(name, input);
-  const sharedOptions = definition.options;
-  const permission = hostPermission(name);
-  return {
-    name,
-    description: definition.description,
-    input,
-    options: {
-      ...sharedOptions,
-      ...permission ? { permission } : {},
-      codemode: false
-    },
-    execute: (rawInput, context) => Effect.tryPromise({
-      try: async (signal) => {
-        const runtime = runtimeFor(name, location, context, signal, consumers);
-        const input = executionArguments(name, rawInput);
-        const result = consumers.executeBash && V2_BASH_TOOLS.has(name) ? await consumers.executeBash({
-          name,
-          input,
-          context: runtime,
-          definition
-        }) : await definition.execute(input, runtime);
-        const refusal = failureEnvelopeMessage(result);
-        if (refusal)
-          throw new Error(refusal);
-        return resultContent(result);
-      },
-      catch: failure
-    })
-  };
-}
-
-// src/tools/hoisted.ts
-import { stat as stat2 } from "node:fs/promises";
-import * as path4 from "node:path";
-
-// src/shared/read-vision.ts
-var VISION_HOST_TIMEOUT_MS = 1500;
-var states = new WeakMap;
-function stateFor2(client) {
-  let state = states.get(client);
-  if (!state) {
-    state = { models: new Map, history: new Map, capabilities: new Map };
-    states.set(client, state);
-  }
-  return state;
-}
-function rememberReadModel(client, sessionID, model) {
-  stateFor2(client).models.set(sessionID, model);
-}
-async function bounded(call) {
-  let timer;
-  try {
-    return await Promise.race([
-      Promise.resolve().then(call),
-      new Promise((resolve) => {
-        timer = setTimeout(() => resolve(undefined), VISION_HOST_TIMEOUT_MS);
-      })
-    ]);
-  } catch {
-    return;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-function record3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
-}
-async function currentSessionVisionCapability(client, sessionID) {
-  if (!sessionID)
-    return;
-  const state = stateFor2(client);
-  let model = state.models.get(sessionID);
-  if (!model) {
-    let pending = state.history.get(sessionID);
-    if (!pending) {
-      pending = bounded(() => resolvePromptContext(client, sessionID)).then((context) => context?.model);
-      state.history.set(sessionID, pending);
-      pending.finally(() => state.history.delete(sessionID));
-    }
-    const historical = await pending;
-    model = state.models.get(sessionID) ?? historical;
-  }
-  if (!model)
-    return;
-  const currentModel = model;
-  const key = JSON.stringify([model.providerID, model.modelID]);
-  let capability = state.capabilities.get(key);
-  if (!capability) {
-    capability = (async () => {
-      const api = client.provider;
-      if (!api?.list)
-        return;
-      const list = api.list.bind(api);
-      const listed = record3(await bounded(list));
-      const catalog = record3(listed?.data) ?? listed;
-      const providers = catalog?.all ?? catalog?.providers;
-      if (!Array.isArray(providers))
-        return;
-      const provider = providers.map(record3).find((entry) => entry?.id === currentModel.providerID);
-      const models = provider?.models;
-      const entry = record3(Array.isArray(models) ? models.find((entry) => record3(entry)?.id === currentModel.modelID) : record3(models)?.[currentModel.modelID]);
-      const inputs = record3(entry?.modalities)?.input;
-      return Array.isArray(inputs) ? inputs.includes("image") : typeof entry?.attachment === "boolean" ? entry.attachment : undefined;
-    })();
-    state.capabilities.set(key, capability);
-    capability.then((value) => {
-      if (value === undefined)
-        state.capabilities.delete(key);
-    });
-  }
-  return capability;
-}
-
-// src/shared/subagent-detect.ts
-import { Effect as Effect2 } from "effect";
-var CACHE_MAX_ENTRIES2 = 200;
-var cache2 = new Map;
-async function resolveIsSubagent(client, sessionId, _fallbackDirectory) {
-  if (!sessionId) {
-    sessionLog(undefined, "[subagent-detect] no sessionId provided → primary");
-    return false;
-  }
-  const cached = cache2.get(sessionId);
-  if (cached) {
-    cache2.delete(sessionId);
-    cache2.set(sessionId, cached);
-    return cached.isSubagent;
-  }
-  if (isV2PluginContext(client))
-    return resolveV2(client, sessionId);
-  const c = client;
-  const sessionApi = c?.session;
-  if (!sessionApi || typeof sessionApi.get !== "function") {
-    sessionLog(sessionId, `[subagent-detect] client.session.get unavailable (client=${typeof client}, session=${typeof sessionApi}, get=${typeof sessionApi?.get}) → caching as primary`);
-    setCache2(sessionId, false);
-    return false;
-  }
-  sessionLog(sessionId, `[subagent-detect] cache miss, calling client.session.get(id=${sessionId})`);
-  let isSubagent = false;
-  let parentIdRaw;
-  try {
-    const result = await sessionApi.get({
-      path: { id: sessionId }
-    });
-    const session = result?.data ?? result;
-    parentIdRaw = session?.parentID;
-    isSubagent = session !== undefined && typeof session.parentID === "string" && session.parentID.length > 0;
-    sessionLog(sessionId, `[subagent-detect] SDK returned session=${session !== undefined ? "present" : "undefined"}, parentID=${JSON.stringify(parentIdRaw)} → isSubagent=${isSubagent}`);
-  } catch (err) {
-    sessionWarn(sessionId, `[subagent-detect] SDK lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-    return false;
-  }
-  setCache2(sessionId, isSubagent);
-  return isSubagent;
-}
-function isV2PluginContext(client) {
-  if (!client || typeof client !== "object")
-    return false;
-  const candidate = client;
-  return typeof candidate.location?.directory === "string" && typeof candidate.session?.get === "function";
-}
-async function resolveV2(context, sessionId) {
-  let session;
-  try {
-    session = await Effect2.runPromise(context.session.get({ sessionID: sessionId }));
-  } catch (err) {
-    sessionWarn(sessionId, `[subagent-detect] OpenCode 2 session lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-    return false;
-  }
-  const isSubagent = typeof session?.parentID === "string" && session.parentID.length > 0;
-  sessionLog(sessionId, `[subagent-detect] OpenCode 2 session parentID=${JSON.stringify(session?.parentID)} → isSubagent=${isSubagent}`);
-  setCache2(sessionId, isSubagent);
-  return isSubagent;
-}
-function setCache2(sessionId, isSubagent) {
-  if (cache2.has(sessionId))
-    cache2.delete(sessionId);
-  cache2.set(sessionId, { isSubagent, recordedAt: Date.now() });
-  if (cache2.size > CACHE_MAX_ENTRIES2) {
-    const oldest = cache2.keys().next().value;
-    if (oldest !== undefined)
-      cache2.delete(oldest);
-  }
-}
-
 // src/tools/bash.ts
-var z4 = tool.schema;
+var z3 = tool.schema;
 var METADATA_PREVIEW_LIMIT = 30 * 1024;
 var DEFAULT_HARD_TIMEOUT_MS = 30 * 60 * 1000;
 var BASH_TRANSPORT_MARGIN_MS = 1e4;
@@ -43541,7 +43513,9 @@ function resolveForegroundWaitMs(configured) {
   }
   return configured;
 }
-function orchestratedTransportTimeoutMs(blockToCompletion, wait, effectiveTimeout, foregroundWaitMs) {
+function orchestratedTransportTimeoutMs(blockToCompletion, wait, effectiveTimeout, foregroundWaitMs, noHardKill = false) {
+  if (noHardKill)
+    return LONGEST_TIMER_DELAY_MS;
   const waitBudget = blockToCompletion || wait ? effectiveTimeout ?? DEFAULT_HARD_TIMEOUT_MS : foregroundWaitMs;
   return waitBudget + BASH_TRANSPORT_MARGIN_MS;
 }
@@ -43618,13 +43592,38 @@ function listenForForegroundAbort(ctx, runtime, enabled) {
 function userMessageDetachDescription(detachOnUserMessage) {
   return detachOnUserMessage ? "Any new message detaches this wait. Set `bash.detach_on_user_message: false` to keep it blocking; even then, a message containing the literal `&detach` forces detachment, and the token is stripped before delivery and the rest of the message is preserved; a token-only message becomes `(requested background detach)`." : "Because `bash.detach_on_user_message` is false, a new message leaves this wait blocking; include the literal `&detach` anywhere to force detachment, and the token is stripped before delivery and the rest of the message is preserved; a token-only message becomes `(requested background detach)`.";
 }
-function backgroundWaitDescription(watchToolRegistered) {
-  return watchToolRegistered ? "then bash_watch handles only a short remaining wait (default 30s, max bash.watch_sync_max_ms, 120s by default); for anything longer end the turn and let the completion reminder wake you, or use bash({wait:true}) when the result is needed before anything else — never background a command and immediately bash_watch it (that wastes a turn for what foreground returns in one), and never loop bash_status to wait." : "the task keeps running after the call returns, a completion reminder arrives when it exits, and bash_status reports its state and output. Use bash({wait:true}) instead when the result is needed before anything else.";
+function bashCompanionRegistered(config, companion) {
+  return resolveBashConfig(config).background && toolEnabled(config, companion);
 }
-function bashToolDescription(aftSearchRegistered, compressionOn, backgroundOn, detachOnUserMessage = true, zoomEnabled = true, watchToolRegistered = true) {
-  const searchSteer = aftSearchRegistered ? `use aft_search (concepts, identifiers, regex, literals), read, aft_outline${zoomEnabled ? ", or aft_zoom" : ""} instead` : `use the grep tool, read, aft_outline${zoomEnabled ? ", or aft_zoom" : ""} instead`;
+function backgroundWaitDescription(watchToolRegistered, statusRegistered) {
+  if (watchToolRegistered) {
+    const noPolling = statusRegistered ? ", and never loop bash_status to wait" : "";
+    return `then bash_watch handles only a short remaining wait (in a main session a watch defaults to 30s, max bash.watch_sync_max_ms, 120s by default; in a delegated session a watch without a timeout waits until the command finishes); for anything longer end the turn and let the completion reminder wake you, or use bash({wait:true}) when the result is needed before anything else — never background a command and immediately bash_watch it (that wastes a turn for what foreground returns in one)${noPolling}.`;
+  }
+  return statusRegistered ? "the task keeps running after the call returns, a completion reminder arrives when it exits, and bash_status reports its state and output. Use bash({wait:true}) instead when the result is needed before anything else." : "the task keeps running after the call returns and a completion reminder arrives when it exits. Use bash({wait:true}) instead when the result is needed before anything else.";
+}
+function ptyDriveClause(statusRegistered, writeRegistered) {
+  if (statusRegistered && writeRegistered) {
+    return ', and is driven with bash_status({ outputMode: "screen" }) plus bash_write';
+  }
+  if (statusRegistered)
+    return ', and its screen is read with bash_status({ outputMode: "screen" })';
+  if (writeRegistered)
+    return ", and is driven with bash_write";
+  return "";
+}
+function bashToolDescription(aftSearchRegistered, compressionOn, backgroundOn, detachOnUserMessage = true, zoomEnabled = true, watchToolRegistered = true, surface = {}) {
+  const outline = surface.outline !== false;
+  const status = surface.status !== false;
+  const write = surface.write !== false;
+  const steerTools = [
+    aftSearchRegistered ? "aft_search (concepts, identifiers, regex, literals)" : "the grep tool",
+    "read",
+    ...outline ? ["aft_outline"] : []
+  ].join(", ");
+  const searchSteer = `use ${steerTools}${zoomEnabled ? ", or aft_zoom" : ""} instead`;
   const compression = compressionOn ? " Output is compressed by default; pass compressed: false for raw output. Piped commands run verbatim and show the pipeline's output; for AFT's test/build summary, run the runner without | head, | tail, or | grep. Pipeline-failure notes cover single top-level pipelines only; multi-statement commands (`a; b | c; d`) are not instrumented, so masked failures inside them still need explicit exit-code checks." : "";
-  const tasks = backgroundOn ? ` Commands run in the foreground and return inline; wait: true blocks until a long command finishes instead of auto-promoting; ${userMessageDetachDescription(detachOnUserMessage)} Use it when you need the result before doing anything else; keep it off otherwise so auto-promote can remind you while you work. Use background: true yourself ONLY when you have other useful work to do while it runs; ${backgroundWaitDescription(watchToolRegistered)} A \`nohup … &\` launch still holds the call if the child keeps stdout/stderr; redirect both or use background:true. pty: true runs interactive programs (REPLs, TUIs), implies background, and is driven with bash_status({ outputMode: "screen" }) plus bash_write.` : " Commands run in the foreground to completion; timeout is the hard kill cap (default 30 minutes).";
+  const tasks = backgroundOn ? ` Commands run in the foreground and return inline; wait: true blocks until a long command finishes instead of auto-promoting; ${userMessageDetachDescription(detachOnUserMessage)} Use it when you need the result before doing anything else; keep it off otherwise so auto-promote can remind you while you work. Use background: true yourself ONLY when you have other useful work to do while it runs; ${backgroundWaitDescription(watchToolRegistered, status)} A \`nohup … &\` launch still holds the call if the child keeps stdout/stderr; redirect both or use background:true. pty: true runs interactive programs (REPLs, TUIs), implies background${ptyDriveClause(status, write)}.` : " Commands run in the foreground to completion; timeout is the hard kill cap (default 30 minutes).";
   return `Execute shell commands.${compression}${tasks}
 
 DO NOT use bash for code search or code exploration. If you are about to run grep, rg, sed, awk, find, or cat through bash to locate or read code: STOP — ${searchSteer}. When 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.`;
@@ -43701,30 +43700,63 @@ async function withPermissionLoop(ctx, runtime, params, bridgeCall, options) {
   }
   throw new Error("bash permission retry failed: too many rounds");
 }
+function ptyDriveParamSentence(statusRegistered, writeRegistered) {
+  const writeInput = 'its input accepts either a string OR an array like [ "iHello", { key: "esc" }, ":wq", { key: "enter" } ] for atomic text+key sequences.';
+  if (statusRegistered && writeRegistered) {
+    return ` Inspect with bash_status({ taskId, outputMode: "screen" }) and drive interactively with bash_write — ${writeInput}`;
+  }
+  if (statusRegistered)
+    return ' Inspect with bash_status({ taskId, outputMode: "screen" }).';
+  if (writeRegistered)
+    return ` Drive interactively with bash_write — ${writeInput}`;
+  return "";
+}
+function nativeSandboxEnabled(config) {
+  return config.sandbox?.enabled === true;
+}
 function createBashTool(ctx, aftSearchRegisteredOverride) {
   const initialBashCfg = resolveBashConfig(ctx.config);
+  const statusRegistered = bashCompanionRegistered(ctx.config, "bash_status");
+  const writeRegistered = bashCompanionRegistered(ctx.config, "bash_write");
+  const taskControls = [
+    ...statusRegistered ? ["bash_status"] : [],
+    ...bashCompanionRegistered(ctx.config, "bash_kill") ? ["bash_kill"] : []
+  ];
+  const waitArg = initialBashCfg.background ? {
+    wait: z3.boolean().optional().describe(`When true, run in the foreground without auto-promoting and wait until the command finishes or reaches its timeout; ${userMessageDetachDescription(initialBashCfg.detach_on_user_message)} Use only when you know the result is required before doing anything else.`)
+  } : {};
+  const sandboxArg = nativeSandboxEnabled(ctx.config) ? {
+    sandbox: z3.literal("host").optional().describe("Request one-command approval to run unsandboxed on the host; use only when native sandboxing blocks required work, and note that it is a no-op when sandboxing is disabled.")
+  } : {};
+  const compressedArg = initialBashCfg.compress ? {
+    compressed: z3.boolean().optional().describe("When true or omitted, return compressed output with noisy terminal control sequences reduced. Set to false for raw output.")
+  } : {};
   const backgroundFlagArg = initialBashCfg.background ? {
-    background: z4.boolean().optional().describe("When true, spawn the command in the background and return a taskId for bash_status/bash_kill instead of waiting for completion. Defaults to false.")
+    background: z3.boolean().optional().describe(`When true, spawn the command in the background and return a taskId${taskControls.length > 0 ? ` for ${taskControls.join("/")}` : ""} instead of waiting for completion. Defaults to false.`)
   } : {};
   const ptyArgs = initialBashCfg.background ? {
-    pty: z4.boolean().optional().describe('When true, spawn the command in a real PTY for interactive programs (python/node/bash REPLs, vim). Implies background: true automatically. Unavailable in subagent sessions. Inspect with bash_status({ taskId, outputMode: "screen" }) and drive interactively with bash_write — its input accepts either a string OR an array like [ "iHello", { key: "esc" }, ":wq", { key: "enter" } ] for atomic text+key sequences.'),
+    pty: z3.boolean().optional().describe(`When true, spawn the command in a real PTY for interactive programs (python/node/bash REPLs, vim). Implies background: true automatically.${initialBashCfg.subagent_background ? "" : " Unavailable in subagent sessions because bash.subagent_background is false."}${ptyDriveParamSentence(statusRegistered, writeRegistered)}`),
     ptyRows: optionalInt(1, 60).describe("PTY terminal height in rows — ignored when pty is false. Defaults to 24 when pty: true. Minimum 1, maximum 60."),
     ptyCols: optionalInt(1, 140).describe("PTY terminal width in columns — ignored when pty is false. Defaults to 80 when pty: true. Minimum 1, maximum 140.")
   } : {};
   const args = {
-    command: z4.string().describe("Shell command to execute. Supports pipes, redirection, and normal shell syntax."),
+    command: z3.string().describe("Shell command to execute. Supports pipes, redirection, and normal shell syntax."),
     timeout: optionalInt(1, Number.MAX_SAFE_INTEGER).describe(initialBashCfg.background ? "Hard kill cap in milliseconds (positive integer). In the default foreground mode when wait is false, a command that exceeds the configured wait window is promoted to background and gets a completion reminder when it exits; wait:true disables promotion and remains inline until completion or timeout." : "Hard kill cap in milliseconds (positive integer). When omitted, the foreground command can run up to 30 minutes and returns inline when it finishes."),
-    workdir: z4.string().optional().describe("Working directory for command execution. Relative paths resolve through the bridge; defaults to the current tool context/project root when omitted."),
-    description: z4.string().optional().describe("Short 5-10 word human-readable summary shown in OpenCode UI metadata instead of raw shell syntax."),
-    wait: z4.boolean().optional().describe(`When true, run in the foreground without auto-promoting and wait until the command finishes or reaches its timeout; ${userMessageDetachDescription(initialBashCfg.detach_on_user_message)} Use only when you know the result is required before doing anything else.`),
-    sandbox: z4.literal("host").optional().describe("Request one-command approval to run unsandboxed on the host; use only when native sandboxing blocks required work, and note that it is a no-op when sandboxing is disabled."),
+    workdir: z3.string().optional().describe("Working directory for command execution. Relative paths resolve through the bridge; defaults to the current tool context/project root when omitted."),
+    description: z3.string().optional().describe("Short 5-10 word human-readable summary shown in OpenCode UI metadata instead of raw shell syntax."),
+    ...waitArg,
+    ...sandboxArg,
     ...backgroundFlagArg,
-    compressed: z4.boolean().optional().describe("When true or omitted, return compressed output with noisy terminal control sequences reduced. Set to false for raw output."),
+    ...compressedArg,
     ...ptyArgs
   };
   let hostFallbackActive = false;
   return {
-    description: bashToolDescription(false, initialBashCfg.compress, initialBashCfg.background, true, toolEnabled(ctx.config, "aft_zoom")),
+    description: bashToolDescription(false, initialBashCfg.compress, initialBashCfg.background, true, toolEnabled(ctx.config, "aft_zoom"), bashCompanionRegistered(ctx.config, "bash_watch"), {
+      outline: toolEnabled(ctx.config, "aft_outline"),
+      status: statusRegistered,
+      write: writeRegistered
+    }),
     args,
     execute: async (args, context) => {
       const bashCfg = resolveBashConfig(ctx.config);
@@ -43738,7 +43770,7 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
       const cwd = args.workdir ?? context.directory;
       const isSubagent = await resolveIsSubagent(ctx.client, context.sessionID, context.directory);
       const backgroundDisabled = !bashCfg.background;
-      const requestedWait = coerceBoolean(args.wait);
+      const requestedWait = !backgroundDisabled && coerceBoolean(args.wait);
       const rawRequestedPty = coerceBoolean(args.pty);
       const rawRequestedBackground = coerceBoolean(args.background);
       if (requestedWait && rawRequestedPty) {
@@ -43749,14 +43781,15 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
       }
       const requestedPty = !backgroundDisabled && rawRequestedPty;
       const requestedBackground = !backgroundDisabled && (rawRequestedBackground || requestedPty);
-      if (requestedPty && isSubagent) {
-        throw new Error("PTY mode is not available in subagent sessions; subagents cannot drive interactive terminals.");
-      }
       const allowSubagentBg = bashCfg.subagent_background;
       const subagentForcedForeground = isSubagent && !allowSubagentBg;
+      if (requestedPty && subagentForcedForeground) {
+        throw new Error("pty:true is unavailable in this subagent session because bash.subagent_background is false; run the command without pty.");
+      }
       const blockToCompletion = subagentForcedForeground || backgroundDisabled || requestedWait;
       const effectiveBackground = blockToCompletion ? false : requestedBackground;
       const rawTimeout = coerceOptionalInt(args.timeout, "timeout", 1, Number.MAX_SAFE_INTEGER);
+      const workerUnboundedWait = isSubagent && requestedWait && rawTimeout === undefined;
       const ptyRows = coerceOptionalInt(args.ptyRows, "ptyRows", 1, 60);
       const ptyCols = coerceOptionalInt(args.ptyCols, "ptyCols", 1, 140);
       const compressed = coerceBoolean(args.compressed, true);
@@ -43787,7 +43820,7 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
           wait: requestedWait,
           sandbox: args.sandbox
         }, callBashBridge, {
-          transportTimeoutMs: orchestratedTransportTimeoutMs(blockToCompletion, requestedWait, rawTimeout, foregroundWaitMs),
+          transportTimeoutMs: orchestratedTransportTimeoutMs(blockToCompletion, requestedWait, rawTimeout, foregroundWaitMs, workerUnboundedWait),
           onProgress: ({ text }) => {
             accumulatedOutput = preview(accumulatedOutput + text);
             metadata?.({ output: accumulatedOutput, description });
@@ -43797,10 +43830,10 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
         const fallbackCause = classifyBashHostFallbackError(error);
         if (!bashCfg.host_fallback || fallbackCause === undefined)
           throw error;
-        if (rawRequestedBackground) {
+        if (!backgroundDisabled && rawRequestedBackground) {
           throw new Error(`${BASH_HOST_FALLBACK_REFUSAL}; background:true is unsupported.`);
         }
-        if (rawRequestedPty) {
+        if (requestedPty) {
           throw new Error(`${BASH_HOST_FALLBACK_REFUSAL}; pty:true is unsupported.`);
         }
         const projectRoot = projectRootFor(context);
@@ -43834,7 +43867,7 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
         trackBgTask(context.sessionID, taskId);
         let rendered = data.output ?? "";
         if (isSubagent && allowSubagentBg) {
-          rendered += subagentGuidance(taskId, bashCfg.watch_sync_max_ms);
+          rendered += workerBackgroundTaskNote(taskId);
         }
         const metadataPayload = { description, output: rendered, status: "running", taskId };
         metadata?.(metadataPayload);
@@ -43853,17 +43886,19 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
   };
 }
 function createBashStatusTool(ctx) {
+  const waitSteer = bashCompanionRegistered(ctx.config, "bash_watch") ? " To wait, use bash_watch." : "";
   return {
-    description: "Read-only snapshot of a background or PTY bash task's current state and output. Returns immediately. Never waits. One look to check on a task is fine — never loop it to wait for completion. To wait, use bash_watch.",
+    description: `Read-only snapshot of a background or PTY bash task's current state and output. Returns immediately. Never waits. One look to check on a task is fine — never loop it to wait for completion.${waitSteer}`,
     args: {
-      taskId: z4.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047a1c39ded."),
-      outputMode: z4.enum(["screen", "raw", "both"]).optional().describe("PTY output rendering mode. Defaults to screen for PTY tasks and preserves existing behavior for piped tasks when omitted.")
+      taskId: z3.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047a1c39ded."),
+      outputMode: z3.enum(["screen", "raw", "both"]).optional().describe("PTY output rendering mode. Defaults to screen for PTY tasks and preserves existing behavior for piped tasks when omitted.")
     },
     execute: async (args, context) => {
       const taskId = args.taskId;
       const outputMode = args.outputMode;
       const data = await bashStatusSnapshot(ctx, context, taskId, outputMode);
-      return await formatBashStatusText(context, taskId, data, outputMode);
+      const isSubagent = await resolveIsSubagent(ctx.client, context.sessionID, context.directory);
+      return await formatBashStatusText(context, taskId, data, outputMode, isSubagent ? "worker" : "primary");
     }
   };
 }
@@ -43871,7 +43906,7 @@ function createBashKillTool(ctx) {
   return {
     description: "Terminate a running background bash task spawned with bash({ background: true }). Returns confirmation of kill or an error if the task already finished.",
     args: {
-      taskId: z4.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047a1c39ded.")
+      taskId: z3.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047a1c39ded.")
     },
     execute: async (args, context) => {
       const data = await callBashBridge(ctx, context, "bash_kill", {
@@ -43894,7 +43929,7 @@ async function bashStatusSnapshot(ctx, runtime, taskId, outputMode, options) {
   }
   return data;
 }
-async function formatBashStatusText(runtime, taskId, data, requestedOutputMode) {
+async function formatBashStatusText(runtime, taskId, data, requestedOutputMode, role) {
   const status = data.status;
   const exit = typeof data.exit_code === "number" ? ` (exit ${data.exit_code})` : "";
   const dur = typeof data.duration_ms === "number" ? ` ${Math.round(data.duration_ms / 1000)}s` : "";
@@ -43912,7 +43947,7 @@ ${preview}`;
     }
     if (status === "running") {
       text += `
-A completion reminder will be delivered automatically; don't poll.`;
+${runningTaskStatusHint(role)}`;
     }
   }
   return text;
@@ -43941,11 +43976,6 @@ PTY task is still running. Use bash_status({ taskId: "${taskId}", outputMode: "s
 function preview(output) {
   return output.length <= METADATA_PREVIEW_LIMIT ? output : output.slice(-METADATA_PREVIEW_LIMIT);
 }
-function subagentGuidance(taskId, watchSyncMaxMs) {
-  return `
-
-NOTE (subagent session): Continue with other work if you have it. If you don't, call bash_watch({ taskId: "${taskId}" }) to wait for completion before returning to the parent; without timeoutMs it waits up to ${watchSyncMaxMs} ms, the maximum. Subagents don't survive turn-end and won't receive the completion reminder.`;
-}
 function foregroundMetadata(description, data, rendered) {
   const outputPath = data.output_path;
   const truncated = typeof data.truncated === "boolean" ? data.truncated : data.output_truncated;
@@ -43966,24 +43996,355 @@ function shortenCommand(command) {
   return collapsed.length <= 80 ? collapsed : `${collapsed.slice(0, 77)}...`;
 }
 
+// src/tools/conflicts.ts
+var z4 = tool.schema;
+function conflictTools(ctx) {
+  return {
+    aft_conflicts: {
+      description: "Show all git merge conflicts across the repository — returns line-numbered conflict regions with context for every conflicted file in a single call. Conflicts are discovered from the git repository's top level. By default it inspects the session's project repository; pass `path` to inspect a different repository or git worktree (e.g. where a rebase/merge is running).",
+      args: {
+        path: z4.string().describe("Optional path inside the git repository or worktree to inspect (absolute or relative to project root). Conflicts are discovered from that repository's top level. Defaults to the session project root.").optional()
+      },
+      execute: async (args, context) => {
+        const rawArgs = {};
+        if (!isEmptyParam(args?.path)) {
+          const expanded = expandTilde2(String(args.path));
+          const projectRoot = await resolveProjectRoot(ctx, context);
+          const resolved = resolvePathFromProjectRoot(projectRoot, expanded);
+          const denied = await assertExternalDirectoryPermission(ctx, context, resolved, {
+            kind: "directory"
+          });
+          if (denied)
+            return permissionDeniedResponse(denied);
+          rawArgs.path = resolved;
+        }
+        const response = await callToolCall(ctx, context, "conflicts", rawArgs);
+        if (response.success === false) {
+          throw new Error(response.message || "git_conflicts failed");
+        }
+        return response.text;
+      }
+    }
+  };
+}
+
+// src/tools/definitions/v2.ts
+import { Effect as Effect3 } from "effect";
+var V2_TOOL_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+var V2_PATH_HEADER_TOOLS = new Set(["read", "write", "edit"]);
+var V2_BASH_TOOLS = new Set(["bash"]);
+var V2_SHELL_PERMISSION = "shell";
+var ROOT_COMBINATORS = ["anyOf", "oneOf", "allOf"];
+function failure(error) {
+  if (error instanceof Error)
+    return error;
+  const detail = (() => {
+    try {
+      return JSON.stringify(error) ?? String(error);
+    } catch {
+      return String(error);
+    }
+  })();
+  return new Error(`V2 tool execution rejected with a non-Error value: ${detail}`);
+}
+function isPlainObject3(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function jsonSafeMetadata(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => entry === undefined ? null : jsonSafeMetadata(entry));
+  }
+  if (!isPlainObject3(value))
+    return value;
+  const cleaned = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry === undefined)
+      continue;
+    cleaned[key] = jsonSafeMetadata(entry);
+  }
+  return cleaned;
+}
+function resultContent(result) {
+  if (typeof result === "string")
+    return { content: result };
+  const attachments = (result.attachments ?? []).map((attachment) => ({
+    type: "file",
+    uri: attachment.url,
+    mime: attachment.mime,
+    ...attachment.filename ? { name: attachment.filename } : {}
+  }));
+  const content = attachments.length ? [{ type: "text", text: result.output }, ...attachments] : result.output;
+  const metadata = jsonSafeMetadata({
+    ...result.metadata ?? {},
+    ...result.title ? { title: result.title } : {}
+  });
+  return {
+    content,
+    ...Object.keys(metadata).length ? { metadata } : {}
+  };
+}
+function failureEnvelopeMessage(result) {
+  const output = typeof result === "string" ? result : result.output;
+  if (typeof output !== "string")
+    return;
+  const trimmed = output.trim();
+  if (!trimmed.startsWith("{") || !trimmed.includes('"success"'))
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return;
+  const envelope = parsed;
+  if (envelope.success !== false)
+    return;
+  for (const field of [envelope.message, envelope.error, envelope.code]) {
+    if (typeof field === "string" && field.length > 0)
+      return field;
+  }
+  return "The tool call failed.";
+}
+function bareToolName3(name) {
+  return name.startsWith("aft_") ? name.slice(4) : name;
+}
+function projectArguments(name, definition) {
+  if (!V2_PATH_HEADER_TOOLS.has(bareToolName3(name)) || !("filePath" in definition.args)) {
+    return { ...definition.args };
+  }
+  const { filePath, ...rest } = definition.args;
+  return { path: filePath, ...rest };
+}
+function executionArguments(name, input) {
+  if (!V2_PATH_HEADER_TOOLS.has(bareToolName3(name)) || !("path" in input))
+    return input;
+  const { path, ...rest } = input;
+  return { filePath: path, ...rest };
+}
+function hostPermission(name) {
+  const bare = bareToolName3(name);
+  if (new Set(["read", "glob", "grep"]).has(bare))
+    return bare;
+  if (V2_BASH_TOOLS.has(name))
+    return V2_SHELL_PERMISSION;
+  if (new Set([
+    "write",
+    "edit",
+    "apply_patch",
+    "delete",
+    "move",
+    "ast_grep_replace",
+    "import",
+    "safety"
+  ]).has(bare)) {
+    return "edit";
+  }
+  return;
+}
+function assertV2Contract(name, input) {
+  if (!V2_TOOL_NAME.test(name)) {
+    throw new Error(`Invalid V2 tool name ${JSON.stringify(name)}; expected ${V2_TOOL_NAME.source}`);
+  }
+  const schema = tool.schema.toJSONSchema(input, { io: "input" });
+  if (schema.type !== "object") {
+    throw new Error(`V2 tool ${name} must have an object-rooted input schema`);
+  }
+  for (const keyword of ROOT_COMBINATORS) {
+    if (keyword in schema) {
+      throw new Error(`V2 tool ${name} input schema cannot use root ${keyword}`);
+    }
+  }
+}
+function v2PermissionRequest(name, request) {
+  if (!V2_BASH_TOOLS.has(name) || request.permission !== "bash")
+    return request;
+  return { ...request, permission: V2_SHELL_PERMISSION };
+}
+function runtimeFor(name, location, context, signal, consumers) {
+  const directory = location.directory;
+  const worktree = location.project?.canonical ?? location.project?.directory ?? directory;
+  return {
+    sessionID: context.sessionID,
+    messageID: context.messageID,
+    agent: context.agent,
+    directory,
+    directoryIsSessionRoot: true,
+    worktree,
+    abort: signal,
+    effectAbort: signal,
+    metadata: (update) => {
+      Effect3.runPromise(context.progress(jsonSafeMetadata({
+        ...update.metadata ?? {},
+        ...update.title ? { title: update.title } : {}
+      })));
+    },
+    ask: (asked) => {
+      const request = v2PermissionRequest(name, asked);
+      if (consumers.requestPermission)
+        return consumers.requestPermission(request, context);
+      return Promise.reject(new Error(`The "${request.permission}" operation was refused because this AFT runtime has no permission evaluator bound, so the host's permission rules for it could not be consulted.`));
+    },
+    progress: context.progress
+  };
+}
+function projectV2Tool(name, definition, location, consumers = {}) {
+  const input = tool.schema.object(projectArguments(name, definition));
+  assertV2Contract(name, input);
+  const sharedOptions = definition.options;
+  const permission = hostPermission(name);
+  return {
+    name,
+    description: definition.description,
+    input,
+    options: {
+      ...sharedOptions,
+      ...permission ? { permission } : {},
+      codemode: false
+    },
+    execute: (rawInput, context) => Effect3.tryPromise({
+      try: async (signal) => {
+        const runtime = runtimeFor(name, location, context, signal, consumers);
+        const input = executionArguments(name, rawInput);
+        const result = consumers.executeBash && V2_BASH_TOOLS.has(name) ? await consumers.executeBash({
+          name,
+          input,
+          context: runtime,
+          definition
+        }) : await definition.execute(input, runtime);
+        const refusal = failureEnvelopeMessage(result);
+        if (refusal)
+          throw new Error(refusal);
+        return resultContent(result);
+      },
+      catch: failure
+    })
+  };
+}
+
+// src/tools/hoisted.ts
+import { stat as stat2 } from "node:fs/promises";
+import * as path4 from "node:path";
+
+// src/hashline-tag-sources.ts
+function hashlineTagSourceSentence(bashRewritesMintTags, isRegistered = () => true) {
+  const rewrites = bashRewritesMintTags ? " (and accepted AFT `cat`/`head`/`tail` rewrites)" : "";
+  const lookAlikes = [
+    ...["aft_zoom", "aft_outline"].filter(isRegistered),
+    "grep",
+    ...isRegistered("aft_search") ? ["aft_search"] : []
+  ].map((name) => `\`${name}\``);
+  lookAlikes.push("conflict snippets");
+  return `Only \`read\`${rewrites} mint hashline tags. ${joinList(lookAlikes)} do not. After navigation, call \`read\` on every file and range the patch addresses.`;
+}
+function joinList(items) {
+  if (items.length <= 2)
+    return items.join(" and ");
+  return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
+}
+
+// src/shared/read-vision.ts
+var VISION_HOST_TIMEOUT_MS = 1500;
+var states = new WeakMap;
+function stateFor2(client) {
+  let state = states.get(client);
+  if (!state) {
+    state = { models: new Map, history: new Map, capabilities: new Map };
+    states.set(client, state);
+  }
+  return state;
+}
+function rememberReadModel(client, sessionID, model) {
+  stateFor2(client).models.set(sessionID, model);
+}
+async function bounded(call) {
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve().then(call),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(undefined), VISION_HOST_TIMEOUT_MS);
+      })
+    ]);
+  } catch {
+    return;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function record3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+async function currentSessionVisionCapability(client, sessionID) {
+  if (!sessionID)
+    return;
+  const state = stateFor2(client);
+  let model = state.models.get(sessionID);
+  if (!model) {
+    let pending = state.history.get(sessionID);
+    if (!pending) {
+      pending = bounded(() => resolvePromptContext(client, sessionID)).then((context) => context?.model);
+      state.history.set(sessionID, pending);
+      pending.finally(() => state.history.delete(sessionID));
+    }
+    const historical = await pending;
+    model = state.models.get(sessionID) ?? historical;
+  }
+  if (!model)
+    return;
+  const currentModel = model;
+  const key = JSON.stringify([model.providerID, model.modelID]);
+  let capability = state.capabilities.get(key);
+  if (!capability) {
+    capability = (async () => {
+      const api = client.provider;
+      if (!api?.list)
+        return;
+      const list = api.list.bind(api);
+      const listed = record3(await bounded(list));
+      const catalog = record3(listed?.data) ?? listed;
+      const providers = catalog?.all ?? catalog?.providers;
+      if (!Array.isArray(providers))
+        return;
+      const provider = providers.map(record3).find((entry) => entry?.id === currentModel.providerID);
+      const models = provider?.models;
+      const entry = record3(Array.isArray(models) ? models.find((entry) => record3(entry)?.id === currentModel.modelID) : record3(models)?.[currentModel.modelID]);
+      const inputs = record3(entry?.modalities)?.input;
+      return Array.isArray(inputs) ? inputs.includes("image") : typeof entry?.attachment === "boolean" ? entry.attachment : undefined;
+    })();
+    state.capabilities.set(key, capability);
+    capability.then((value) => {
+      if (value === undefined)
+        state.capabilities.delete(key);
+    });
+  }
+  return capability;
+}
+
 // src/tools/bash_watch.ts
 var z5 = tool.schema;
-var BASH_WAIT_POLL_INTERVAL_MS = 100;
 var REGEX_WAIT_SCAN_WINDOW_BYTES = 64 * 1024;
 function unavailableSnapshot() {
   return { status: "unknown" };
 }
-function coerceConfiguredWatchTimeout(value, cap) {
+function coerceConfiguredWatchTimeout(value, role, cap) {
   try {
-    return coerceOptionalInt(value, "timeoutMs", 1, cap);
+    return coerceOptionalInt(value, "timeoutMs", 1, maxWatchTimeoutMs(role, cap));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
+    if (role === "worker")
+      throw error;
     throw new Error(`${message} (bash.watch_sync_max_ms)`);
   }
 }
 function createBashWatchTool(ctx) {
+  const noPolling = bashCompanionRegistered(ctx.config, "bash_status") ? " Never loop bash_status to wait." : "";
   return {
-    description: "Watch a background bash task. Sync waits are for a short remaining wait on a task (default 30s, max `bash.watch_sync_max_ms`, 120s by default); for anything longer end the turn on `bash({background:true})` and let the completion reminder wake you, or use `bash({wait:true})` when the result is needed before anything else. The user can interrupt anytime; the wait auto-converts to an async notification. Async (background:true, requires pattern) registers a non-blocking notification and returns immediately — use when you have parallel work or want to end your turn. Never loop bash_status to wait.",
+    description: `Watch a background bash task. ${WATCH_SYNC_DEFAULTS_DESCRIPTION}. In a main session sync waits are for a short remaining wait on a task; for anything longer end the turn on \`bash({background:true})\` and let the completion reminder wake you, or use \`bash({wait:true})\` when the result is needed before anything else. The user can interrupt anytime; the wait auto-converts to an async notification. Async (background:true, requires pattern) registers a non-blocking notification and returns immediately — use when you have parallel work or want to end your turn.${noPolling}`,
     args: {
       taskId: z5.string().describe("Background task ID returned by bash({ background: true })."),
       pattern: z5.union([z5.string(), z5.object({ regex: z5.string() })]).optional().describe("Substring or regex pattern. Optional in sync mode; required with background:true. Sync substring watches keep only the overlap tail needed for boundary matches; sync regex watches use a 64 KB rolling output window."),
@@ -44034,11 +44395,11 @@ A notification will fire when the pattern matches or the task exits.`;
       }
       const syncWaitCap = bashCfg.watch_sync_max_ms;
       const role = isSubagent ? "worker" : "primary";
-      const effectiveWaitMs = subagentForcedSync ? syncWaitCap : resolveWatchTimeoutMs(coerceConfiguredWatchTimeout(args.timeoutMs, syncWaitCap), role, syncWaitCap);
+      const effectiveWaitMs = subagentForcedSync ? undefined : resolveWatchTimeoutMs(coerceConfiguredWatchTimeout(args.timeoutMs, role, syncWaitCap), role, syncWaitCap);
       const data = await waitForBashStatus(ctx, context, taskId, undefined, waitFor, effectiveWaitMs);
       const waited = data.waited;
       if (waited?.reason === "user_message") {
-        const convertedText = await convertToAsyncWatchOnAbort(ctx, context, taskId, waitFor, coerceBoolean(args.once, true), waited.elapsed_ms);
+        const convertedText = await convertToAsyncWatchOnAbort(ctx, context, taskId, waitFor, coerceBoolean(args.once, true), waited.elapsed_ms, role);
         const metadata = context.metadata;
         metadata?.({ taskId, status: data.status, waited, convertedToAsync: true });
         return convertedText;
@@ -44050,10 +44411,11 @@ A notification will fire when the pattern matches or the task exits.`;
     }
   };
 }
-async function convertToAsyncWatchOnAbort(ctx, context, taskId, waitFor, once, elapsedMs) {
+async function convertToAsyncWatchOnAbort(ctx, context, taskId, waitFor, once, elapsedMs, role) {
   const interrupted = `Sync watch for task ${taskId} was interrupted because you sent a message after ${elapsedMs}ms of waiting. `;
+  const reminderFallback = interruptedWatchTail(role, `The task is still running in the background. A completion reminder will be ` + `delivered automatically when the task exits.`);
   if (!waitFor) {
-    return interrupted + `The task is still running in the background. A completion reminder will be ` + `delivered automatically when the task exits; don't poll bash_status.`;
+    return interrupted + interruptedWatchTail(role, `The task is still running in the background. A completion reminder will be ` + `delivered automatically when the task exits; don't poll bash_status.`);
   }
   const notifyParams = {
     task_id: taskId,
@@ -44068,12 +44430,12 @@ async function convertToAsyncWatchOnAbort(ctx, context, taskId, waitFor, once, e
     const registered = await callBashBridge(ctx, context, "bash_notify", notifyParams);
     if (registered.success === false) {
       unmarkExplicitControl(context.sessionID, taskId);
-      return interrupted + `Auto-registering an async watch failed (${String(registered.message ?? "unknown error")}). ` + `The task is still running in the background. A completion reminder will be ` + `delivered automatically when the task exits.`;
+      return interrupted + `Auto-registering an async watch failed (${String(registered.message ?? "unknown error")}). ` + reminderFallback;
     }
-    return interrupted + `The wait has been converted to an async watch (${registered.watch_id}). ` + `A notification will fire when the pattern matches or the task exits.`;
+    return interrupted + `The wait has been converted to an async watch (${registered.watch_id}). ` + interruptedWatchTail(role, `A notification will fire when the pattern matches or the task exits.`);
   } catch (err) {
     unmarkExplicitControl(context.sessionID, taskId);
-    return interrupted + `Auto-registering an async watch failed (${err instanceof Error ? err.message : String(err)}). ` + `The task is still running in the background. A completion reminder will be ` + `delivered automatically when the task exits.`;
+    return interrupted + `Auto-registering an async watch failed (${err instanceof Error ? err.message : String(err)}). ` + reminderFallback;
   }
 }
 function formatWatchResultText(taskId, data, waited, role, syncWaitCap) {
@@ -44082,17 +44444,20 @@ function formatWatchResultText(taskId, data, waited, role, syncWaitCap) {
   const dur = typeof data.duration_ms === "number" ? ` ${Math.round(data.duration_ms / 1000)}s` : "";
   let text = `Task ${taskId}: ${status}${exit}${dur}`;
   if (waited) {
-    const waitedText = formatWatchWaited(waited.elapsed_ms, waited.limit_ms, syncWaitCap);
+    const waitedText = formatWatchWaited(waited.elapsed_ms, waited.limit_ms, role === "primary" ? syncWaitCap : undefined);
     if (waited.reason === "matched") {
       const stream = waited.match_stream ? ` in ${waited.match_stream}` : "";
       text += `
 ${waitedText}; matched ${JSON.stringify(waited.match ?? "")}${stream} at offset ${waited.match_offset ?? 0}.`;
     } else if (waited.reason === "timeout") {
       text += `
-${waitedText}; timeout reached without match. ${watchTimeoutSteer(role, syncWaitCap)}`;
+${waitedText}; timeout reached without match. ${watchTimeoutSteer(role)}`;
     } else if (waited.reason === "unavailable") {
       text += `
-${waitedText}; the bridge was busy, so task state is unknown. Do not poll; let the task's completion notification wake the session, or use one bash_status snapshot on the next normal tool call.`;
+${waitedText}; ${watchUnavailableSteer(role)}`;
+    } else if (waited.reason === "aborted") {
+      text += `
+${waitedText}; the watch was cancelled. The task keeps running.`;
     } else {
       const stat = String(data.status ?? "unknown");
       const e = typeof data.exit_code === "number" ? `, exit ${data.exit_code}` : "";
@@ -44119,9 +44484,17 @@ async function bashStatusSnapshot2(ctx, runtime, taskId, outputMode, cursor, opt
   return data;
 }
 async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effectiveWaitMs) {
-  const startedAt = monotonicNowMs();
-  const deadline = startedAt + effectiveWaitMs;
-  const elapsedMs = () => Math.round(monotonicNowMs() - startedAt);
+  const startedAt = watchClock.now();
+  const deadline = effectiveWaitMs === undefined ? Number.POSITIVE_INFINITY : startedAt + effectiveWaitMs;
+  const elapsedMs = () => Math.round(watchClock.now() - startedAt);
+  const abortSignal = runtime.abort;
+  const pause = () => watchClock.sleep(Math.min(watchPollDelayMs(elapsedMs()), Math.max(0, deadline - watchClock.now())), abortSignal);
+  const waited = (reason, extra = {}) => ({
+    reason,
+    elapsed_ms: elapsedMs(),
+    ...effectiveWaitMs === undefined ? {} : { limit_ms: effectiveWaitMs },
+    ...extra
+  });
   let spillCursor = { output: 0, stderr: 0 };
   const scanState = {
     output: { text: "", baseOffset: 0 },
@@ -44135,31 +44508,29 @@ async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effe
   markTaskWaiting(runtime.sessionID, taskId);
   let sawTerminal = false;
   let lastData;
+  let busySince;
   try {
     while (true) {
+      if (abortSignal?.aborted) {
+        return withWaited(lastData ?? unavailableSnapshot(), waited("aborted"));
+      }
       let data;
       try {
         data = await bashStatusSnapshot2(ctx, runtime, taskId, outputMode, waitFor ? spillCursor : undefined, bridgeOptions);
       } catch (err) {
         if (!isBridgeTransportTimeout(err))
           throw err;
+        busySince ??= watchClock.now();
         if (isSyncWatchAborted(runtime.sessionID)) {
-          return withWaited(lastData ?? unavailableSnapshot(), {
-            reason: "user_message",
-            elapsed_ms: elapsedMs(),
-            limit_ms: effectiveWaitMs
-          });
+          return withWaited(lastData ?? unavailableSnapshot(), waited("user_message"));
         }
-        if (monotonicNowMs() >= deadline) {
-          return withWaited(lastData ?? unavailableSnapshot(), {
-            reason: "unavailable",
-            elapsed_ms: elapsedMs(),
-            limit_ms: effectiveWaitMs
-          });
+        if (watchClock.now() >= deadline || watchClock.now() - busySince >= WATCH_UNAVAILABLE_GIVE_UP_MS) {
+          return withWaited(lastData ?? unavailableSnapshot(), waited("unavailable"));
         }
-        await sleep(Math.min(BASH_WAIT_POLL_INTERVAL_MS, Math.max(0, deadline - monotonicNowMs())));
+        await pause();
         continue;
       }
+      busySince = undefined;
       lastData = data;
       const terminal = isTerminalStatus(data.status);
       if (waitFor) {
@@ -44184,14 +44555,11 @@ async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effe
                 await markBgCompletionDelivered({ ctx, directory: projectRootFor(runtime), sessionID: runtime.sessionID }, taskId);
               }
               const matchStream = data.mode === "pty" ? undefined : chunk.stream === "output" ? "stdout" : "stderr";
-              return withWaited(data, {
-                reason: "matched",
-                elapsed_ms: elapsedMs(),
-                limit_ms: effectiveWaitMs,
+              return withWaited(data, waited("matched", {
                 match: match.text,
                 match_offset: state.baseOffset + match.byteOffset,
                 match_stream: matchStream
-              });
+              }));
             }
             if (waitFor.kind === "substring") {
               const trimmed = trimWaitScanBuffer(state.text, state.baseOffset, waitFor);
@@ -44205,27 +44573,15 @@ async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effe
         sawTerminal = true;
         consumeBgCompletion(runtime.sessionID, taskId);
         await markBgCompletionDelivered({ ctx, directory: projectRootFor(runtime), sessionID: runtime.sessionID }, taskId);
-        return withWaited(data, {
-          reason: "exited",
-          elapsed_ms: elapsedMs(),
-          limit_ms: effectiveWaitMs
-        });
+        return withWaited(data, waited("exited"));
       }
       if (isSyncWatchAborted(runtime.sessionID)) {
-        return withWaited(data, {
-          reason: "user_message",
-          elapsed_ms: elapsedMs(),
-          limit_ms: effectiveWaitMs
-        });
+        return withWaited(data, waited("user_message"));
       }
-      if (monotonicNowMs() >= deadline) {
-        return withWaited(data, {
-          reason: "timeout",
-          elapsed_ms: elapsedMs(),
-          limit_ms: effectiveWaitMs
-        });
+      if (watchClock.now() >= deadline) {
+        return withWaited(data, waited("timeout"));
       }
-      await sleep(Math.min(BASH_WAIT_POLL_INTERVAL_MS, Math.max(0, deadline - monotonicNowMs())));
+      await pause();
     }
   } finally {
     if (!sawTerminal)
@@ -44335,8 +44691,9 @@ function withWaited(data, waited) {
 // src/tools/bash_write.ts
 var z6 = tool.schema;
 function createBashWriteTool(ctx) {
+  const modeCheck = bashCompanionRegistered(ctx.config, "bash_status") ? '; check bash_status reports mode: "pty" first.' : ".";
   return {
-    description: 'Write input bytes to a running PTY bash task. PTY-only; check bash_status reports mode: "pty" first. ' + 'Input is either a string (verbatim bytes) or an array mixing strings and { key: "esc" | "enter" | "up" | "ctrl-c" | ... } objects ' + 'for atomic text+key sequences such as [ "iHello", { key: "esc" }, ":wq", { key: "enter" } ]. ' + "Named keys cover enter/return/tab/space/backspace/esc/escape, arrows, home/end/page-up/page-down/delete/insert, f1..f12, and ctrl-a..ctrl-z. " + "Maximum 1 MiB per call (post-expansion).",
+    description: `Write input bytes to a running PTY bash task. PTY-only${modeCheck} ` + 'Input is either a string (verbatim bytes) or an array mixing strings and { key: "esc" | "enter" | "up" | "ctrl-c" | ... } objects ' + 'for atomic text+key sequences such as [ "iHello", { key: "esc" }, ":wq", { key: "enter" } ]. ' + "Named keys cover enter/return/tab/space/backspace/esc/escape, arrows, home/end/page-up/page-down/delete/insert, f1..f12, and ctrl-a..ctrl-z. " + "Maximum 1 MiB per call (post-expansion).",
     args: {
       taskId: z6.string().describe("Background PTY task ID returned by bash({ pty: true, background: true })."),
       input: z6.union([
@@ -44604,25 +44961,19 @@ function createReadTool(ctx) {
           const failure = classifyPermissionError(error);
           return permissionDeniedResponse(failure.kind === "rule_denied" ? permissionRuleDenial("read") : failure.message);
         }
-        const rawStartLine = coerceOptionalInt(args.startLine, "startLine", 1, Number.MAX_SAFE_INTEGER);
-        const rawEndLine = coerceOptionalInt(args.endLine, "endLine", 1, Number.MAX_SAFE_INTEGER);
-        const rawLimit = coerceOptionalInt(args.limit, "limit", 1, Number.MAX_SAFE_INTEGER);
-        const rawOffset = coerceOptionalInt(args.offset, "offset", 1, Number.MAX_SAFE_INTEGER);
-        let startLine = rawStartLine;
-        let endLine = rawEndLine;
-        if (startLine === undefined && rawOffset !== undefined) {
-          startLine = rawOffset;
-          if (rawLimit !== undefined) {
-            endLine = rawOffset + rawLimit - 1;
-          }
-        }
+        const startLine = coerceOptionalInt(args.startLine, "startLine", 1, Number.MAX_SAFE_INTEGER);
+        const endLine = coerceOptionalInt(args.endLine, "endLine", 1, Number.MAX_SAFE_INTEGER);
+        const limit = coerceOptionalInt(args.limit, "limit", 1, Number.MAX_SAFE_INTEGER);
+        const offset = coerceOptionalInt(args.offset, "offset", 1, Number.MAX_SAFE_INTEGER);
         const rawArgs = { filePath: file };
         if (startLine !== undefined)
           rawArgs.startLine = startLine;
         if (endLine !== undefined)
           rawArgs.endLine = endLine;
-        if (rawLimit !== undefined && rawOffset === undefined)
-          rawArgs.limit = rawLimit;
+        if (offset !== undefined)
+          rawArgs.offset = offset;
+        if (limit !== undefined)
+          rawArgs.limit = limit;
         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)
@@ -44678,7 +45029,7 @@ function createWriteTool(ctx, editToolName = "edit") {
     description: 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")
+      content: z7.string().describe("The full content to write to the file; for issue://N / pr://N, the comment body to post")
     },
     execute: async (args, context) => {
       const argsRecord = args;
@@ -44795,7 +45146,7 @@ ${backupBehavior}
 - Symbol replace includes decorators, attributes, and doc comments in range
 - Response is a compact server-rendered summary; before/after diff details are attached as UI metadata when available.`;
 }
-var HASHLINE_EDIT_DESCRIPTION = [
+var HASHLINE_EDIT_GRAMMAR = [
   "Apply a hashline patch. Arguments are exactly `{patch}` where `patch` is a non-empty string. Server-owned preview control is outside this schema.",
   "",
   "Quick reference:",
@@ -44803,13 +45154,18 @@ var HASHLINE_EDIT_DESCRIPTION = [
   "- Same canonical path: multiple sections compose in patch order against pre-request coordinates.",
   "- Addresses: `0` (BOF), `N` (one line), `N.=M` (range; `N..=M`/`N..M` also work), `<N`/`>N` (gap before/after), `N*`/`<N*`/`>N*` (block), and `$`/`$-K` (EOF-relative). A plain `N` PUT replaces; use `<N` or `>N` to insert.",
   "- PUT text: `PUT <address>:` followed by one or more `+` body rows (`+` alone is blank). A final patch newline is allowed. PUT without `:` copies `@name` (or the anonymous register) and takes no body; names use `@` plus ASCII letters, digits, `_`, or `-`.",
-  "- CUT: `CUT <address> [@name]`. REM: bare `REM` only, removing the whole file. MV: `MV <destination>` (one whitespace-free path, optional matching quotes), once and after any line operations. `*** Begin Patch`/`*** End Patch` is an optional envelope.",
-  "- Only `read` (and accepted AFT `cat`/`head`/`tail` rewrites) mint hashline tags. `aft_zoom`, `aft_outline`, `grep`, `aft_search`, and conflict snippets do not. After navigation, call `read` on every file and range the patch addresses."
+  "- CUT: `CUT <address> [@name]`. REM: bare `REM` only, removing the whole file. MV: `MV <destination>` (one whitespace-free path, optional matching quotes), once and after any line operations. `*** Begin Patch`/`*** End Patch` is an optional envelope."
 ].join(`
 `);
+function hashlineEditDescription(config) {
+  const bashRewrites = toolEnabled(config, "bash") && resolveBashConfig(config).rewrite;
+  const tagSources = hashlineTagSourceSentence(bashRewrites, (name) => toolEnabled(config, name));
+  return `${HASHLINE_EDIT_GRAMMAR}
+- ${tagSources}`;
+}
 function createHashlineEditTool(ctx) {
   return {
-    description: HASHLINE_EDIT_DESCRIPTION,
+    description: hashlineEditDescription(ctx.config),
     args: {
       patch: z7.string().min(1).describe("Hashline patch text with one or more [path#TAG] sections and PUT/CUT/REM/MV operations")
     },
@@ -44884,8 +45240,7 @@ function createEditTool(ctx, writeToolName = "write") {
         throw new Error("'path' parameter is required");
       if (isGithubResourcePath(file)) {
         const edits = argsRecord.edits;
-        const onlyFindReplace = Array.isArray(edits) && edits.length > 0 && argsRecord.appendContent === undefined && argsRecord.symbol === undefined && argsRecord.content === undefined && edits.every((entry) => entry !== null && typeof entry === "object" && typeof entry.oldString === "string" && (entry.newString === undefined || typeof entry.newString === "string") && entry.startLine === undefined && entry.endLine === undefined && entry.content === undefined);
-        if (!onlyFindReplace) {
+        if (!isFindReplaceOnlyEdit(argsRecord)) {
           throw new Error("edit: GitHub resources support only edits[] find/replace entries with oldString and optional newString");
         }
         const rawArgs = { path: file, edits };
@@ -45172,6 +45527,12 @@ function createMoveTool(ctx) {
   };
 }
 function hoistedTools(ctx) {
+  const backgroundCompanions = resolveBashConfig(ctx.config).background ? {
+    bash_status: createBashStatusTool(ctx),
+    bash_write: createBashWriteTool(ctx),
+    bash_watch: createBashWatchTool(ctx),
+    bash_kill: createBashKillTool(ctx)
+  } : {};
   const tools = {
     read: createReadTool(ctx),
     write: createWriteTool(ctx, "edit"),
@@ -45180,10 +45541,7 @@ function hoistedTools(ctx) {
     aft_delete: createDeleteTool(ctx),
     aft_move: createMoveTool(ctx),
     bash: createBashTool(ctx),
-    bash_status: createBashStatusTool(ctx),
-    bash_write: createBashWriteTool(ctx),
-    bash_watch: createBashWatchTool(ctx),
-    bash_kill: createBashKillTool(ctx)
+    ...backgroundCompanions
   };
   return prepareToolMap(tools, { hashlineEffective: ctx.hashlineEffective });
 }
@@ -45579,6 +45937,9 @@ function navigationTools(ctx) {
 
 // src/tools/reading.ts
 var z11 = tool.schema;
+function isGithubPathArg(value) {
+  return typeof value === "string" && (value.startsWith("issue://") || value.startsWith("pr://"));
+}
 function buildZoomTitle(args) {
   const targets = args.targets;
   if (!isEmptyParam(targets)) {
@@ -45602,6 +45963,13 @@ function buildZoomTitle(args) {
   }
   return path || "(no target)";
 }
+function outlineFocusSteer(config) {
+  const zoomEnabled = toolEnabled(config, "aft_zoom");
+  const reader = zoomEnabled ? "aft_zoom" : "read";
+  const locate = toolEnabled(config, "aft_search") ? `aft_search + ${reader}` : reader;
+  const callgraph = zoomEnabled ? toolEnabled(config, "aft_callgraph") ? " aft_zoom with `callgraph:true` gives one-level forward calls-out; use aft_callgraph only for reverse callers or multi-level traces." : " aft_zoom with `callgraph:true` gives one-level forward calls-out." : "";
+  return `For understanding a specific feature, prefer ${locate} on named symbols; use aft_outline on a whole directory only for high-level structure mapping.${callgraph}`;
+}
 function readingTools(ctx) {
   const zoomEnabled = toolEnabled(ctx.config, "aft_zoom");
   const ghReadEnabled = resolveGithubConfig(ctx.config).read;
@@ -45609,9 +45977,9 @@ function readingTools(ctx) {
   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" + (zoomEnabled ? "For understanding a specific feature, prefer aft_search + aft_zoom on named symbols; use aft_outline on a whole directory only for high-level structure mapping. aft_zoom with `callgraph:true` gives one-level forward calls-out; use aft_callgraph only for reverse callers or multi-level traces.\n\n" : `For understanding a specific feature, prefer aft_search + read on named symbols; use aft_outline on a whole directory only for high-level structure mapping.
+      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) + `
 
-`) + "Pass a single `target`:\n" + `  • file path → outline that file (with signatures)
+` + "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 ? `
@@ -45660,7 +46028,7 @@ ${githubOutlineDescription}` : "") + "\n\nWhen a list is cut, the reply ends wit
       }
     },
     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 exactly ONE mode: `{ path, symbols }`, `{ url, symbols }`, or `{ targets }`. `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." + (githubZoomDescription ? `
+      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 ? `
 
 ${githubZoomDescription}` : ""),
       args: {
@@ -45676,37 +46044,22 @@ ${githubZoomDescription}` : ""),
             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. Mutually exclusive with path/url/symbols."),
+        ]).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.")
       },
       execute: async (args, context) => {
-        const hasTargetsProvided = (t) => {
-          if (isEmptyParam(t))
-            return false;
-          const entryEmpty = (entry) => {
-            if (!entry || typeof entry !== "object")
-              return true;
-            const fp = entry.path;
-            const sym = entry.symbol;
-            const fpEmpty = typeof fp !== "string" || fp.length === 0;
-            const symEmpty = typeof sym !== "string" || sym.length === 0;
-            return fpEmpty && symEmpty;
-          };
-          if (Array.isArray(t))
-            return !t.every(entryEmpty);
-          return !entryEmpty(t);
-        };
         const targetsInput = coerceJsonCollectionParam(args.targets, "targets");
-        const hasFilePath = !isEmptyParam(args.path);
-        const hasUrl = !isEmptyParam(args.url);
-        const hasTargets = hasTargetsProvided(targetsInput);
-        const hasSymbols = !isEmptyParam(args.symbols);
+        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: targetsInput
+          targets: hasTargets ? targetEntries : undefined
         });
         const zoomDisplay = { title: zoomTitle };
         if (hasFilePath)
@@ -45717,7 +46070,7 @@ ${githubZoomDescription}` : ""),
           zoomDisplay.symbols = typeof args.symbols === "string" ? args.symbols : JSON.stringify(args.symbols);
         }
         if (hasTargets)
-          zoomDisplay.targets = JSON.stringify(targetsInput);
+          zoomDisplay.targets = JSON.stringify(targetEntries);
         if (contextLines !== undefined)
           zoomDisplay.contextLines = contextLines;
         if (wantCallgraph)
@@ -45728,23 +46081,24 @@ ${githubZoomDescription}` : ""),
           metadata: zoomDisplay
         });
         if (hasTargets) {
-          if (hasFilePath || hasUrl || hasSymbols) {
-            throw new Error("'targets' is mutually exclusive with 'path', 'url', and 'symbols'");
+          if (hasFilePath && hasUrl) {
+            throw new Error("Provide exactly ONE of 'path' or 'url' — not both");
           }
-          const targets = Array.isArray(targetsInput) ? targetsInput : [targetsInput];
-          if (targets.length === 0) {
-            throw new Error("'targets' must be a non-empty object or array");
-          }
-          for (const [i, entry] of targets.entries()) {
-            const targetPath = entry?.path;
-            if (typeof targetPath !== "string" || targetPath.length === 0) {
+          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`);
             }
-            if (typeof entry.symbol !== "string" || entry.symbol.length === 0) {
-              throw new Error(`targets[${i}].symbol must be a non-empty string`);
-            }
-          }
-          const resolvedTargets = await Promise.all(targets.map((t) => resolvePathArg(ctx, context, t.path)));
+            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 permissionDenied = await assertPathExternalPermissions(ctx, context, resolvedTargets);
           if (permissionDenied)
             return permissionDeniedResponse(permissionDenied);
@@ -45754,6 +46108,12 @@ ${githubZoomDescription}` : ""),
               symbol: target.symbol
             }))
           };
+          if (hasFilePath)
+            rawArgs.filePath = args.path;
+          else if (hasUrl)
+            rawArgs.url = args.url;
+          if (hasSymbols)
+            rawArgs.symbols = args.symbols;
           if (contextLines !== undefined)
             rawArgs.contextLines = contextLines;
           if (wantCallgraph)
@@ -45770,7 +46130,7 @@ ${githubZoomDescription}` : ""),
         if (hasFilePath && hasUrl) {
           throw new Error("Provide exactly ONE of 'path' or 'url' — not both");
         }
-        const githubPath = hasFilePath && (String(args.path).startsWith("issue://") || String(args.path).startsWith("pr://")) || hasUrl && (String(args.url).startsWith("issue://") || String(args.url).startsWith("pr://"));
+        const githubPath = hasFilePath && isGithubPathArg(args.path) || hasUrl && isGithubPathArg(args.url);
         if (!hasUrl && !githubPath) {
           const file = await resolvePathArg(ctx, context, args.path);
           const permissionDenied = await assertPathExternalPermissions(ctx, context, file);
@@ -45861,7 +46221,7 @@ function safetyTools(ctx) {
 ` + "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 restore — restores only that file). Absolute or relative to project root"),
+        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"),
         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)")
       },
@@ -46297,8 +46657,20 @@ function buildAftToolDefinitions(ctx, config, onUnknownDisabled) {
   const unknown = unknownDisabledTools(disabled);
   if (unknown.length > 0)
     onUnknownDisabled?.(unknown);
+  describeBashForRegisteredSurface(allTools, config);
   return allTools;
 }
+function describeBashForRegisteredSurface(allTools, config) {
+  const bash = allTools.bash;
+  if (!bash)
+    return;
+  const bashCfg = resolveBashConfig(config);
+  bash.description = bashToolDescription("aft_search" in allTools, bashCfg.compress, bashCfg.background, bashCfg.detach_on_user_message, "aft_zoom" in allTools, "bash_watch" in allTools, {
+    outline: "aft_outline" in allTools,
+    status: "bash_status" in allTools,
+    write: "bash_write" in allTools
+  });
+}
 function registerAftTools(context, location, definitions, consumers = {}) {
   const projected = Object.entries(definitions).map(([name, definition]) => projectV2Tool(name, definition, location, consumers));
   return context.tool.transform((editor) => {
@@ -49009,7 +49381,10 @@ function registerShutdownCleanup(fn) {
 
 // src/workflow-hints.ts
 var HEADING = "## IMPORTANT NOTICE about your tools";
-var HASHLINE_TAG_SOURCE_HINT = "**Hashline edit tags**: Only `read` (and accepted AFT `cat`/`head`/`tail` rewrites) mint hashline tags. `aft_zoom`, `aft_outline`, `grep`, `aft_search`, and conflict snippets do not. After navigation, call `read` on every file and range the patch addresses.";
+function hashlineTagSourceHint(bashRewritesMintTags, isRegistered = () => true) {
+  return `**Hashline edit tags**: ${hashlineTagSourceSentence(bashRewritesMintTags, isRegistered)}`;
+}
+var HASHLINE_TAG_SOURCE_HINT = hashlineTagSourceHint(true);
 function buildWorkflowHints(opts) {
   const sections = [];
   const grepName = "grep";
@@ -49026,6 +49401,8 @@ function buildWorkflowHints(opts) {
   const hasInspect = !opts.disabledTools.has("aft_inspect");
   const hasBash = !opts.disabledTools.has(bashName);
   const hasBgBash = hasBash && opts.bashBackgroundEnabled && !opts.disabledTools.has(bashStatusName);
+  const hasWatch = !opts.disabledTools.has("bash_watch");
+  const hasWrite = !opts.disabledTools.has(bashWriteName);
   if (hasBash && opts.bashCompressionEnabled) {
     sections.push([
       "**Test/build output**: bash output is auto-compressed for non-piped commands. Piped commands run verbatim and show the pipeline's output. For AFT's test/build summary, run the runner without filters:",
@@ -49067,17 +49444,19 @@ function buildWorkflowHints(opts) {
     ].join(`
 `));
   }
-  if (hasBash && hasBgBash) {
+  if (hasBgBash && hasWatch) {
     sections.push([
       `**Long-running commands** (builds, installs, full test suites): run them in the FOREGROUND — use \`${bashName}({ command, wait: true })\` when you know it is long and need the result before anything else; if you send a new message, the wait detaches to background; otherwise omit \`wait\` so auto-promote can hand you a reminder while you work.`,
       "- `background: true` is ONLY for when you have OTHER useful work to do while it runs: start it, do the other work, and the completion reminder delivers the result (or spawn a subagent for the side work). Do NOT background a command and then immediately `bash_watch` it — that spends a whole extra turn waiting for something foreground returns in one.",
       "- `bash_watch` is for blocking on an ALREADY-backgrounded task once you've run out of parallel work (sync — the user can interrupt), or reacting to a specific early output line (async: background:true + pattern). Never loop `bash_status` to wait — it's a one-shot inspector."
     ].join(`
 `));
+  }
+  if (hasBgBash && hasWrite) {
     sections.push(`**PTY / interactive commands**: PTY mode is for interactive REPLs and terminal apps (python, node, bash itself, vim). Start with \`${bashName}({ command: "python", pty: true, background: true })\`, read the screen with \`${bashStatusName}({ taskId, outputMode: "screen" })\`, and send input with \`${bashWriteName}({ taskId, input: "..." })\`.`);
   }
   if (opts.hashlineEffective === true) {
-    sections.push(HASHLINE_TAG_SOURCE_HINT);
+    sections.push(hashlineTagSourceHint(hasBash && opts.bashRewriteEnabled !== false, (name) => !opts.disabledTools.has(name)));
   }
   if (sections.length === 0) {
     return null;
@@ -49092,13 +49471,32 @@ ${sections.join(`
 `)}`;
 }
 function buildHintsFromConfig(config, disabledTools, hashlineEffective = false) {
+  const bashCfg = resolveBashConfig(config);
   return buildWorkflowHints({
-    bashBackgroundEnabled: resolveBashConfig(config).background,
-    bashCompressionEnabled: resolveBashConfig(config).compress,
+    bashBackgroundEnabled: bashCfg.background,
+    bashCompressionEnabled: bashCfg.compress,
+    bashRewriteEnabled: bashCfg.rewrite,
     disabledTools,
     hashlineEffective
   });
 }
+var WORKFLOW_HINT_TOOL_NAMES = [
+  "aft_outline",
+  "aft_zoom",
+  "aft_search",
+  "aft_callgraph",
+  "aft_inspect",
+  "grep",
+  "read",
+  "bash",
+  "bash_status",
+  "bash_watch",
+  "bash_write"
+];
+function buildHintsForRegisteredTools(config, registeredTools, hashlineEffective = false) {
+  const absent = new Set(WORKFLOW_HINT_TOOL_NAMES.filter((name) => !registeredTools.has(name)));
+  return buildHintsFromConfig(config, absent, hashlineEffective);
+}
 function appendHintsToSystem(system, hintsBlock) {
   if (!hintsBlock)
     return;
@@ -49469,36 +49867,13 @@ Install: ${getManualInstallHint()}`);
     signal: autoUpdateAbort.signal,
     storageDir: ctx.storageDir
   });
-  const HINTS_TOOL_NAMES = [
-    "aft_outline",
-    "aft_zoom",
-    "aft_search",
-    "aft_callgraph",
-    "aft_inspect",
-    "grep",
-    "read",
-    "bash",
-    "bash_status"
-  ];
   const registeredTools = new Set(Object.keys(allTools));
   const { hashlineEditRegistered, aftSearchRegistered } = applyToolSurfaceOverrides(pool, aftConfig, registeredTools);
   ctx.hashlineEffective = hashlineEditRegistered;
   const hashlineDowngrade = reportHashlineDowngrade(aftConfig, registeredTools, (message) => deliverConfigMigrationWarnings(registrationRoot, [message]));
   log2(`hashline activation decision requested=${aftConfig.edit_mode === "hashline"} ` + `edit_slot_survives=${hashlineEditRegistered} effective=${ctx.hashlineEffective}` + (hashlineDowngrade ? ` downgraded=${hashlineDowngrade.code}` : ""));
   ctx.aftSearchRegistered = aftSearchRegistered;
-  for (const name of ["bash"]) {
-    const def = allTools[name];
-    if (def) {
-      const bashCfg = resolveBashConfig(aftConfig);
-      def.description = bashToolDescription(aftSearchRegistered, bashCfg.compress, bashCfg.background, bashCfg.detach_on_user_message);
-    }
-  }
-  const hintsAbsentTools = new Set;
-  for (const name of HINTS_TOOL_NAMES) {
-    if (!registeredTools.has(name))
-      hintsAbsentTools.add(name);
-  }
-  const hintsBlock = buildHintsFromConfig(aftConfig, hintsAbsentTools, hashlineEditRegistered);
+  const hintsBlock = buildHintsForRegisteredTools(aftConfig, registeredTools, hashlineEditRegistered);
   if (hintsBlock) {
     log2(`Workflow hints injected (${hintsBlock.length} chars)`);
   }
@@ -49644,10 +50019,10 @@ Install: ${getManualInstallHint()}`);
 var src_default = plugin;
 
 // src/entry/server-runtime.mjs
-import { Effect as Effect7 } from "effect";
+import { Effect as Effect9 } from "effect";
 
 // src/rpc/register.ts
-import { Effect as Effect3 } from "effect";
+import { Effect as Effect4 } from "effect";
 
 // src/tui/aft-rpc.ts
 import { Schema } from "effect";
@@ -49726,7 +50101,7 @@ function isStatusSubscribable(bridge) {
   return typeof bridge.subscribeStatus === "function";
 }
 function locationRoot(location) {
-  return location.project?.canonical ?? location.project?.directory ?? location.directory;
+  return location.directory;
 }
 function placeholderStatus() {
   return {
@@ -49743,7 +50118,7 @@ function restoreOwnProperty(target, key, descriptor) {
     Reflect.deleteProperty(target, key);
 }
 function registerAftRpc(context, location, pool) {
-  return Effect3.gen(function* () {
+  return Effect4.gen(function* () {
     const root = locationRoot(location);
     const bridgeUnsubscribes = new Map;
     let disposed = false;
@@ -49751,7 +50126,7 @@ function registerAftRpc(context, location, pool) {
     const emit = async (name, payload) => {
       if (disposed)
         return;
-      await Effect3.runPromise(registration.events.emit(name, payload));
+      await Effect4.runPromise(registration.events.emit(name, payload));
     };
     const publishStatus = (snapshot) => {
       const sessionID = sessionFromSnapshot(snapshot);
@@ -49765,21 +50140,21 @@ function registerAftRpc(context, location, pool) {
         return;
       bridgeUnsubscribes.set(bridge, bridge.subscribeStatus(publishStatus));
     };
-    const getStatus = (input) => Effect3.suspend(() => {
+    const getStatus = (input) => Effect4.suspend(() => {
       const sessionID = input.sessionID || "rpc";
       const bridge = pool.getActiveBridgeForRoot(root);
       if (!bridge)
-        return Effect3.succeed(placeholderStatus());
+        return Effect4.succeed(placeholderStatus());
       observeBridge(bridge);
       const cached = bridge.getCachedStatus();
       const cachedSessionID = cached ? sessionFromSnapshot(cached) : undefined;
       if (cached && cachedSessionID === sessionID) {
-        return Effect3.succeed({ success: true, ...cached });
+        return Effect4.succeed({ success: true, ...cached });
       }
-      return Effect3.tryPromise({
+      return Effect4.tryPromise({
         try: (signal) => bridge.send("status", { session_id: sessionID }, { abortSignal: signal }),
         catch: (error) => error
-      }).pipe(Effect3.tap((response) => Effect3.sync(() => {
+      }).pipe(Effect4.tap((response) => Effect4.sync(() => {
         if (response.success !== false)
           bridge.cacheStatusSnapshot(response);
       })));
@@ -49840,21 +50215,21 @@ function registerAftRpc(context, location, pool) {
         bridgeUnsubscribes.clear();
         restoreOwnProperty(pool, "getBridge", ownGetBridge);
         restoreOwnProperty(pool, "toolCall", ownToolCall);
-        await Effect3.runPromise(registration.dispose);
+        await Effect4.runPromise(registration.dispose);
       }
     };
   });
 }
 function registerAftConfigErrorRpc(context, message) {
-  return Effect3.gen(function* () {
+  return Effect4.gen(function* () {
     let disposed = false;
     const registration = yield* context.rpc.register(AftRpc, {
-      getStatus: () => Effect3.succeed(configErrorStatusSnapshot(message))
+      getStatus: () => Effect4.succeed(configErrorStatusSnapshot(message))
     });
     const emit = async (name, payload) => {
       if (disposed)
         return;
-      await Effect3.runPromise(registration.events.emit(name, payload));
+      await Effect4.runPromise(registration.events.emit(name, payload));
     };
     return {
       emitStatusInvalidated: (payload = {}) => emit("statusInvalidated", payload),
@@ -49864,14 +50239,14 @@ function registerAftConfigErrorRpc(context, message) {
         if (disposed)
           return;
         disposed = true;
-        await Effect3.runPromise(registration.dispose);
+        await Effect4.runPromise(registration.dispose);
       }
     };
   });
 }
 
 // src/permissions/v2.ts
-import { Effect as Effect4 } from "effect";
+import { Effect as Effect5 } from "effect";
 
 class PermissionDeniedError extends Error {
   name = "PermissionDeniedError";
@@ -49927,7 +50302,7 @@ function detail(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function runHostEffect(effect) {
-  return await Effect4.runPromise(effect);
+  return await Effect5.runPromise(effect);
 }
 async function sessionRecord(host, sessionID) {
   if (!sessionID)
@@ -49968,7 +50343,7 @@ function deniedMessage(request, decision) {
 }
 function promptUnavailableMessage(request, decision, observed) {
   const resource = decision.resource ?? "*";
-  return `The ${JSON.stringify(request.permission)} operation needs interactive approval: this ` + `session's permission rules resolve it to "ask" for ${JSON.stringify(resource)}, and AFT ` + `could not reach the OpenCode service to raise a prompt (${observed}). Start OpenCode's ` + "background service and retry, or run it without a prompt by adding " + `{"action": ${JSON.stringify(request.permission)}, "resource": ${JSON.stringify(resource)}, ` + '"effect": "allow"} to the "permissions" list of the agent or session in your OpenCode config.';
+  return `The ${JSON.stringify(request.permission)} operation needs interactive approval: this ` + `session's permission rules resolve it to "ask" for ${JSON.stringify(resource)}, and AFT ` + `could not reach the OpenCode service to raise a prompt (${observed}). Once the server is ` + "reachable, retry; or run it without a prompt by adding " + `{"action": ${JSON.stringify(request.permission)}, "resource": ${JSON.stringify(resource)}, ` + '"effect": "allow"} to the "permissions" list of the agent or session in your OpenCode config.';
 }
 function promptUnansweredMessage(request, decision, observed) {
   const resource = decision.resource ?? "*";
@@ -50176,6 +50551,9 @@ async function requestPermission(host, request, context, prompt, limits = {}) {
 }
 
 // src/permissions/v2-service.ts
+import { readdir, readFile as readFile3, readlink } from "node:fs/promises";
+import { homedir as homedir15 } from "node:os";
+import { join as join26 } from "node:path";
 init_promise();
 
 // ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-txckps9j.js
@@ -50183,26 +50561,6 @@ var stderrLimit = 8 * 1024;
 
 // ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-xgnj2w4v.js
 var timings = new WeakMap;
-var defaultEnsureTiming2 = {
-  pollInterval: 25,
-  requestTimeout: 2000,
-  spawnDelay: 5000,
-  maxSpawnDelay: 30000,
-  promiseTimeout: 120000,
-  stopPollInterval: 50,
-  stopPollAttempts: 100
-};
-
-// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-sxt88q69.js
-function matchesVersion2(version, options) {
-  if (options.version === undefined)
-    return true;
-  if (version === undefined)
-    return false;
-  if (typeof options.version === "function")
-    return options.version(version);
-  return version === options.version;
-}
 
 // ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-rg0h87gt.js
 init_service_9rqn6x4v();
@@ -50312,22 +50670,6 @@ function isHandoff(value) {
   return typeof value === "object" && value !== null && "directory" in value && typeof value.directory === "string" && "instanceID" in value && typeof value.instanceID === "string" && "ticket" in value && typeof value.ticket === "string" && "expiresAt" in value && typeof value.expiresAt === "number" && Number.isFinite(value.expiresAt);
 }
 // ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/promise/service.js
-import { readFile as readFile3, rm as rm3 } from "node:fs/promises";
-import { homedir as homedir15 } from "node:os";
-import { join as join26 } from "node:path";
-async function discover(options = {}) {
-  const found = (await registered(options.file)).service;
-  if (found?.state !== "ready")
-    return;
-  if (!found.compatible)
-    return;
-  if (!matchesVersion2(found.version, options))
-    return;
-  return found.endpoint;
-}
-function fallback() {
-  return join26(process.env["XDG_STATE_HOME"] ?? join26(homedir15(), ".local", "state"), "opencode", "service.json");
-}
 function headers(endpoint) {
   if (endpoint.auth === undefined)
     return;
@@ -50335,113 +50677,385 @@ function headers(endpoint) {
     authorization: "Basic " + Buffer.from(endpoint.auth.username + ":" + endpoint.auth.password).toString("base64")
   };
 }
-async function read2(file) {
-  const text = await readFile3(file ?? fallback(), "utf8").catch(() => {
-    return;
-  });
-  if (text === undefined)
+
+// src/permissions/v2-service.ts
+var OPENCODE_BASIC_AUTH_USERNAME = "opencode";
+var DEFAULT_PROBE_TIMEOUT_MS2 = 2000;
+var LISTEN_LOOKUP_TIMEOUT_MS = 5000;
+var HOW_TO_FIX = `set "opencode.server_url" in your user AFT config to this server's URL, with ` + '"opencode.server_password_env" naming the environment variable that holds its password ' + "(for OpenChamber, the host and port given as OPENCODE_HOST / OPENCODE_PORT), or start " + "OpenCode with OPENCODE_SERVER_PASSWORD set so AFT can authenticate to it";
+function detail2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function promptClient(endpoint) {
+  const client = exports_client.make({ baseUrl: endpoint.url, headers: headers(endpoint) });
+  return {
+    permission: {
+      create: (input) => client.permission.create(input)
+    },
+    event: {
+      subscribe: async () => ({ stream: client.event.subscribe() })
+    }
+  };
+}
+function basicAuth(password) {
+  if (!password)
     return;
+  return { type: "basic", username: OPENCODE_BASIC_AUTH_USERNAME, password };
+}
+function ownServerPassword(env) {
+  return env.OPENCODE_PASSWORD || env.OPENCODE_SERVER_PASSWORD || undefined;
+}
+async function probe(server, endpoint, timeoutMs) {
+  let response;
   try {
-    return JSON.parse(text);
+    response = await server.fetch(`${endpoint.url.replace(/\/+$/, "")}/api/info`, {
+      headers: headers(endpoint) ?? {},
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (error) {
+    return { kind: "failed", detail: detail2(error) };
+  }
+  if (response.status === 401 || response.status === 403) {
+    await response.body?.cancel().catch(() => {});
+    return { kind: "unauthorized", status: response.status };
+  }
+  if (!response.ok && response.status !== 503) {
+    await response.body?.cancel().catch(() => {});
+    return { kind: "failed", detail: `it answered HTTP ${response.status}` };
+  }
+  let body;
+  try {
+    body = await response.json();
   } catch {
-    return;
+    body = undefined;
   }
+  const pid = body?.pid;
+  if (typeof pid === "number" && Number.isInteger(pid))
+    return { kind: "answered", pid };
+  return response.ok ? { kind: "answered" } : { kind: "failed", detail: `it answered HTTP ${response.status}` };
 }
-async function probeResult(info, timeout = defaultEnsureTiming2.requestTimeout) {
+async function configuredServer(settings, server, timeoutMs) {
+  const raw = settings.server_url.trim();
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return {
+      reason: "server_url_invalid",
+      unavailable: `"opencode.server_url" ${JSON.stringify(raw)} in your AFT config is not a URL; set it to the server's base URL, for example "http://127.0.0.1:4096"`
+    };
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password) {
+    return {
+      reason: "server_url_invalid",
+      unavailable: `"opencode.server_url" ${JSON.stringify(raw)} must be an http(s) URL without credentials; ` + 'put the password in an environment variable and name it in "opencode.server_password_env"'
+    };
+  }
+  const variable = settings.server_password_env?.trim();
+  let password;
+  if (variable) {
+    password = server.env[variable] || undefined;
+    if (!password) {
+      return {
+        reason: "server_url_invalid",
+        unavailable: `the environment variable ${variable} named by "opencode.server_password_env" is not ` + "set in the OpenCode process; set it to the server's password and restart OpenCode"
+      };
+    }
+  } else {
+    password = ownServerPassword(server.env);
+  }
   const endpoint = {
-    url: info.url,
-    auth: info.password === undefined ? undefined : { type: "basic", username: "opencode", password: info.password }
-  };
-  const signal = AbortSignal.timeout(timeout);
-  const result = await fetch(new URL("/api/info", info.url), { headers: headers(endpoint), signal }).then(async (response) => ({
-    response,
-    body: response.status === 404 ? undefined : await response.json()
-  })).then((value) => ({ value }), (cause) => ({ cause }));
-  if ("cause" in result)
-    return { service: undefined, timedOut: signal.aborted };
-  const response = result.value.response;
-  if (response.status === 404)
+    url: url.href.replace(/\/+$/, ""),
+    auth: basicAuth(password)
+  };
+  const result = await probe(server, endpoint, timeoutMs);
+  if (result.kind === "unauthorized") {
     return {
-      service: {
-        info,
-        endpoint,
-        version: info.version,
-        state: "ready",
-        compatible: false
-      },
-      timedOut: false
+      reason: "server_url_unreachable",
+      unavailable: `the server at "opencode.server_url" ${endpoint.url} refused AFT's credentials ` + `(HTTP ${result.status}); set "opencode.server_password_env" to the name of the ` + "environment variable holding that server's password"
     };
-  const serverInfo = decodeInfo(result.value.body);
-  if (serverInfo !== undefined) {
-    if (serverInfo.pid !== info.pid)
-      return { service: undefined, timedOut: false };
-    if (info.version !== undefined && serverInfo.version !== info.version)
-      return { service: undefined, timedOut: false };
+  }
+  if (result.kind === "failed") {
     return {
-      service: {
-        info,
-        endpoint,
-        version: serverInfo.version,
-        state: response.ok ? "ready" : response.status === 500 ? "failed" : "waiting",
-        compatible: true
-      },
-      timedOut: false
+      reason: "server_url_unreachable",
+      unavailable: `the server at "opencode.server_url" ${endpoint.url} did not answer (${result.detail})`
     };
   }
-  return { service: undefined, timedOut: false };
+  if (result.pid !== undefined && result.pid !== server.pid) {
+    warn2(`[permissions] opencode.server_url ${endpoint.url} is served by process ${result.pid}, not ` + `by this OpenCode process (${server.pid}); permission prompts are raised there`);
+  }
+  return { client: promptClient(endpoint) };
 }
-function decodeInfo(input) {
-  if (typeof input !== "object" || input === null)
-    return;
-  if (!("version" in input) || typeof input.version !== "string")
-    return;
-  if (!("pid" in input) || typeof input.pid !== "number" || !Number.isInteger(input.pid) || input.pid < 0)
+function flagValue(argv, name) {
+  let value;
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === `--${name}`)
+      value = argv[index + 1];
+    else if (arg?.startsWith(`--${name}=`))
+      value = arg.slice(name.length + 3);
+  }
+  return value;
+}
+function ownListenAddress(argv) {
+  const rawHost = flagValue(argv, "hostname")?.trim();
+  let hostname = rawHost ? rawHost.replace(/^\[(.*)\]$/, "$1") : "127.0.0.1";
+  if (hostname === "0.0.0.0")
+    hostname = "127.0.0.1";
+  if (hostname === "::")
+    hostname = "::1";
+  const rawPort = flagValue(argv, "port")?.trim();
+  const parsed = rawPort !== undefined && /^\d+$/.test(rawPort) ? Number(rawPort) : undefined;
+  const port = parsed !== undefined && parsed <= 65535 ? parsed : undefined;
+  return { hostname, port, stdio: argv.includes("--stdio") };
+}
+function serverURL(hostname, port) {
+  return `http://${hostname.includes(":") ? `[${hostname}]` : hostname}:${port}`;
+}
+async function ownRegistration(server, timeoutMs, observed) {
+  let registrations;
+  try {
+    registrations = await server.registrations();
+  } catch (error) {
+    observed.push(`reading OpenCode service registrations failed: ${detail2(error)}`);
     return;
-  return { version: input.version, pid: input.pid };
+  }
+  for (const registration of registrations) {
+    let info;
+    try {
+      info = JSON.parse(registration.text);
+    } catch {
+      continue;
+    }
+    if (typeof info?.url !== "string" || typeof info.pid !== "number")
+      continue;
+    if (info.pid !== server.pid) {
+      observed.push(`the service registered in ${registration.path} is process ${info.pid}, not this one (${server.pid}), so it was not used`);
+      continue;
+    }
+    const endpoint = {
+      url: info.url.replace(/\/+$/, ""),
+      auth: basicAuth(typeof info.password === "string" ? info.password : undefined)
+    };
+    const result = await probe(server, endpoint, timeoutMs);
+    if (result.kind === "answered" && result.pid === server.pid) {
+      return { client: promptClient(endpoint) };
+    }
+    observed.push(`this process's own registration ${registration.path} did not verify at ${endpoint.url}`);
+  }
+  return;
 }
-async function registered(file, timeout) {
-  const info = await read2(file);
-  if (info === undefined)
-    return { info: undefined, service: undefined, timedOut: false };
-  return { info, ...await probeResult(info, timeout) };
+function reachableHost(address) {
+  const host = address.replace(/^\[(.*)\]$/, "$1");
+  if (host === "*" || host === "0.0.0.0" || host === "")
+    return "127.0.0.1";
+  if (/^[0:]+$/.test(host))
+    return "::1";
+  return host;
+}
+async function ownCandidates(server, listen, observed) {
+  const declared = listen.port !== undefined && listen.port !== 0 ? listen.port : undefined;
+  let sockets;
+  try {
+    sockets = await server.listeningSockets();
+  } catch (error) {
+    const failure = `looking up the ports this process (${server.pid}) listens on failed: ${detail2(error)}`;
+    if (declared === undefined) {
+      observed.push(`${failure}, and its command line names no --port`);
+      return;
+    }
+    return [serverURL(listen.hostname, declared)];
+  }
+  const own = declared === undefined ? sockets : sockets.filter((socket) => socket.port === declared);
+  if (own.length === 0) {
+    const found = sockets.map((socket) => socket.port).join(", ") || "none";
+    observed.push(declared === undefined ? `this process (${server.pid}) listens on no TCP port` : `--port ${declared} is not one of the ports this process (${server.pid}) listens on (${found})`);
+    return;
+  }
+  return [...new Set(own.map((socket) => serverURL(reachableHost(socket.address), socket.port)))];
+}
+async function ownServer(server, options) {
+  const observed = [];
+  const registered = await ownRegistration(server, options.timeoutMs, observed);
+  if (registered)
+    return registered;
+  const unaddressable = () => ({
+    reason: "own_server_unaddressable",
+    unavailable: `AFT could not find the OpenCode server it runs in (${observed.join("; ")}); to fix it, ${HOW_TO_FIX}`
+  });
+  const listen = ownListenAddress(server.argv);
+  const password = ownServerPassword(server.env);
+  if (listen.stdio) {
+    observed.push("this is a private server (opencode --standalone) whose password is not readable by plugins");
+    return unaddressable();
+  }
+  if (!password) {
+    observed.push("this server was started without OPENCODE_SERVER_PASSWORD, so it generated a password AFT cannot read");
+    return unaddressable();
+  }
+  const candidates = await ownCandidates(server, listen, observed);
+  if (!candidates)
+    return unaddressable();
+  let refused = 0;
+  let others = 0;
+  for (const url of candidates) {
+    const endpoint = { url, auth: basicAuth(password) };
+    const result = await probe(server, endpoint, options.timeoutMs);
+    if (result.kind === "answered" && result.pid === server.pid) {
+      return { client: promptClient(endpoint) };
+    }
+    if (result.kind === "unauthorized")
+      refused += 1;
+    if (result.kind === "answered")
+      others += 1;
+  }
+  observed.push(`none of ${candidates.join(", ")} answered as this process (${server.pid})` + (refused > 0 ? `; ${refused} refused the password from OPENCODE_SERVER_PASSWORD` : "") + (others > 0 ? `; ${others} belonged to another process` : ""));
+  return unaddressable();
+}
+async function discoverPromptServer(settings, server = currentServerProcess(), options = {}) {
+  const resolved = {
+    timeoutMs: options.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS2
+  };
+  const serverUrl = settings?.server_url;
+  if (serverUrl !== undefined && serverUrl.trim() !== "") {
+    return await configuredServer({ ...settings, server_url: serverUrl }, server, resolved.timeoutMs);
+  }
+  return await ownServer(server, resolved);
 }
-
-// src/permissions/v2-service.ts
-function detail2(error) {
-  return error instanceof Error ? error.message : String(error);
+function registrationDirectory(env) {
+  return join26(env.XDG_STATE_HOME || join26(homedir15(), ".local", "state"), "opencode");
 }
-function promptClient(endpoint) {
-  const client = exports_client.make({ baseUrl: endpoint.url, headers: headers(endpoint) });
+function currentServerProcess() {
+  const env = globalThis.process.env;
   return {
-    permission: {
-      create: (input) => client.permission.create(input)
+    pid: globalThis.process.pid,
+    argv: globalThis.process.argv,
+    env,
+    async registrations() {
+      const directory = registrationDirectory(env);
+      const names = await readdir(directory).catch(() => []);
+      const files = names.filter((name) => /^service(-[^/\\]+)?\.json$/.test(name)).sort();
+      const read = await Promise.all(files.map(async (name) => {
+        const path = join26(directory, name);
+        const text = await readFile3(path, "utf8").catch(() => {
+          return;
+        });
+        return text === undefined ? undefined : { path, text };
+      }));
+      return read.filter((entry) => entry !== undefined);
     },
-    event: {
-      subscribe: async () => ({ stream: client.event.subscribe() })
-    }
+    listeningSockets: () => listeningSocketsOf(globalThis.process.pid),
+    fetch: (url, init) => fetch(url, init)
   };
 }
-async function discoverPromptClient() {
-  let endpoint;
+function runCommand(file, args) {
+  return new Promise((resolve, reject) => {
+    execFile(file, [...args], { timeout: LISTEN_LOOKUP_TIMEOUT_MS, maxBuffer: 8 * 1024 * 1024, encoding: "utf8" }, (error, stdout) => {
+      const code = error?.code;
+      if (error && !(code === 1 && file === "lsof"))
+        reject(error);
+      else
+        resolve(String(stdout ?? ""));
+    });
+  });
+}
+function splitHostPort(value) {
+  const separator = value.lastIndexOf(":");
+  if (separator < 0)
+    return;
+  const port = Number(value.slice(separator + 1));
+  if (!Number.isInteger(port) || port <= 0 || port > 65535)
+    return;
+  return { address: value.slice(0, separator).replace(/^\[(.*)\]$/, "$1"), port };
+}
+function parseLsofListening(output) {
+  return output.split(/\r?\n/).filter((line) => line.startsWith("n")).map((line) => splitHostPort(line.slice(1))).filter((socket) => socket !== undefined);
+}
+function parseNetstatListening(output, pid) {
+  const sockets = [];
+  for (const line of output.split(/\r?\n/)) {
+    const columns = line.trim().split(/\s+/);
+    if (columns.length < 5 || !columns[0]?.toUpperCase().startsWith("TCP"))
+      continue;
+    if (Number(columns[columns.length - 1]) !== pid)
+      continue;
+    if (!/:0$/.test(columns[2] ?? ""))
+      continue;
+    const socket = splitHostPort(columns[1] ?? "");
+    if (socket)
+      sockets.push(socket);
+  }
+  return sockets;
+}
+function procAddress(hex) {
+  const bytes = [];
+  for (let word = 0;word < hex.length; word += 8) {
+    const chunk = hex.slice(word, word + 8);
+    for (let index = 6;index >= 0; index -= 2) {
+      bytes.push(Number.parseInt(chunk.slice(index, index + 2), 16));
+    }
+  }
+  if (bytes.length === 4)
+    return bytes.join(".");
+  const groups = [];
+  for (let index = 0;index < bytes.length; index += 2) {
+    groups.push(((bytes[index] ?? 0) << 8 | (bytes[index + 1] ?? 0)).toString(16));
+  }
+  return groups.join(":");
+}
+function parseProcNetListening(table, inodes) {
+  const sockets = [];
+  for (const line of table.split(/\r?\n/).slice(1)) {
+    const columns = line.trim().split(/\s+/);
+    if (columns[3] !== "0A" || !inodes.has(columns[9] ?? ""))
+      continue;
+    const [address, port] = (columns[1] ?? "").split(":");
+    if (!address || !port)
+      continue;
+    sockets.push({ address: procAddress(address), port: Number.parseInt(port, 16) });
+  }
+  return sockets;
+}
+async function procListening(pid) {
+  const descriptors = await readdir(`/proc/${pid}/fd`);
+  const inodes = new Set;
+  await Promise.all(descriptors.map(async (fd) => {
+    const target = await readlink(`/proc/${pid}/fd/${fd}`).catch(() => "");
+    const inode = /^socket:\[(\d+)\]$/.exec(target)?.[1];
+    if (inode)
+      inodes.add(inode);
+  }));
+  const tables = await Promise.all(["/proc/net/tcp", "/proc/net/tcp6"].map((path) => readFile3(path, "utf8").catch(() => "")));
+  return tables.flatMap((table) => parseProcNetListening(table, inodes));
+}
+async function listeningSocketsOf(pid) {
+  if (globalThis.process.platform === "win32") {
+    return parseNetstatListening(await runCommand("netstat", ["-ano", "-p", "TCP"]), pid).concat(parseNetstatListening(await runCommand("netstat", ["-ano", "-p", "TCPv6"]), pid));
+  }
   try {
-    endpoint = await discover();
+    return parseLsofListening(await runCommand("lsof", ["-nP", "-a", "-p", String(pid), "-iTCP", "-sTCP:LISTEN", "-Fn"]));
   } catch (error) {
-    return { unavailable: `looking up the local OpenCode service failed: ${detail2(error)}` };
-  }
-  if (!endpoint) {
-    return { unavailable: "no healthy, compatible local OpenCode service is registered" };
+    const missing = error.code === "ENOENT";
+    if (!missing || globalThis.process.platform !== "linux")
+      throw error;
+    return await procListening(pid);
   }
-  return { client: promptClient(endpoint) };
 }
-function createV2PromptChannel(discovery = discoverPromptClient) {
+function createV2PromptChannel(discovery = () => discoverPromptServer(undefined)) {
   let cached;
+  let failureLogged = false;
   return {
     async client() {
       if (cached)
         return { client: cached };
       const result = await discovery();
-      if (result.client)
+      if (result.client) {
         cached = result.client;
+        log2("[permissions] OpenCode server for permission prompts found");
+      } else if (!failureLogged) {
+        failureLogged = true;
+        warn2(`[permissions] permission prompts are unavailable${result.reason ? ` (${result.reason})` : ""}: ${result.unavailable}`);
+      }
       return result;
     }
   };
@@ -50461,9 +51075,149 @@ function hoistedV2ToolConsumers(host, prompt = createV2PromptChannel()) {
     requestPermission: (request, context) => requestPermission(host, request, context, prompt)
   };
 }
+function v2PromptChannelFor(settings) {
+  return createV2PromptChannel(() => discoverPromptServer(settings));
+}
 
-// src/wakes/runtime-consumer.ts
+// src/v2-prompt-detach.ts
+import { Effect as Effect7 } from "effect";
+
+// src/wakes/session-delivery.ts
 import { Effect as Effect6 } from "effect";
+var AFT_PROMPT_SOURCE = "aft";
+function isAftOriginatedPrompt(metadata) {
+  return typeof metadata === "object" && metadata !== null && metadata.source === AFT_PROMPT_SOURCE;
+}
+
+class V2SessionDelivery {
+  session;
+  admittedCompletions = new Set;
+  disposed = false;
+  constructor(session) {
+    this.session = session;
+  }
+  completion(input) {
+    return Effect6.suspend(() => {
+      if (this.disposed)
+        return Effect6.succeed(false);
+      const keys = [...new Set(input.taskIDs)].map((taskID) => `${input.sessionID}\x00${taskID}`);
+      if (keys.length === 0 || keys.every((key) => this.admittedCompletions.has(key))) {
+        return Effect6.succeed(false);
+      }
+      for (const key of keys)
+        this.admittedCompletions.add(key);
+      return this.session.prompt({
+        sessionID: input.sessionID,
+        text: input.text,
+        delivery: "steer",
+        metadata: {
+          ...input.metadata,
+          source: AFT_PROMPT_SOURCE,
+          task_ids: [...new Set(input.taskIDs)]
+        }
+      }).pipe(Effect6.map(() => true));
+    });
+  }
+  status(input) {
+    return Effect6.suspend(() => {
+      if (this.disposed)
+        return Effect6.succeed(undefined);
+      return this.session.synthetic({
+        sessionID: input.sessionID,
+        text: input.text,
+        description: input.description,
+        metadata: input.metadata,
+        resume: false
+      }).pipe(Effect6.asVoid);
+    });
+  }
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    this.admittedCompletions.clear();
+  }
+}
+
+// src/v2-prompt-detach.ts
+function mapOffset(offset, edits) {
+  let shift = 0;
+  for (const edit of edits) {
+    if (offset <= edit.start)
+      break;
+    if (offset >= edit.end) {
+      shift += edit.length - (edit.end - edit.start);
+      continue;
+    }
+    return edit.start + shift + Math.min(offset - edit.start, edit.length);
+  }
+  return offset + shift;
+}
+function offsetMapper(original, finalText) {
+  const tokenEdits = standaloneDetachKeywordRanges(original).map(([start, end]) => ({
+    start,
+    end,
+    length: 0
+  }));
+  const withoutTokens = stripStandaloneDetachKeywords(original);
+  const whitespaceEdits = [...withoutTokens.matchAll(/[ \t]{2,}/g)].map((match) => ({
+    start: match.index ?? 0,
+    end: (match.index ?? 0) + match[0].length,
+    length: 1
+  }));
+  return (offset) => Math.min(mapOffset(mapOffset(offset, tokenEdits), whitespaceEdits), finalText.length);
+}
+function mentionCarriers(prompt) {
+  return [...prompt.files ?? [], ...prompt.agents ?? [], ...prompt.skills ?? []].filter((item) => typeof item?.mention?.start === "number" && typeof item.mention.end === "number");
+}
+function interruptBashWaitsForV2Prompt(runtime, event) {
+  const prompt = event.prompt;
+  const original = prompt.text;
+  const synthetic = isAftOriginatedPrompt(event.metadata);
+  const output = { parts: [{ type: "text", text: original, synthetic }] };
+  const interrupted = interruptBashWaitsForChatMessage(runtime.pool, runtime.getConfig(), runtime.projectRoot, event.sessionID, output);
+  const finalText = output.parts[0]?.text ?? original;
+  if (synthetic || finalText === original)
+    return interrupted;
+  const map = offsetMapper(original, finalText);
+  const moved = mentionCarriers(prompt).map((item) => {
+    const mention = item.mention;
+    return { item, mention: { ...mention, start: map(mention.start), end: map(mention.end) } };
+  });
+  prompt.text = finalText;
+  for (const { item, mention } of moved)
+    item.mention = mention;
+  return interrupted;
+}
+function failureReason(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createV2PromptDetachHook(runtime) {
+  const loggedReasons = new Set;
+  return (event) => Effect7.sync(() => {
+    try {
+      interruptBashWaitsForV2Prompt(runtime, event);
+    } catch (error) {
+      const reason = failureReason(error);
+      if (loggedReasons.has(reason))
+        return;
+      loggedReasons.add(reason);
+      warn2(`[bash_wait_detach] prompt hook failed for session ${String(event?.sessionID)}; the prompt passes through unchanged: ${reason}`);
+    }
+  });
+}
+function registerV2PromptDetachHook(context, runtime) {
+  const session = context?.session;
+  const hook = session?.hook;
+  if (typeof hook !== "function") {
+    warn2("[bash_wait_detach] host has no session prompt hook; a new message cannot detach a waiting bash here");
+    return Effect7.succeed(false);
+  }
+  return hook.call(session, "prompt", createV2PromptDetachHook(runtime)).pipe(Effect7.as(true));
+}
+
+// src/wakes/runtime-consumer.ts
+import { Effect as Effect8 } from "effect";
 
 // src/cancellation/effect-abort.ts
 function forwardEffectAbort(signal, send) {
@@ -50511,96 +51265,64 @@ async function executeV2Bash(execution) {
   }
 }
 
-// src/wakes/session-delivery.ts
-import { Effect as Effect5 } from "effect";
-
-class V2SessionDelivery {
-  session;
-  admittedCompletions = new Set;
-  disposed = false;
-  constructor(session) {
-    this.session = session;
-  }
-  completion(input) {
-    return Effect5.suspend(() => {
-      if (this.disposed)
-        return Effect5.succeed(false);
-      const keys = [...new Set(input.taskIDs)].map((taskID) => `${input.sessionID}\x00${taskID}`);
-      if (keys.length === 0 || keys.every((key) => this.admittedCompletions.has(key))) {
-        return Effect5.succeed(false);
-      }
-      for (const key of keys)
-        this.admittedCompletions.add(key);
-      return this.session.prompt({
-        sessionID: input.sessionID,
-        text: input.text,
-        delivery: "steer",
-        metadata: {
-          ...input.metadata,
-          task_ids: [...new Set(input.taskIDs)]
-        }
-      }).pipe(Effect5.map(() => true));
-    });
-  }
-  status(input) {
-    return Effect5.suspend(() => {
-      if (this.disposed)
-        return Effect5.succeed(undefined);
-      return this.session.synthetic({
-        sessionID: input.sessionID,
-        text: input.text,
-        description: input.description,
-        metadata: input.metadata,
-        resume: false
-      }).pipe(Effect5.asVoid);
-    });
-  }
-  dispose() {
-    if (this.disposed)
-      return;
-    this.disposed = true;
-    this.admittedCompletions.clear();
-  }
-}
-
 // src/wakes/runtime-consumer.ts
-var sessionRoutes = new Map;
-async function routeCompletion(completion, bridge) {
-  const route = sessionRoutes.get(completion.session_id);
-  if (!route)
-    return;
-  const admitted = await Effect6.runPromise(route.delivery.completion({
-    sessionID: completion.session_id,
-    taskIDs: [completion.task_id],
-    text: formatSystemReminder([completion]),
-    metadata: {
-      source: "aft",
-      kind: "bash_completion",
-      task_ids: [completion.task_id],
-      status: completion.status
-    }
-  }));
-  if (!admitted)
+var WAKE_ROUTE_STATE = Symbol.for("@cortexkit/aft-opencode/wake-routes/v1");
+function wakeRouteState() {
+  const host = globalThis;
+  return host[WAKE_ROUTE_STATE] ??= {
+    routes: new Map,
+    unrouted: new Map,
+    warnedUnrouted: new Set
+  };
+}
+var MAX_UNROUTED_COMPLETIONS = 256;
+function holdUnrouted(completion, bridge) {
+  const { unrouted } = wakeRouteState();
+  let held = 0;
+  for (const tasks of unrouted.values())
+    held += tasks.size;
+  const sessionTasks = unrouted.get(completion.session_id);
+  if (!sessionTasks?.has(completion.task_id) && held >= MAX_UNROUTED_COMPLETIONS) {
+    const oldest = unrouted.keys().next();
+    if (!oldest.done)
+      unrouted.delete(oldest.value);
+  }
+  const tasks = unrouted.get(completion.session_id) ?? new Map;
+  tasks.set(completion.task_id, { completion, bridge });
+  unrouted.set(completion.session_id, tasks);
+}
+function warnUnroutedOnce(sessionID, message) {
+  const { warnedUnrouted } = wakeRouteState();
+  if (warnedUnrouted.has(sessionID))
     return;
-  await bridge.send("bash_ack_completions", {
-    session_id: completion.session_id,
-    task_ids: [completion.task_id]
-  });
+  warnedUnrouted.add(sessionID);
+  warn2(message);
+}
+async function routeCompletion(completion, bridge) {
+  const route = wakeRouteState().routes.get(completion.session_id);
+  if (route)
+    return route.completion(completion, bridge);
+  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`);
 }
 async function routeLongRunning(reminder, _bridge) {
-  const route = sessionRoutes.get(reminder.session_id);
-  if (!route)
+  const route = wakeRouteState().routes.get(reminder.session_id);
+  if (route)
+    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, route) {
+  const state = wakeRouteState();
+  state.warnedUnrouted.delete(sessionID);
+  const held = state.unrouted.get(sessionID);
+  if (!held)
     return;
-  await Effect6.runPromise(route.delivery.status({
-    sessionID: reminder.session_id,
-    text: formatLongRunningReminder([reminder]),
-    description: "Background bash status",
-    metadata: {
-      source: "aft",
-      kind: "bash_long_running",
-      task_id: reminder.task_id
-    }
-  }));
+  state.unrouted.delete(sessionID);
+  for (const { completion, bridge } of held.values()) {
+    route.completion(completion, bridge).catch((error) => {
+      warn2(`[bash_completion] late delivery of task ${completion.task_id} to session ${sessionID} failed: ${error instanceof Error ? error.message : String(error)}`);
+    });
+  }
 }
 var sharedBridgeOptions = {
   onBashCompletion: routeCompletion,
@@ -50608,12 +51330,47 @@ var sharedBridgeOptions = {
 };
 function createV2RuntimeConsumer(context) {
   const delivery = new V2SessionDelivery(context.session);
-  const route = { delivery, sessions: new Set };
+  const sessions = new Set;
+  const route = {
+    completion: async (completion, bridge) => {
+      const admitted = await Effect8.runPromise(delivery.completion({
+        sessionID: completion.session_id,
+        taskIDs: [completion.task_id],
+        text: formatSystemReminder([completion]),
+        metadata: {
+          source: "aft",
+          kind: "bash_completion",
+          task_ids: [completion.task_id],
+          status: completion.status
+        }
+      }));
+      if (!admitted)
+        return;
+      await bridge.send("bash_ack_completions", {
+        session_id: completion.session_id,
+        task_ids: [completion.task_id]
+      });
+    },
+    longRunning: (reminder) => Effect8.runPromise(delivery.status({
+      sessionID: reminder.session_id,
+      text: formatLongRunningReminder([reminder]),
+      description: "Background bash status",
+      metadata: {
+        source: "aft",
+        kind: "bash_long_running",
+        task_id: reminder.task_id
+      }
+    }))
+  };
   const registerSession = (sessionID) => {
     if (!sessionID)
       return;
-    route.sessions.add(sessionID);
-    sessionRoutes.set(sessionID, route);
+    sessions.add(sessionID);
+    const { routes } = wakeRouteState();
+    if (routes.get(sessionID) === route)
+      return;
+    routes.set(sessionID, route);
+    deliverUnrouted(sessionID, route);
   };
   return {
     bridgeOptions: sharedBridgeOptions,
@@ -50623,11 +51380,12 @@ function createV2RuntimeConsumer(context) {
     },
     dispose: () => {
       delivery.dispose();
-      for (const sessionID of route.sessions) {
-        if (sessionRoutes.get(sessionID) === route)
-          sessionRoutes.delete(sessionID);
+      const { routes } = wakeRouteState();
+      for (const sessionID of sessions) {
+        if (routes.get(sessionID) === route)
+          routes.delete(sessionID);
       }
-      route.sessions.clear();
+      sessions.clear();
     }
   };
 }
@@ -50639,8 +51397,9 @@ var defaults = {
   registerTools: registerAftTools,
   registerRpc: registerAftRpc,
   registerConfigErrorRpc: registerAftConfigErrorRpc,
-  toolConsumers: (context) => ({
-    ...hoistedV2ToolConsumers(context),
+  registerPromptHook: registerV2PromptDetachHook,
+  toolConsumers: (context, config) => ({
+    ...hoistedV2ToolConsumers(context, v2PromptChannelFor(config?.opencode)),
     ...createV2RuntimeConsumer(context)
   }),
   acquireBridge,
@@ -50666,7 +51425,7 @@ async function bootLocation(context, location, dependencies) {
   const pluginVersion = dependencies.resolveVersion();
   const environment = await prepareBridgeEnvironment({ configRoot: directory, lspDirectory: directory, config, pluginVersion, notify }, dependencies);
   const canonicalDirectory = location.project?.canonical ?? directory;
-  const consumers = dependencies.toolConsumers(context);
+  const consumers = dependencies.toolConsumers(context, config);
   const isProjectEnabled = createProjectAcceptance(directory, dependencies);
   const pool = await dependencies.acquireBridge(canonicalDirectory, {
     harness: "opencode",
@@ -50709,7 +51468,7 @@ async function bootLocation(context, location, dependencies) {
     },
     notify
   });
-  return { consumers, pool, tools, liveConfigReload };
+  return { consumers, pool, tools, liveConfigReload, toolContext, directory };
 }
 var runningByDirectory = new Map;
 var startsInProcess = 0;
@@ -50736,27 +51495,32 @@ function makeServerEffect(overrides = {}) {
     const location = context.location;
     if (typeof location?.directory !== "string") {
       debug2("V2 effect skipped: host context has no location");
-      return Effect7.void;
+      return Effect9.void;
     }
-    return Effect7.gen(function* () {
+    return Effect9.gen(function* () {
       const logRuntimeStop = logRuntimeStart(location);
-      yield* Effect7.addFinalizer(() => Effect7.sync(logRuntimeStop));
-      const runtime = yield* Effect7.promise(() => bootLocation(context, location, dependencies));
+      yield* Effect9.addFinalizer(() => Effect9.sync(logRuntimeStop));
+      const runtime = yield* Effect9.promise(() => bootLocation(context, location, dependencies));
       if (!runtime)
         return;
       if (runtime.configError !== undefined) {
         const rpc = yield* dependencies.registerConfigErrorRpc(context, runtime.configError);
-        yield* Effect7.addFinalizer(() => Effect7.promise(() => rpc.dispose()));
+        yield* Effect9.addFinalizer(() => Effect9.promise(() => rpc.dispose()));
         yield* dependencies.registerTools(context, location, runtime.tools, runtime.consumers);
         return;
       }
-      yield* Effect7.addFinalizer(() => Effect7.promise(async () => {
+      yield* Effect9.addFinalizer(() => Effect9.promise(async () => {
         runtime.liveConfigReload?.stop();
         runtime.consumers.dispose?.();
         await dependencies.releaseBridge(runtime.pool);
       }));
       const rpc = yield* dependencies.registerRpc(context, location, runtime.pool);
-      yield* Effect7.addFinalizer(() => Effect7.promise(() => rpc.dispose()));
+      yield* Effect9.addFinalizer(() => Effect9.promise(() => rpc.dispose()));
+      yield* dependencies.registerPromptHook(context, {
+        pool: runtime.pool,
+        projectRoot: runtime.directory,
+        getConfig: () => runtime.toolContext.config
+      });
       yield* dependencies.registerTools(context, location, runtime.tools, runtime.consumers);
     });
   };