@cortexkit/aft-opencode 0.19.5 → 0.20.0

package/dist/index.js

@@ -7803,10 +7803,10 @@ var require_src2 = __commonJS((exports, module) => {
 });
 
 // src/index.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync11, readFileSync as readFileSync10, writeFileSync as writeFileSync11 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { homedir as homedir11 } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // ../aft-bridge/dist/active-logger.js
 var active;
@@ -7942,6 +7942,7 @@ class BinaryBridge {
   onVersionMismatch;
   onConfigureWarnings;
   onBashCompletion;
+  onBashLongRunning;
   configureWarningClients = new Map;
   restartResetTimer = null;
   errorPrefix;
@@ -7955,6 +7956,7 @@ class BinaryBridge {
     this.onVersionMismatch = options?.onVersionMismatch;
     this.onConfigureWarnings = options?.onConfigureWarnings;
     this.onBashCompletion = options?.onBashCompletion;
+    this.onBashLongRunning = options?.onBashLongRunning;
     this.errorPrefix = options?.errorPrefix ?? "[aft-bridge]";
   }
   get restartCount() {
@@ -8267,6 +8269,10 @@ class BinaryBridge {
           this.onBashCompletion?.(response, this);
           continue;
         }
+        if (response.type === "bash_long_running") {
+          this.onBashLongRunning?.(response, this);
+          continue;
+        }
         if (response.type === "configure_warnings") {
           this.handleConfigureWarningsFrame(response).catch((err) => {
             warn(`configure warning delivery failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -9091,7 +9097,8 @@ class BridgePool {
       minVersion: options.minVersion,
       onVersionMismatch: options.onVersionMismatch,
       onConfigureWarnings: options.onConfigureWarnings,
-      onBashCompletion: options.onBashCompletion
+      onBashCompletion: options.onBashCompletion,
+      onBashLongRunning: options.onBashLongRunning
     };
     this.configOverrides = configOverrides;
     if (Number.isFinite(this.idleTimeoutMs)) {
@@ -9905,20 +9912,26 @@ async function handlePushedBgCompletion(drainContext, completion) {
   ingestBgCompletions(drainContext.sessionID, [completion]);
   await triggerWakeIfPending(drainContext, true);
 }
+async function handlePushedBgLongRunning(drainContext, reminder) {
+  stateFor(drainContext.sessionID).pendingLongRunning.push(reminder);
+  await triggerWakeIfPending(drainContext, true);
+}
 async function appendInTurnBgCompletions(drainContext, output) {
   if (!output)
     return;
   const state = stateFor(drainContext.sessionID);
-  if (state.outstandingTaskIds.size === 0 && state.pendingCompletions.length === 0)
+  if (state.outstandingTaskIds.size === 0 && state.pendingCompletions.length === 0 && state.pendingLongRunning.length === 0) {
     return;
+  }
   if (state.outstandingTaskIds.size > 0) {
     await drainCompletions(drainContext);
   }
-  if (state.pendingCompletions.length === 0)
+  if (state.pendingCompletions.length === 0 && state.pendingLongRunning.length === 0)
     return;
-  const reminder = formatSystemReminder(state.pendingCompletions);
+  const reminder = formatCombinedSystemReminder(state.pendingCompletions, state.pendingLongRunning);
   output.output = appendReminder(output.output ?? "", reminder);
   state.pendingCompletions = [];
+  state.pendingLongRunning = [];
 }
 async function handleIdleBgCompletions(drainContext) {
   await triggerWakeIfPending(drainContext, false);
@@ -9930,7 +9943,7 @@ async function triggerWakeIfPending(drainContext, skipDrain) {
   if (!skipDrain && state.outstandingTaskIds.size > 0) {
     await drainCompletions(drainContext);
   }
-  if (state.pendingCompletions.length === 0)
+  if (state.pendingCompletions.length === 0 && state.pendingLongRunning.length === 0)
     return;
   scheduleWake(state, async (reminder) => {
     const client = drainContext.client;
@@ -9975,6 +9988,23 @@ For truncated tasks, use bash_status({ taskId: "..." }) to retrieve full output.
 ${bullets}${tail}
 </system-reminder>`;
 }
+function formatLongRunningReminder(reminders) {
+  const bullets = reminders.map((reminder) => `- ${reminder.task_id} still running after ${formatDurationMs(reminder.elapsed_ms)}: ${shorten(reminder.command, 120)}`).join(`
+`);
+  return `<system-reminder>
+[BACKGROUND BASH STILL RUNNING]
+${bullets}
+Use bash_status({ taskId: "..." }) to inspect output or bash_kill({ taskId: "..." }) to terminate.
+</system-reminder>`;
+}
+function formatCombinedSystemReminder(completions, longRunning) {
+  if (completions.length === 0)
+    return formatLongRunningReminder(longRunning);
+  if (longRunning.length === 0)
+    return formatSystemReminder(completions);
+  return `${formatSystemReminder(completions)}
+${formatLongRunningReminder(longRunning)}`;
+}
 function extractSessionID(value) {
   if (!value || typeof value !== "object")
     return;
@@ -10008,7 +10038,8 @@ async function drainCompletions({ ctx, directory, sessionID }) {
 }
 function scheduleWake(state, sendWake, onSendFailure) {
   const now = Date.now();
-  if (state.debounceTimer && state.pendingCompletions.length <= state.scheduledCompletionCount) {
+  const pendingCount = state.pendingCompletions.length + state.pendingLongRunning.length;
+  if (state.debounceTimer && pendingCount <= state.scheduledCompletionCount) {
     return;
   }
   if (state.firstCompletionAt === null) {
@@ -10018,14 +10049,16 @@ function scheduleWake(state, sendWake, onSendFailure) {
     const previousFireAt = state.scheduledFireAt ?? now;
     state.scheduledFireAt = Math.min(previousFireAt + DEBOUNCE_STEP_MS, state.firstCompletionAt + DEBOUNCE_CAP_MS);
   }
-  state.scheduledCompletionCount = state.pendingCompletions.length;
+  state.scheduledCompletionCount = pendingCount;
   if (state.debounceTimer)
     clearTimeout(state.debounceTimer);
   const delay = state.retryDelayMs ?? Math.max(0, (state.scheduledFireAt ?? now) - now);
   state.debounceTimer = setTimeout(() => {
     const pending = state.pendingCompletions;
-    const reminder = formatSystemReminder(pending);
+    const pendingLongRunning = state.pendingLongRunning;
+    const reminder = formatCombinedSystemReminder(pending, pendingLongRunning);
     state.pendingCompletions = [];
+    state.pendingLongRunning = [];
     state.debounceTimer = null;
     state.firstCompletionAt = null;
     state.scheduledFireAt = null;
@@ -10035,6 +10068,7 @@ function scheduleWake(state, sendWake, onSendFailure) {
       state.wakeFiredThisIdle = true;
     }).catch((err) => {
       state.pendingCompletions = [...pending, ...state.pendingCompletions];
+      state.pendingLongRunning = [...pendingLongRunning, ...state.pendingLongRunning];
       state.retryDelayMs = Math.min((delay || DEBOUNCE_STEP_MS) * 2, DEBOUNCE_CAP_MS);
       onSendFailure(err);
       scheduleWake(state, sendWake, onSendFailure);
@@ -10051,6 +10085,7 @@ function stateFor(sessionID) {
     state = {
       outstandingTaskIds: new Set,
       pendingCompletions: [],
+      pendingLongRunning: [],
       debounceTimer: null,
       wakeFiredThisIdle: false,
       firstCompletionAt: null,
@@ -10101,6 +10136,17 @@ function appendReminder(output, reminder) {
 
 ${reminder}` : reminder;
 }
+function formatDurationMs(ms) {
+  if (!Number.isFinite(ms) || ms < 1000)
+    return `${Math.max(0, Math.round(ms))}ms`;
+  const totalSeconds = Math.round(ms / 1000);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+}
+function shorten(value, limit) {
+  return value.length <= limit ? value : `${value.slice(0, limit - 1)}\u2026`;
+}
 function formatCompletion(completion) {
   const status = formatStatus(completion);
   const duration = formatDuration(completion);
@@ -23739,7 +23785,9 @@ var ExperimentalConfigSchema = exports_external.object({
   bash: exports_external.object({
     rewrite: exports_external.boolean().optional(),
     compress: exports_external.boolean().optional(),
-    background: exports_external.boolean().optional()
+    background: exports_external.boolean().optional(),
+    long_running_reminder_enabled: exports_external.boolean().optional(),
+    long_running_reminder_interval_ms: exports_external.number().int().positive().optional()
   }).optional(),
   lsp_ty: exports_external.boolean().optional()
 });
@@ -23820,6 +23868,12 @@ function resolveExperimentalConfigForConfigure(config2) {
   if (config2.experimental?.bash?.background !== undefined) {
     overrides.experimental_bash_background = config2.experimental.bash.background;
   }
+  if (config2.experimental?.bash?.long_running_reminder_enabled !== undefined) {
+    overrides.bash_long_running_reminder_enabled = config2.experimental.bash.long_running_reminder_enabled;
+  }
+  if (config2.experimental?.bash?.long_running_reminder_interval_ms !== undefined) {
+    overrides.bash_long_running_reminder_interval_ms = config2.experimental.bash.long_running_reminder_interval_ms;
+  }
   if (config2.experimental?.lsp_ty !== undefined) {
     overrides.experimental_lsp_ty = config2.experimental.lsp_ty;
   }
@@ -24150,6 +24204,10 @@ function loadAftConfig(projectDirectory) {
   return config2;
 }
 
+// src/hooks/auto-update-checker/index.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, renameSync as renameSync3, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname4, join as join11 } from "path";
+
 // src/hooks/auto-update-checker/cache.ts
 var import_comment_json3 = __toESM(require_src2(), 1);
 import { spawn as spawn2 } from "child_process";
@@ -24547,6 +24605,9 @@ async function runNpmInstallSafe(installDir, options = {}) {
 }
 
 // src/hooks/auto-update-checker/index.ts
+var DEFAULT_CHECK_INTERVAL_MS = 60 * 60 * 1000;
+var DEFAULT_INIT_DELAY_MS = 5000;
+var TIMESTAMP_FILENAME = "last-update-check.json";
 function createAutoUpdateCheckerHook(ctx, options = {}) {
   const {
     enabled = true,
@@ -24554,40 +24615,68 @@ function createAutoUpdateCheckerHook(ctx, options = {}) {
     autoUpdate = true,
     npmRegistryUrl = NPM_REGISTRY_URL,
     fetchTimeoutMs = NPM_FETCH_TIMEOUT,
-    signal = new AbortController().signal
+    signal = new AbortController().signal,
+    storageDir = null,
+    checkIntervalMs = DEFAULT_CHECK_INTERVAL_MS,
+    initDelayMs = DEFAULT_INIT_DELAY_MS
   } = options;
-  let hasChecked = false;
-  return async ({ event }) => {
-    if (!enabled)
-      return;
-    if (event.type !== "session.created")
-      return;
-    if (hasChecked)
-      return;
-    if (getParentId(event.properties))
-      return;
-    hasChecked = true;
-    setTimeout(() => {
-      runStartupCheck(ctx, {
-        showStartupToast,
-        autoUpdate,
-        npmRegistryUrl,
-        fetchTimeoutMs,
-        signal
-      }).catch((err) => {
-        warn2(`[auto-update-checker] Background update check failed: ${String(err)}`);
-      });
-    }, 0);
-  };
+  if (!enabled) {
+    return async (_input) => {};
+  }
+  const initTimer = setTimeout(() => {
+    maybeRunCheck(ctx, {
+      showStartupToast,
+      autoUpdate,
+      npmRegistryUrl,
+      fetchTimeoutMs,
+      signal,
+      storageDir,
+      checkIntervalMs,
+      initDelayMs
+    }).catch((err) => {
+      warn2(`[auto-update-checker] Background update check failed: ${String(err)}`);
+    });
+  }, initDelayMs);
+  if (typeof initTimer === "object" && initTimer !== null && "unref" in initTimer) {
+    initTimer.unref();
+  }
+  signal.addEventListener("abort", () => {
+    clearTimeout(initTimer);
+  }, { once: true });
+  return async (_input) => {};
 }
-function getParentId(properties) {
-  if (!properties || typeof properties !== "object" || Array.isArray(properties))
-    return null;
-  const info = properties.info;
-  if (!info || typeof info !== "object" || Array.isArray(info))
-    return null;
-  const parentID = info.parentID;
-  return typeof parentID === "string" && parentID.length > 0 ? parentID : null;
+async function maybeRunCheck(ctx, options) {
+  if (options.signal.aborted)
+    return;
+  if (!claimCheckSlot(options.storageDir, options.checkIntervalMs)) {
+    log2("[auto-update-checker] Skipping check (another instance ran one recently)");
+    return;
+  }
+  await runStartupCheck(ctx, options);
+}
+function claimCheckSlot(storageDir, intervalMs) {
+  if (!storageDir)
+    return true;
+  try {
+    const file2 = join11(storageDir, TIMESTAMP_FILENAME);
+    if (existsSync8(file2)) {
+      try {
+        const raw = JSON.parse(readFileSync6(file2, "utf-8"));
+        const last = typeof raw.lastCheckedMs === "number" ? raw.lastCheckedMs : 0;
+        if (Number.isFinite(last) && Date.now() - last < intervalMs) {
+          return false;
+        }
+      } catch {}
+    }
+    mkdirSync5(dirname4(file2), { recursive: true });
+    const tmp = `${file2}.tmp.${process.pid}`;
+    writeFileSync6(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
+    renameSync3(tmp, file2);
+    return true;
+  } catch (err) {
+    warn2(`[auto-update-checker] Could not coordinate via timestamp file: ${String(err)}`);
+    return true;
+  }
 }
 async function runStartupCheck(ctx, options) {
   if (options.signal.aborted)
@@ -24675,43 +24764,43 @@ import { createReadStream, statSync as statSync4 } from "fs";
 // src/lsp-cache.ts
 import {
   closeSync as closeSync2,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync6,
   openSync as openSync2,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   statSync as statSync3,
   unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function aftCacheBase() {
   const override = process.env.AFT_CACHE_DIR;
   if (override && override.length > 0)
     return override;
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join11(homedir8(), "AppData", "Local");
-    return join11(base2, "aft");
+    const base2 = localAppData || join12(homedir8(), "AppData", "Local");
+    return join12(base2, "aft");
   }
-  const base = process.env.XDG_CACHE_HOME || join11(homedir8(), ".cache");
-  return join11(base, "aft");
+  const base = process.env.XDG_CACHE_HOME || join12(homedir8(), ".cache");
+  return join12(base, "aft");
 }
 function lspCacheRoot() {
-  return join11(aftCacheBase(), "lsp-packages");
+  return join12(aftCacheBase(), "lsp-packages");
 }
 function lspPackageDir(npmPackage) {
-  return join11(lspCacheRoot(), encodeURIComponent(npmPackage));
+  return join12(lspCacheRoot(), encodeURIComponent(npmPackage));
 }
 function lspBinaryPath(npmPackage, binary) {
-  return join11(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+  return join12(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
 }
 function lspBinDir(npmPackage) {
-  return join11(lspPackageDir(npmPackage), "node_modules", ".bin");
+  return join12(lspPackageDir(npmPackage), "node_modules", ".bin");
 }
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync3(join11(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync3(join12(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -24725,23 +24814,23 @@ function lspBinaryCandidates(binary) {
 var INSTALLED_META_FILE = ".aft-installed";
 function writeInstalledMetaIn(installDir, version2, sha256) {
   try {
-    mkdirSync5(installDir, { recursive: true });
+    mkdirSync6(installDir, { recursive: true });
     const meta3 = {
       version: version2,
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeFileSync6(join11(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
+    writeFileSync7(join12(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
   } catch (err) {
     log2(`[lsp-cache] failed to write installed-meta in ${installDir}: ${err}`);
   }
 }
 function readInstalledMetaIn(installDir) {
-  const path2 = join11(installDir, INSTALLED_META_FILE);
+  const path2 = join12(installDir, INSTALLED_META_FILE);
   try {
     if (!statSync3(path2).isFile())
       return null;
-    const raw = readFileSync6(path2, "utf8");
+    const raw = readFileSync7(path2, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
@@ -24761,17 +24850,17 @@ function readInstalledMeta(packageKey) {
   return readInstalledMetaIn(lspPackageDir(packageKey));
 }
 function lockPath(npmPackage) {
-  return join11(lspPackageDir(npmPackage), ".aft-installing");
+  return join12(lspPackageDir(npmPackage), ".aft-installing");
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
-  mkdirSync5(lspPackageDir(lockKey), { recursive: true });
+  mkdirSync6(lspPackageDir(lockKey), { recursive: true });
   const lock = lockPath(lockKey);
   const tryClaim = () => {
     try {
       const fd = openSync2(lock, "wx");
       try {
-        writeFileSync6(fd, `${process.pid}
+        writeFileSync7(fd, `${process.pid}
 ${new Date().toISOString()}
 `);
       } finally {
@@ -24791,7 +24880,7 @@ ${new Date().toISOString()}
   let owningPid = null;
   let lockMtimeMs = 0;
   try {
-    const raw = readFileSync6(lock, "utf8");
+    const raw = readFileSync7(lock, "utf8");
     const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
     const parsed = Number.parseInt(firstLine, 10);
     if (Number.isFinite(parsed) && parsed > 0)
@@ -24829,7 +24918,7 @@ function releaseInstallLock(lockKey) {
   try {
     let owningPid = null;
     try {
-      const raw = readFileSync6(lock, "utf8");
+      const raw = readFileSync7(lock, "utf8");
       const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
       const parsed = Number.parseInt(firstLine, 10);
       if (Number.isFinite(parsed) && parsed > 0)
@@ -24868,9 +24957,9 @@ async function withInstallLock(lockKey, task) {
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
-  const file2 = join11(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file2 = join12(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
-    const raw = readFileSync6(file2, "utf8");
+    const raw = readFileSync7(file2, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.last_checked === "string") {
       return {
@@ -24884,13 +24973,13 @@ function readVersionCheck(npmPackage) {
   }
 }
 function writeVersionCheck(npmPackage, latest) {
-  mkdirSync5(lspPackageDir(npmPackage), { recursive: true });
-  const file2 = join11(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  mkdirSync6(lspPackageDir(npmPackage), { recursive: true });
+  const file2 = join12(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record2 = {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
   };
-  writeFileSync6(file2, JSON.stringify(record2, null, 2));
+  writeFileSync7(file2, JSON.stringify(record2, null, 2));
 }
 function shouldRecheckVersion(record2, weeklyCheckIntervalMs = 7 * 24 * 60 * 60 * 1000) {
   if (!record2)
@@ -25033,8 +25122,8 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync3 } from "fs";
+import { join as join13 } from "path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
 var NOISE_DIRS = new Set([
@@ -25051,7 +25140,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync8(join12(projectRoot, marker)))
+    if (existsSync9(join13(projectRoot, marker)))
       return true;
   }
   return false;
@@ -25077,7 +25166,7 @@ function relevantExtensionsInProject(projectRoot, extToServer) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (current.depth < MAX_WALK_DEPTH && !NOISE_DIRS.has(entry.name.toLowerCase())) {
-          queue.push({ dir: join12(current.dir, entry.name), depth: current.depth + 1 });
+          queue.push({ dir: join13(current.dir, entry.name), depth: current.depth + 1 });
         }
         continue;
       }
@@ -25416,18 +25505,18 @@ import {
   copyFileSync as copyFileSync3,
   createReadStream as createReadStream2,
   createWriteStream as createWriteStream2,
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   readdirSync as readdirSync4,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync3,
-  renameSync as renameSync3,
+  renameSync as renameSync4,
   rmSync as rmSync3,
   statSync as statSync5,
   unlinkSync as unlinkSync6
 } from "fs";
-import { dirname as dirname4, join as join13, relative as relative2, resolve as resolve3 } from "path";
+import { dirname as dirname5, join as join14, relative as relative2, resolve as resolve3 } from "path";
 import { Readable as Readable2 } from "stream";
 import { pipeline as pipeline2 } from "stream/promises";
 
@@ -25517,25 +25606,25 @@ function detectHostPlatform() {
 
 // src/lsp-github-install.ts
 function ghCacheRoot() {
-  return join13(aftCacheBase(), "lsp-binaries");
+  return join14(aftCacheBase(), "lsp-binaries");
 }
 function ghPackageDir(spec) {
-  return join13(ghCacheRoot(), spec.id);
+  return join14(ghCacheRoot(), spec.id);
 }
 function ghBinDir(spec) {
-  return join13(ghPackageDir(spec), "bin");
+  return join14(ghPackageDir(spec), "bin");
 }
 function ghExtractDir(spec) {
-  return join13(ghPackageDir(spec), "extracted");
+  return join14(ghPackageDir(spec), "extracted");
 }
 function ghBinaryPath(spec, platform2) {
   const ext = platform2 === "win32" ? ".exe" : "";
-  return join13(ghBinDir(spec), `${spec.binary}${ext}`);
+  return join14(ghBinDir(spec), `${spec.binary}${ext}`);
 }
 function isGithubInstalled(spec, platform2) {
   for (const candidate of ghBinaryCandidates(spec, platform2)) {
     try {
-      if (statSync5(join13(ghBinDir(spec), candidate)).isFile())
+      if (statSync5(join14(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -25723,7 +25812,7 @@ async function downloadFile(url2, destPath, fetchImpl, assetSize, signal) {
     if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES2) {
       throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES2}`);
     }
-    mkdirSync6(dirname4(destPath), { recursive: true });
+    mkdirSync7(dirname5(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, controller) {
@@ -25758,7 +25847,7 @@ function validateExtraction(stagingRoot) {
       throw new Error(`failed to read staging dir ${dir}: ${err}`);
     }
     for (const entry of entries) {
-      const full = join13(dir, entry);
+      const full = join14(dir, entry);
       let lst;
       try {
         lst = lstatSync2(full);
@@ -25802,14 +25891,14 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
   try {
     rmSync3(stagingDir, { recursive: true, force: true });
   } catch {}
-  mkdirSync6(stagingDir, { recursive: true });
+  mkdirSync7(stagingDir, { recursive: true });
   try {
     runPlatformExtractor(archivePath, stagingDir, archiveType);
     validateExtraction(stagingDir);
     try {
       rmSync3(destDir, { recursive: true, force: true });
     } catch {}
-    renameSync3(stagingDir, destDir);
+    renameSync4(stagingDir, destDir);
   } catch (err) {
     try {
       rmSync3(stagingDir, { recursive: true, force: true });
@@ -25862,7 +25951,7 @@ async function downloadAndInstall(spec, tag, assets, platform2, arch, fetchImpl,
   }
   const pkgDir = ghPackageDir(spec);
   const extractDir = ghExtractDir(spec);
-  const archivePath = join13(pkgDir, expected.name);
+  const archivePath = join14(pkgDir, expected.name);
   log2(`[lsp] downloading ${spec.id} ${tag} \u2192 ${matchingAsset.url}`);
   try {
     await downloadFile(matchingAsset.url, archivePath, fetchImpl, matchingAsset.size, signal);
@@ -25901,13 +25990,13 @@ async function downloadAndInstall(spec, tag, assets, platform2, arch, fetchImpl,
       unlinkSync6(archivePath);
     } catch {}
   }
-  const innerBinaryPath = join13(extractDir, spec.binaryPathInArchive(platform2, arch, version2));
-  if (!existsSync9(innerBinaryPath)) {
+  const innerBinaryPath = join14(extractDir, spec.binaryPathInArchive(platform2, arch, version2));
+  if (!existsSync10(innerBinaryPath)) {
     error2(`[lsp] ${spec.id}: extracted binary not found at ${innerBinaryPath}`);
     return null;
   }
   const targetBinary = ghBinaryPath(spec, platform2);
-  mkdirSync6(dirname4(targetBinary), { recursive: true });
+  mkdirSync7(dirname5(targetBinary), { recursive: true });
   try {
     copyFileSync3(innerBinaryPath, targetBinary);
     if (platform2 !== "win32") {
@@ -25984,7 +26073,7 @@ function runGithubAutoInstall(relevantServers, config2, fetchImpl = fetch) {
   if (!host) {
     for (const spec of GITHUB_LSP_TABLE) {
       try {
-        if (existsSync9(ghBinDir(spec))) {
+        if (existsSync10(ghBinDir(spec))) {
           cachedBinDirs.push(ghBinDir(spec));
         }
       } catch {}
@@ -26147,9 +26236,9 @@ function normalizeToolMap(tools) {
 }
 
 // src/notifications.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir9, platform as platform2 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function isTuiMode() {
   return process.env.OPENCODE_CLIENT === "cli";
 }
@@ -26173,25 +26262,25 @@ function getDesktopStatePath() {
   const os2 = platform2();
   const home = homedir9();
   if (os2 === "darwin") {
-    return join14(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
+    return join15(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os2 === "linux") {
-    const xdgConfig = process.env.XDG_CONFIG_HOME || join14(home, ".config");
-    return join14(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join15(home, ".config");
+    return join15(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os2 === "win32") {
-    const appData = process.env.APPDATA || join14(home, "AppData", "Roaming");
-    return join14(appData, "ai.opencode.desktop", "opencode.global.dat");
+    const appData = process.env.APPDATA || join15(home, "AppData", "Roaming");
+    return join15(appData, "ai.opencode.desktop", "opencode.global.dat");
   }
   return null;
 }
 function readDesktopState(directory) {
   const statePath = getDesktopStatePath();
-  if (!statePath || !existsSync10(statePath)) {
+  if (!statePath || !existsSync11(statePath)) {
     return { sessionId: null, serverUrl: null };
   }
   try {
-    const raw = readFileSync7(statePath, "utf-8");
+    const raw = readFileSync8(statePath, "utf-8");
     const state = JSON.parse(raw);
     let serverUrl = null;
     const serverStr = state.server;
@@ -26285,10 +26374,10 @@ async function sendWarning(opts, message) {
 }
 async function sendFeatureAnnouncement(opts, version2, features, storageDir) {
   if (storageDir) {
-    const versionFile = join14(storageDir, "last_announced_version");
+    const versionFile = join15(storageDir, "last_announced_version");
     try {
-      if (existsSync10(versionFile)) {
-        const lastVersion = readFileSync7(versionFile, "utf-8").trim();
+      if (existsSync11(versionFile)) {
+        const lastVersion = readFileSync8(versionFile, "utf-8").trim();
         if (lastVersion === version2)
           return;
       }
@@ -26308,17 +26397,17 @@ async function sendFeatureAnnouncement(opts, version2, features, storageDir) {
   }
   if (storageDir) {
     try {
-      mkdirSync7(storageDir, { recursive: true });
-      writeFileSync7(join14(storageDir, "last_announced_version"), version2);
+      mkdirSync8(storageDir, { recursive: true });
+      writeFileSync8(join15(storageDir, "last_announced_version"), version2);
     } catch {}
   }
 }
 function readWarnedTools(storageDir) {
   try {
-    const warnedToolsPath = join14(storageDir, WARNED_TOOLS_FILE);
-    if (!existsSync10(warnedToolsPath))
+    const warnedToolsPath = join15(storageDir, WARNED_TOOLS_FILE);
+    if (!existsSync11(warnedToolsPath))
       return {};
-    const parsed = JSON.parse(readFileSync7(warnedToolsPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(warnedToolsPath, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return {};
     const warned = {};
@@ -26334,9 +26423,9 @@ function readWarnedTools(storageDir) {
 }
 function writeWarnedTools(storageDir, warned) {
   try {
-    mkdirSync7(storageDir, { recursive: true });
-    const warnedToolsPath = join14(storageDir, WARNED_TOOLS_FILE);
-    writeFileSync7(warnedToolsPath, `${JSON.stringify(warned, null, 2)}
+    mkdirSync8(storageDir, { recursive: true });
+    const warnedToolsPath = join15(storageDir, WARNED_TOOLS_FILE);
+    writeFileSync8(warnedToolsPath, `${JSON.stringify(warned, null, 2)}
 `);
   } catch {}
 }
@@ -26429,20 +26518,20 @@ async function cleanupWarnings(opts) {
 
 // src/shared/rpc-server.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { mkdirSync as mkdirSync8, renameSync as renameSync4, unlinkSync as unlinkSync7, writeFileSync as writeFileSync8 } from "fs";
+import { mkdirSync as mkdirSync9, renameSync as renameSync5, unlinkSync as unlinkSync7, writeFileSync as writeFileSync9 } from "fs";
 import { createServer } from "http";
-import { dirname as dirname5 } from "path";
+import { dirname as dirname6 } from "path";
 
 // src/shared/rpc-utils.ts
 import { createHash as createHash5 } from "crypto";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 function projectHash(directory) {
   const normalized = directory.replace(/\/+$/, "");
   return createHash5("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function rpcPortFilePath(storageDir, directory) {
   const hash2 = projectHash(directory);
-  return join15(storageDir, "rpc", hash2, "port");
+  return join16(storageDir, "rpc", hash2, "port");
 }
 
 // src/shared/rpc-server.ts
@@ -26475,11 +26564,11 @@ class AftRpcServer {
         this.token = randomBytes2(32).toString("hex");
         this.server = server;
         try {
-          const dir = dirname5(this.portFilePath);
-          mkdirSync8(dir, { recursive: true });
+          const dir = dirname6(this.portFilePath);
+          mkdirSync9(dir, { recursive: true });
           const tmpPath = `${this.portFilePath}.tmp`;
-          writeFileSync8(tmpPath, JSON.stringify({ port: this.port, token: this.token }), "utf-8");
-          renameSync4(tmpPath, this.portFilePath);
+          writeFileSync9(tmpPath, JSON.stringify({ port: this.port, token: this.token }), "utf-8");
+          renameSync5(tmpPath, this.portFilePath);
           log2(`RPC server listening on 127.0.0.1:${this.port}`);
         } catch (err) {
           warn2(`Failed to write RPC port file: ${err}`);
@@ -26774,21 +26863,21 @@ function formatStatusMarkdown(status) {
 
 // src/shared/tui-config.ts
 var import_comment_json4 = __toESM(require_src2(), 1);
-import { existsSync as existsSync11, mkdirSync as mkdirSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname6, join as join17 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname7, join as join18 } from "path";
 
 // src/shared/opencode-config-dir.ts
 import { homedir as homedir10 } from "os";
-import { join as join16, resolve as resolve4 } from "path";
+import { join as join17, resolve as resolve4 } from "path";
 function getCliConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envConfigDir) {
     return resolve4(envConfigDir);
   }
   if (process.platform === "win32") {
-    return join16(homedir10(), ".config", "opencode");
+    return join17(homedir10(), ".config", "opencode");
   }
-  return join16(process.env.XDG_CONFIG_HOME || join16(homedir10(), ".config"), "opencode");
+  return join17(process.env.XDG_CONFIG_HOME || join17(homedir10(), ".config"), "opencode");
 }
 function getOpenCodeConfigDir2(_options) {
   return getCliConfigDir();
@@ -26797,10 +26886,10 @@ function getOpenCodeConfigPaths(options) {
   const configDir = getOpenCodeConfigDir2(options);
   return {
     configDir,
-    configJson: join16(configDir, "opencode.json"),
-    configJsonc: join16(configDir, "opencode.jsonc"),
-    packageJson: join16(configDir, "package.json"),
-    omoConfig: join16(configDir, "magic-context.jsonc")
+    configJson: join17(configDir, "opencode.json"),
+    configJsonc: join17(configDir, "opencode.jsonc"),
+    packageJson: join17(configDir, "package.json"),
+    omoConfig: join17(configDir, "magic-context.jsonc")
   };
 }
 
@@ -26809,11 +26898,11 @@ var PLUGIN_NAME = "@cortexkit/aft-opencode";
 var PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
 function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join17(configDir, "tui.jsonc");
-  const jsonPath = join17(configDir, "tui.json");
-  if (existsSync11(jsoncPath))
+  const jsoncPath = join18(configDir, "tui.jsonc");
+  const jsonPath = join18(configDir, "tui.json");
+  if (existsSync12(jsoncPath))
     return jsoncPath;
-  if (existsSync11(jsonPath))
+  if (existsSync12(jsonPath))
     return jsonPath;
   return jsonPath;
 }
@@ -26821,8 +26910,8 @@ function ensureTuiPluginEntry() {
   try {
     const configPath = resolveTuiConfigPath();
     let config2 = {};
-    if (existsSync11(configPath)) {
-      config2 = import_comment_json4.parse(readFileSync8(configPath, "utf-8")) ?? {};
+    if (existsSync12(configPath)) {
+      config2 = import_comment_json4.parse(readFileSync9(configPath, "utf-8")) ?? {};
     }
     const plugins = Array.isArray(config2.plugin) ? config2.plugin.filter((value) => typeof value === "string") : [];
     if (plugins.some((plugin) => plugin === PLUGIN_NAME || plugin.startsWith(`${PLUGIN_NAME}@`) || plugin.includes("opencode-plugin") || plugin.includes("aft-opencode"))) {
@@ -26830,8 +26919,8 @@ function ensureTuiPluginEntry() {
     }
     plugins.push(PLUGIN_ENTRY);
     config2.plugin = plugins;
-    mkdirSync9(dirname6(configPath), { recursive: true });
-    writeFileSync9(configPath, `${import_comment_json4.stringify(config2, null, 2)}
+    mkdirSync10(dirname7(configPath), { recursive: true });
+    writeFileSync10(configPath, `${import_comment_json4.stringify(config2, null, 2)}
 `);
     log2(`[aft-plugin] added TUI plugin entry to ${configPath}`);
     return true;
@@ -26951,6 +27040,10 @@ async function callBridge(ctx, runtime, command, params = {}, options) {
 
 // src/tools/permissions.ts
 import * as path3 from "path";
+import { Effect } from "effect";
+async function runAsk(maybe) {
+  await Effect.runPromise(maybe);
+}
 function resolveAbsolutePath(context, target) {
   return path3.isAbsolute(target) ? target : path3.resolve(context.directory, target);
 }
@@ -26976,12 +27069,12 @@ function workspacePattern(_context) {
 }
 async function askEditPermission(context, patterns, metadata = {}) {
   try {
-    await context.ask({
+    await runAsk(context.ask({
       permission: "edit",
       patterns: patterns.length > 0 ? patterns : [workspacePattern(context)],
       always: ["*"],
       metadata
-    });
+    }));
     return;
   } catch (error50) {
     if (error50 instanceof Error && error50.message) {
@@ -27564,8 +27657,9 @@ ${chunk.old_lines.join(`
 import { tool as tool3 } from "@opencode-ai/plugin";
 var z3 = tool3.schema;
 var METADATA_PREVIEW_LIMIT = 30 * 1024;
-var DEFAULT_BASH_TIMEOUT_MS = 30000;
-var BASH_TRANSPORT_TIMEOUT_OVERHEAD_MS = 5000;
+var FOREGROUND_WAIT_WINDOW_MS = 5000;
+var FOREGROUND_POLL_INTERVAL_MS = 100;
+var BASH_TRANSPORT_TIMEOUT_MS = 30000;
 var BASH_DESCRIPTION = `Hoisted bash tool with output compression, command rewriting to AFT tools, and optional background execution. By default, output is compressed; pass compressed: false for raw output. Pass background: true to spawn in the background and get a task_id for bash_status/bash_kill.`;
 async function withPermissionLoop(ctx, runtime, params, bridgeCall, options) {
   const first = await bridgeCall(ctx, runtime, "bash", params, options);
@@ -27575,12 +27669,12 @@ async function withPermissionLoop(ctx, runtime, params, bridgeCall, options) {
   const permissionsGranted = [];
   for (const ask of asks) {
     const permission = ask.kind === "external_directory" ? "external_directory" : "bash";
-    await runtime.ask({
+    await runAsk(runtime.ask({
       permission,
       patterns: ask.patterns,
       always: ask.always,
       metadata: {}
-    });
+    }));
     permissionsGranted.push(...ask.always.length > 0 ? ask.always : ask.patterns);
   }
   const second = await bridgeCall(ctx, runtime, "bash", { ...params, permissions_granted: permissionsGranted }, options);
@@ -27594,7 +27688,7 @@ function createBashTool(ctx) {
     description: BASH_DESCRIPTION,
     args: {
       command: z3.string().describe("Shell command to execute through AFT's unified bash schema. Supports normal shell syntax, pipes, redirection, and command rewriting to dedicated AFT tools when available."),
-      timeout: z3.number().optional().describe("Maximum execution time in milliseconds for foreground commands. Defaults to 30000 (30 seconds) when omitted. For commands expected to run longer than 30s (builds, installs, full test suites), use background: true instead."),
+      timeout: z3.number().int().positive().optional().describe("Hard kill cap in milliseconds (positive integer). When omitted, the task can run up to 30 minutes. Foreground bash returns inline if the command finishes within ~5s; otherwise it's automatically promoted to background and a completion reminder is delivered when the task actually finishes."),
       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."),
       background: z3.boolean().optional().describe("When true, spawn the command in the background and return a task_id for bash_status/bash_kill instead of waiting for completion. Defaults to false."),
@@ -27614,10 +27708,11 @@ function createBashTool(ctx) {
         env: shellEnv?.env ?? {},
         description,
         background: args.background,
+        notify_on_completion: args.background === true,
         compressed: args.compressed,
         permissions_requested: true
       }, callBridge, {
-        transportTimeoutMs: bashTransportTimeoutMs(args.timeout),
+        transportTimeoutMs: BASH_TRANSPORT_TIMEOUT_MS,
         keepBridgeOnTimeout: true,
         onProgress: ({ text }) => {
           accumulatedOutput = preview(accumulatedOutput + text);
@@ -27630,17 +27725,58 @@ function createBashTool(ctx) {
       if (data.status === "running" && typeof data.task_id === "string") {
         const callID2 = getCallID(context);
         const taskId = data.task_id;
-        trackBgTask(context.sessionID, taskId);
-        const startedLine = `Background task started: ${taskId}. A completion reminder will be delivered automatically; don't poll bash_status.`;
-        const metadataPayload2 = { description, output: startedLine, status: "running", taskId };
-        metadata?.(metadataPayload2);
-        if (callID2) {
-          storeToolMetadata(context.sessionID, callID2, {
-            title: description ?? shortenCommand(command),
-            metadata: metadataPayload2
-          });
+        if (args.background === true) {
+          trackBgTask(context.sessionID, taskId);
+          const startedLine = formatBackgroundLaunch(taskId);
+          const metadataPayload2 = { description, output: startedLine, status: "running", taskId };
+          metadata?.(metadataPayload2);
+          if (callID2) {
+            storeToolMetadata(context.sessionID, callID2, {
+              title: description ?? shortenCommand(command),
+              metadata: metadataPayload2
+            });
+          }
+          return startedLine;
+        }
+        const argTimeout = args.timeout;
+        const waitTimeoutMs = argTimeout !== undefined ? Math.min(argTimeout, FOREGROUND_WAIT_WINDOW_MS) : FOREGROUND_WAIT_WINDOW_MS;
+        const startedAt = Date.now();
+        while (true) {
+          const status = await callBridge(ctx, context, "bash_status", { task_id: taskId });
+          if (status.success === false) {
+            throw new Error(status.message ?? "bash_status failed");
+          }
+          if (isTerminalStatus(status.status)) {
+            const rendered2 = formatForegroundResult(status);
+            const metadataPayload2 = foregroundMetadata(description, status, rendered2);
+            metadata?.(metadataPayload2);
+            if (callID2) {
+              storeToolMetadata(context.sessionID, callID2, {
+                title: description ?? shortenCommand(command),
+                metadata: metadataPayload2
+              });
+            }
+            return rendered2;
+          }
+          if (Date.now() - startedAt >= waitTimeoutMs) {
+            const promoted = await callBridge(ctx, context, "bash_promote", { task_id: taskId });
+            if (promoted.success === false) {
+              throw new Error(promoted.message ?? "bash_promote failed");
+            }
+            trackBgTask(context.sessionID, taskId);
+            const message = formatPromotionMessage(taskId, args.timeout);
+            const metadataPayload2 = { description, output: message, status: "running", taskId };
+            metadata?.(metadataPayload2);
+            if (callID2) {
+              storeToolMetadata(context.sessionID, callID2, {
+                title: description ?? shortenCommand(command),
+                metadata: metadataPayload2
+              });
+            }
+            return message;
+          }
+          await sleep(FOREGROUND_POLL_INTERVAL_MS);
         }
-        return startedLine;
       }
       const output = data.output ?? "";
       const metadataOutput = preview(output);
@@ -27727,13 +27863,53 @@ function createBashKillTool(ctx) {
     }
   };
 }
-function bashTransportTimeoutMs(timeout) {
-  const bashTimeout = timeout ?? DEFAULT_BASH_TIMEOUT_MS;
-  return Math.max(30000, bashTimeout + BASH_TRANSPORT_TIMEOUT_OVERHEAD_MS);
-}
 function preview(output) {
   return output.length <= METADATA_PREVIEW_LIMIT ? output : output.slice(-METADATA_PREVIEW_LIMIT);
 }
+function isTerminalStatus(status) {
+  return status === "completed" || status === "failed" || status === "killed" || status === "timed_out";
+}
+function formatBackgroundLaunch(taskId) {
+  return `Background task started: ${taskId}. A completion reminder will be delivered automatically; don't poll bash_status.`;
+}
+function formatPromotionMessage(taskId, timeout) {
+  const waited = timeout !== undefined ? Math.min(timeout, FOREGROUND_WAIT_WINDOW_MS) : FOREGROUND_WAIT_WINDOW_MS;
+  return `Foreground bash didn't finish within ${waited}ms and was promoted to background: ${taskId}. A completion reminder will be delivered automatically; use bash_status({ taskId: "${taskId}" }) to inspect output or bash_kill({ taskId: "${taskId}" }) to terminate.`;
+}
+function formatForegroundResult(data) {
+  const output = data.output_preview ?? "";
+  const outputPath = data.output_path;
+  const truncated = data.output_truncated === true;
+  const status = data.status;
+  const exit = data.exit_code;
+  let rendered = output;
+  if (truncated && outputPath) {
+    rendered += `
+[output truncated; full output at ${outputPath}]`;
+  }
+  if (status === "timed_out") {
+    rendered += `
+[command timed out]`;
+  }
+  if (typeof exit === "number" && exit !== 0) {
+    rendered += `
+[exit code: ${exit}]`;
+  }
+  return rendered;
+}
+function foregroundMetadata(description, data, rendered) {
+  const outputPath = data.output_path;
+  return {
+    description,
+    output: preview(rendered),
+    exit: data.exit_code,
+    truncated: data.output_truncated,
+    ...outputPath ? { outputPath } : {}
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
+}
 function getCallID(ctx) {
   const c = ctx;
   return c.callID ?? c.callId ?? c.call_id;
@@ -27985,12 +28161,12 @@ function createReadTool(ctx) {
     execute: async (args, context) => {
       const file2 = args.filePath;
       const filePath = path4.isAbsolute(file2) ? file2 : path4.resolve(context.directory, file2);
-      await context.ask({
+      await runAsk(context.ask({
         permission: "read",
         patterns: [filePath],
         always: ["*"],
         metadata: {}
-      });
+      }));
       const ext = path4.extname(filePath).toLowerCase();
       const mimeMap = {
         ".png": "image/png",
@@ -28109,12 +28285,12 @@ function createWriteTool(ctx, editToolName = "edit") {
       const content = args.content;
       const filePath = path4.isAbsolute(file2) ? file2 : path4.resolve(context.directory, file2);
       const relPath = path4.relative(context.worktree, filePath);
-      await context.ask({
+      await runAsk(context.ask({
         permission: "edit",
         patterns: [relPath],
         always: ["*"],
         metadata: { filepath: filePath }
-      });
+      }));
       const data = await callBridge(ctx, context, "write", {
         file: filePath,
         content,
@@ -28259,12 +28435,12 @@ function createEditTool(ctx, writeToolName = "write") {
       if (Array.isArray(args.operations)) {
         const ops = args.operations;
         const files = ops.map((op) => op.file).filter(Boolean);
-        await context.ask({
+        await runAsk(context.ask({
           permission: "edit",
           patterns: files.map((f) => path4.relative(context.worktree, path4.resolve(context.directory, f))),
           always: ["*"],
           metadata: {}
-        });
+        }));
         const resolvedOps = ops.map((op) => ({
           ...op,
           file: path4.isAbsolute(op.file) ? op.file : path4.resolve(context.directory, op.file)
@@ -28279,12 +28455,12 @@ function createEditTool(ctx, writeToolName = "write") {
         throw new Error("'filePath' parameter is required");
       const filePath = path4.isAbsolute(file2) ? file2 : path4.resolve(context.directory, file2);
       const relPath = path4.relative(context.worktree, filePath);
-      await context.ask({
+      await runAsk(context.ask({
         permission: "edit",
         patterns: [relPath],
         always: ["*"],
         metadata: { filepath: filePath }
-      });
+      }));
       const params = { file: filePath };
       let command;
       if (typeof args.appendContent === "string") {
@@ -28481,12 +28657,12 @@ function createApplyPatchTool(ctx) {
       }
       const relPaths = Array.from(affectedAbs).map((abs) => path4.relative(context.worktree, abs));
       const multiFileWritePaths = Array.from(affectedAbs);
-      await context.ask({
+      await runAsk(context.ask({
         permission: "edit",
         patterns: relPaths,
         always: ["*"],
         metadata: {}
-      });
+      }));
       const checkpointPaths = Array.from(affectedAbs).filter((abs) => !newlyCreatedAbs.has(abs));
       const checkpointName = `apply_patch_${Date.now()}`;
       let checkpointCreated = false;
@@ -28716,12 +28892,12 @@ function createDeleteTool(ctx) {
     execute: async (args, context) => {
       const inputs = args.files;
       const absolutePaths = inputs.map((f) => path4.isAbsolute(f) ? f : path4.resolve(context.directory, f));
-      await context.ask({
+      await runAsk(context.ask({
         permission: "edit",
         patterns: absolutePaths,
         always: ["*"],
         metadata: { action: "delete", count: absolutePaths.length }
-      });
+      }));
       const deleted = [];
       const skipped = [];
       for (const filePath of absolutePaths) {
@@ -28761,12 +28937,12 @@ function createMoveTool(ctx) {
     execute: async (args, context) => {
       const filePath = path4.isAbsolute(args.filePath) ? args.filePath : path4.resolve(context.directory, args.filePath);
       const destPath = path4.isAbsolute(args.destination) ? args.destination : path4.resolve(context.directory, args.destination);
-      await context.ask({
+      await runAsk(context.ask({
         permission: "edit",
         patterns: [filePath, destPath],
         always: ["*"],
         metadata: { action: "move" }
-      });
+      }));
       const result = await callBridge(ctx, context, "move_file", {
         file: filePath,
         destination: destPath
@@ -28793,8 +28969,6 @@ function hoistedTools(ctx) {
   const anyBashExperimental = bashRewrite || bashCompress || bashBackground;
   if (anyBashExperimental) {
     tools.bash = createBashTool(ctx);
-  }
-  if (bashBackground) {
     tools.bash_status = createBashStatusTool(ctx);
     tools.bash_kill = createBashKillTool(ctx);
   }
@@ -28817,12 +28991,12 @@ function aftPrefixedTools(ctx) {
           const file2 = normalizedArgs.filePath;
           const filePath = path4.isAbsolute(file2) ? file2 : path4.resolve(context.directory, file2);
           const relPath = path4.relative(context.worktree, filePath);
-          await context.ask({
+          await runAsk(context.ask({
             permission: "edit",
             patterns: [relPath],
             always: ["*"],
             metadata: { filepath: filePath }
-          });
+          }));
           const writeParams = {
             file: filePath,
             content: normalizedArgs.content,
@@ -29441,6 +29615,36 @@ function normalizeGlob(pattern) {
   }
   return pattern;
 }
+function splitIncludeArg(raw) {
+  const out = [];
+  let depth = 0;
+  let buf = "";
+  for (const ch of raw) {
+    if (ch === "{") {
+      depth++;
+      buf += ch;
+      continue;
+    }
+    if (ch === "}") {
+      if (depth > 0)
+        depth--;
+      buf += ch;
+      continue;
+    }
+    if (ch === "," && depth === 0) {
+      const trimmed = buf.trim();
+      if (trimmed.length > 0)
+        out.push(trimmed);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  const tail = buf.trim();
+  if (tail.length > 0)
+    out.push(tail);
+  return out;
+}
 function searchTools(ctx) {
   const grepTool = {
     description: "Search file contents using regular expressions. Returns matching lines with file paths, line numbers, and context.",
@@ -29453,7 +29657,7 @@ function searchTools(ctx) {
       const response = await callBridge(ctx, context, "grep", {
         pattern: args.pattern,
         case_sensitive: true,
-        include: args.include ? String(args.include).split(",").map((s) => normalizeGlob(s.trim())).filter(Boolean) : undefined,
+        include: args.include ? splitIncludeArg(String(args.include)).map(normalizeGlob).filter(Boolean) : undefined,
         path: args.path,
         max_results: 100
       });
@@ -29703,12 +29907,8 @@ function buildWorkflowHints(opts) {
     ].join(`
 `));
   }
-  if (hasBash) {
-    if (hasBgBash) {
-      sections.push(`**Long-running commands** (builds, installs, full test suites): \`${bashName}({ background: true })\` returns immediately with a \`taskId\`. A completion reminder is delivered automatically \u2014 do not poll \`${bashStatusName}({ taskId })\`. Use \`${bashStatusName}\` only after the reminder arrives, or to inspect a task you already know is complete.`);
-    } else {
-      sections.push(`**Long-running bash commands**: foreground \`${bashName}\` times out after 30 seconds. Pass \`timeout\` in milliseconds to extend it for commands you know will take longer.`);
-    }
+  if (hasBash && hasBgBash) {
+    sections.push(`**Long-running commands** (builds, installs, full test suites): \`${bashName}({ background: true })\` returns immediately with a \`taskId\`. A completion reminder is delivered automatically \u2014 do not poll \`${bashStatusName}({ taskId })\`. Use \`${bashStatusName}\` only after the reminder arrives, or to inspect a task you already know is complete.`);
   }
   if (sections.length === 0) {
     return null;
@@ -29835,8 +30035,8 @@ var plugin = async (input) => {
   if (aftConfig.max_callgraph_files !== undefined)
     configOverrides.max_callgraph_files = aftConfig.max_callgraph_files;
   const isFastembedSemanticBackend = (aftConfig.semantic?.backend ?? "fastembed") === "fastembed";
-  const dataHome = process.env.XDG_DATA_HOME || join18(homedir11(), ".local", "share");
-  configOverrides.storage_dir = join18(dataHome, "opencode", "storage", "plugin", "aft");
+  const dataHome = process.env.XDG_DATA_HOME || join19(homedir11(), ".local", "share");
+  configOverrides.storage_dir = join19(dataHome, "opencode", "storage", "plugin", "aft");
   let onnxRuntimePromise = null;
   if (aftConfig.semantic_search && isFastembedSemanticBackend) {
     const storageDir2 = configOverrides.storage_dir;
@@ -29912,7 +30112,7 @@ ${lines}
     warn2(`[lsp] auto-install setup failed: ${err instanceof Error ? err.message : String(err)}`);
   }
   let versionUpgradeAttempted = null;
-  const pool = new BridgePool(binaryPath, {
+  const poolOptions = {
     errorPrefix: "[aft-plugin]",
     minVersion: PLUGIN_VERSION,
     onVersionMismatch: (binaryVersion, minVersion) => {
@@ -29955,8 +30155,19 @@ ${lines}
         client: input.client,
         isActive: () => bridge.hasPendingRequests()
       }, completion);
+    },
+    onBashLongRunning: (reminder, bridge) => {
+      const sessionDir = getSessionDirectoryCached(reminder.session_id) ?? input.directory;
+      handlePushedBgLongRunning({
+        ctx,
+        directory: sessionDir,
+        sessionID: reminder.session_id,
+        client: input.client,
+        isActive: () => bridge.hasPendingRequests()
+      }, reminder);
     }
-  }, configOverrides);
+  };
+  const pool = new BridgePool(binaryPath, poolOptions, configOverrides);
   const ctx = {
     pool,
     client: input.client,
@@ -30032,10 +30243,10 @@ ${lines}
       return { show: false };
     }
     if (storageDir) {
-      const versionFile = join18(storageDir, "last_announced_version");
+      const versionFile = join19(storageDir, "last_announced_version");
       try {
-        if (existsSync13(versionFile)) {
-          const lastVersion = readFileSync9(versionFile, "utf-8").trim();
+        if (existsSync14(versionFile)) {
+          const lastVersion = readFileSync10(versionFile, "utf-8").trim();
           if (lastVersion === ANNOUNCEMENT_VERSION)
             return { show: false };
         }
@@ -30046,8 +30257,8 @@ ${lines}
   rpcServer.handle("mark-announced", async () => {
     if (storageDir && ANNOUNCEMENT_VERSION) {
       try {
-        mkdirSync10(storageDir, { recursive: true });
-        writeFileSync10(join18(storageDir, "last_announced_version"), ANNOUNCEMENT_VERSION);
+        mkdirSync11(storageDir, { recursive: true });
+        writeFileSync11(join19(storageDir, "last_announced_version"), ANNOUNCEMENT_VERSION);
       } catch {}
     }
     return { success: true };
@@ -30131,7 +30342,8 @@ Install: ${getManualInstallHint()}`).catch(() => {});
   const autoUpdateEventHook = createAutoUpdateCheckerHook(input, {
     enabled: true,
     autoUpdate: aftConfig.auto_update ?? true,
-    signal: autoUpdateAbort.signal
+    signal: autoUpdateAbort.signal,
+    storageDir: ctx.storageDir
   });
   const HINTS_TOOL_NAMES = [
     "aft_outline",