@cortexkit/aft-opencode 0.39.4 → 0.40.0

package/dist/index.js

@@ -11594,11 +11594,6 @@ function error(message, meta) {
   }
 }
 // ../aft-bridge/dist/bash-format.js
-function appendPipeStripNote(output, note) {
-  return note ? `${output}
-
-${note}` : output;
-}
 function formatSeconds(ms) {
   return `${Number((ms / 1000).toFixed(1))}s`;
 }
@@ -11676,12 +11671,16 @@ function maybeAppendGrepSearchHint(output, command, aftSearchRegistered, project
 ${hint}`;
 }
 function shouldSuppressGrepSearchHint(command, projectRoot) {
-  const root = projectRoot?.trim();
-  if (!root)
-    return false;
   const statements = splitTopLevelStatements(command);
   if (statements === null)
     return false;
+  if (allSearchPathOperandsAreDynamic(statements))
+    return true;
+  const root = projectRoot?.trim();
+  if (!root)
+    return false;
+  const resolvedRoot = path.resolve(root);
+  let effectiveCwd = resolvedRoot;
   let sawCodeSearchStatement = false;
   for (const statement of statements) {
     const firstStage = firstPipelineStage(statement);
@@ -11690,19 +11689,84 @@ function shouldSuppressGrepSearchHint(command, projectRoot) {
     const firstToken = readShellToken(firstStage, skipSpaces(firstStage, 0));
     if (firstToken === null)
       continue;
-    if (firstToken.token !== "grep" && firstToken.token !== "rg")
+    const head = firstToken.token;
+    if (head === "cd") {
+      effectiveCwd = nextCwdAfterCd(effectiveCwd, firstStage, firstToken.end);
+      continue;
+    }
+    if (head !== "grep" && head !== "rg")
       continue;
     sawCodeSearchStatement = true;
+    if (effectiveCwd === null)
+      continue;
+    if (!isDirInsideProject(resolvedRoot, effectiveCwd))
+      continue;
     const operands = collectPathOperands(firstStage, firstToken.end);
     if (operands.length === 0)
       return false;
     for (const operand of operands) {
-      if (isPathInsideProject(root, operand))
+      if (isDynamicPathOperand(operand))
+        continue;
+      if (isPathInsideProject(resolvedRoot, effectiveCwd, operand))
         return false;
     }
   }
   return sawCodeSearchStatement;
 }
+function allSearchPathOperandsAreDynamic(statements) {
+  let sawDynamicOnlySearch = false;
+  for (const statement of statements) {
+    const firstStage = firstPipelineStage(statement);
+    if (firstStage === null)
+      continue;
+    const firstToken = readShellToken(firstStage, skipSpaces(firstStage, 0));
+    if (firstToken === null)
+      continue;
+    const head = firstToken.token;
+    if (head !== "grep" && head !== "rg")
+      continue;
+    const operands = collectPathOperands(firstStage, firstToken.end);
+    if (operands.length === 0)
+      return false;
+    if (operands.some((operand) => !isDynamicPathOperand(operand)))
+      return false;
+    sawDynamicOnlySearch = true;
+  }
+  return sawDynamicOnlySearch;
+}
+function nextCwdAfterCd(currentCwd, firstStage, afterCd) {
+  let index = skipSpaces(firstStage, afterCd);
+  let target = null;
+  while (index < firstStage.length) {
+    const tokenResult = readShellToken(firstStage, index);
+    if (tokenResult === null)
+      break;
+    const { token, end } = tokenResult;
+    if (end <= index)
+      break;
+    index = skipSpaces(firstStage, end);
+    if (token === "-")
+      return null;
+    if (token.length > 1 && token.startsWith("-"))
+      continue;
+    target = token;
+    break;
+  }
+  if (target === null)
+    return path.resolve(os.homedir());
+  if (target.includes("$") || target.includes("`"))
+    return null;
+  const expanded = expandTilde(target);
+  if (path.isAbsolute(expanded))
+    return path.resolve(expanded);
+  if (currentCwd === null)
+    return null;
+  return path.resolve(currentCwd, expanded);
+}
+function isDirInsideProject(resolvedRoot, dir) {
+  const rel = path.relative(resolvedRoot, path.resolve(dir));
+  return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+}
 function collectPathOperands(firstStage, startAfterCommand) {
   const operands = [];
   let index = skipSpaces(firstStage, startAfterCommand);
@@ -11724,6 +11788,9 @@ function collectPathOperands(firstStage, startAfterCommand) {
 function looksLikePathOperand(token) {
   return token.includes("/") || token.startsWith("~") || token.startsWith("./") || token.startsWith("../");
 }
+function isDynamicPathOperand(token) {
+  return token.startsWith("~") || token.includes("$") || token.includes("`");
+}
 function expandTilde(target) {
   if (!target.startsWith("~"))
     return target;
@@ -11736,10 +11803,9 @@ function resolvePathOperand(projectRoot, operand) {
   const expanded = expandTilde(operand);
   return path.isAbsolute(expanded) ? path.resolve(expanded) : path.resolve(projectRoot, expanded);
 }
-function isPathInsideProject(projectRoot, operand) {
-  const root = path.resolve(projectRoot);
-  const resolved = resolvePathOperand(root, operand);
-  const rel = path.relative(root, resolved);
+function isPathInsideProject(resolvedRoot, baseCwd, operand) {
+  const resolved = resolvePathOperand(baseCwd, operand);
+  const rel = path.relative(resolvedRoot, resolved);
   return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
 }
 function splitTopLevelStatements(command) {
@@ -11932,6 +11998,7 @@ var LONG_RUNNING_COMMAND_TIMEOUT_MS = {
   trace_to_symbol: 60000,
   trace_data: 60000,
   impact: 60000,
+  inspect: 60000,
   grep: 60000,
   glob: 60000,
   semantic_search: 60000
@@ -11995,7 +12062,6 @@ ${formatStatusBar(counts)}`;
 // ../aft-bridge/dist/bridge.js
 var DEFAULT_BRIDGE_TIMEOUT_MS = 30000;
 var BRIDGE_HANG_TIMEOUT_THRESHOLD = 2;
-var SEMANTIC_TIMEOUT_SAFETY_MARGIN_MS = 5000;
 var MAX_STDOUT_BUFFER = 64 * 1024 * 1024;
 var STDOUT_BUFFER_COMPACT_THRESHOLD = 64 * 1024;
 var TERMINAL_BASH_STATUSES = new Set([
@@ -12068,28 +12134,19 @@ function compareSemver(a, b) {
   }
   return 0;
 }
-function clampSemanticTimeout(configOverrides, bridgeTimeoutMs) {
-  const semantic = configOverrides.semantic;
-  if (!semantic || typeof semantic !== "object" || Array.isArray(semantic)) {
-    return configOverrides;
-  }
-  const timeoutMs = semantic.timeout_ms;
-  if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs)) {
-    return configOverrides;
-  }
-  const semanticTransportBudgetMs = Math.max(bridgeTimeoutMs, LONG_RUNNING_COMMAND_TIMEOUT_MS.semantic_search ?? 0);
-  const maxSemanticTimeoutMs = semanticTransportBudgetMs > SEMANTIC_TIMEOUT_SAFETY_MARGIN_MS ? semanticTransportBudgetMs - SEMANTIC_TIMEOUT_SAFETY_MARGIN_MS : Math.max(1, semanticTransportBudgetMs - 1);
-  if (timeoutMs <= maxSemanticTimeoutMs) {
-    return configOverrides;
-  }
-  warn(`semantic.timeout_ms=${timeoutMs} exceeds the semantic transport budget; clamping to ${maxSemanticTimeoutMs}ms (budget: ${semanticTransportBudgetMs}ms)`);
-  return {
-    ...configOverrides,
-    semantic: {
-      ...semantic,
-      timeout_ms: maxSemanticTimeoutMs
+function coerceConfigureDroppedKeys(value) {
+  if (!Array.isArray(value))
+    return [];
+  const dropped = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object" || Array.isArray(item))
+      continue;
+    const record = item;
+    if (typeof record.key === "string" && typeof record.tier === "string" && typeof record.reason === "string") {
+      dropped.push({ key: record.key, tier: record.tier, reason: record.reason });
     }
-  };
+  }
+  return dropped;
 }
 
 class BridgeReplacedDuringVersionCheck extends Error {
@@ -12159,7 +12216,7 @@ class BinaryBridge {
     this.timeoutMs = options?.timeoutMs ?? DEFAULT_BRIDGE_TIMEOUT_MS;
     this.hangThreshold = options?.hangThreshold ?? BRIDGE_HANG_TIMEOUT_THRESHOLD;
     this.maxRestarts = options?.maxRestarts ?? 3;
-    this.configOverrides = clampSemanticTimeout(configOverrides ?? {}, this.timeoutMs);
+    this.configOverrides = configOverrides ?? {};
     this.minVersion = options?.minVersion;
     this.onVersionMismatch = options?.onVersionMismatch;
     this.onConfigureWarnings = options?.onConfigureWarnings;
@@ -12396,18 +12453,24 @@ class BinaryBridge {
     }
   }
   async deliverConfigureWarnings(configResult, params, options) {
-    if (!this.onConfigureWarnings || !Array.isArray(configResult.warnings))
+    if (!this.onConfigureWarnings)
       return;
-    if (configResult.warnings.length === 0)
+    const warnings = Array.isArray(configResult.warnings) ? configResult.warnings : [];
+    const configDroppedKeys = coerceConfigureDroppedKeys(configResult.config_dropped_keys);
+    if (warnings.length === 0 && configDroppedKeys.length === 0)
       return;
     const sessionId = typeof params.session_id === "string" ? params.session_id : undefined;
+    const context = {
+      projectRoot: this.cwd,
+      sessionId,
+      client: options?.configureWarningClient ?? (sessionId ? this.configureWarningClients.get(sessionId) : undefined),
+      warnings
+    };
+    if (configDroppedKeys.length > 0) {
+      context.configDroppedKeys = configDroppedKeys;
+    }
     try {
-      await this.onConfigureWarnings({
-        projectRoot: this.cwd,
-        sessionId,
-        client: options?.configureWarningClient ?? (sessionId ? this.configureWarningClients.get(sessionId) : undefined),
-        warnings: configResult.warnings
-      });
+      await this.onConfigureWarnings(context);
     } catch (err) {
       this.warnVia(`configure warning delivery failed: ${err instanceof Error ? err.message : String(err)}`);
     } finally {
@@ -13114,6 +13177,62 @@ function coerceStringArray(value) {
   }
   return [];
 }
+function coerceTargetParam(value) {
+  if (Array.isArray(value)) {
+    return value.filter((entry) => typeof entry === "string" && entry.length > 0);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+          return parsed.filter((entry) => typeof entry === "string" && entry.length > 0);
+        }
+      } catch {}
+    }
+    return value;
+  }
+  return value;
+}
+function coerceBoolean(value, defaultValue = false) {
+  if (defaultValue) {
+    if (value === undefined)
+      return true;
+    if (typeof value === "boolean")
+      return value;
+    if (typeof value === "number")
+      return value !== 0;
+    if (typeof value === "string") {
+      const normalized = value.trim().toLowerCase();
+      return normalized !== "false" && normalized !== "0";
+    }
+    return true;
+  }
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "number")
+    return value === 1;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    return normalized === "true" || normalized === "1";
+  }
+  return false;
+}
+function coerceOptionalInt(v, paramName, min, max) {
+  if (v === undefined || v === null || v === "")
+    return;
+  if (typeof v === "number" && (!Number.isFinite(v) || v === 0 && min > 0))
+    return;
+  const n = typeof v === "string" ? Number(v) : v;
+  if (typeof n !== "number" || !Number.isInteger(n)) {
+    throw new Error(`${paramName} must be an integer between ${min} and ${max}`);
+  }
+  if (n < min || n > max) {
+    throw new Error(`${paramName} must be between ${min} and ${max}`);
+  }
+  return n;
+}
 function isEmptyParam(value) {
   if (value === undefined || value === null)
     return true;
@@ -13125,10 +13244,43 @@ function isEmptyParam(value) {
     return Object.keys(value).length === 0;
   return false;
 }
+// ../aft-bridge/dist/config-tiers.js
+import { existsSync, readFileSync } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+function readConfigTiers(opts) {
+  const tiers = [];
+  try {
+    if (existsSync(opts.userConfigPath)) {
+      const doc = readFileSync(opts.userConfigPath, "utf-8");
+      tiers.push({
+        tier: "user",
+        source: resolve2(opts.userConfigPath),
+        doc
+      });
+    }
+  } catch {}
+  try {
+    if (existsSync(opts.projectConfigPath)) {
+      const doc = readFileSync(opts.projectConfigPath, "utf-8");
+      tiers.push({
+        tier: "project",
+        source: resolve2(opts.projectConfigPath),
+        doc
+      });
+    }
+  } catch {}
+  return tiers;
+}
+function formatDroppedKeyWarnings(dropped) {
+  if (!dropped || !Array.isArray(dropped)) {
+    return [];
+  }
+  return dropped.map((item) => `Ignoring ${item.key} from ${item.tier} config (${item.reason})`);
+}
 // ../aft-bridge/dist/downloader.js
 import { spawnSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
-import { chmodSync, closeSync, copyFileSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, unlinkSync, writeSync } from "node:fs";
+import { chmodSync, closeSync, copyFileSync, createWriteStream, existsSync as existsSync2, mkdirSync, openSync, readFileSync as readFileSync2, renameSync, rmSync, statSync, unlinkSync, writeSync } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { join as join3 } from "node:path";
 import { Readable } from "node:stream";
@@ -13200,7 +13352,7 @@ function getCachedBinaryPath(version) {
   if (!version)
     return null;
   const binaryPath = join3(getCacheDir(), version, getBinaryName());
-  return existsSync(binaryPath) ? binaryPath : null;
+  return existsSync2(binaryPath) ? binaryPath : null;
 }
 async function downloadBinary(version) {
   const archMap = PLATFORM_ARCH_MAP[process.platform] ?? {};
@@ -13219,7 +13371,7 @@ async function downloadBinary(version) {
   const versionedCacheDir = join3(getCacheDir(), tag);
   const binaryName = getBinaryName();
   const binaryPath = join3(versionedCacheDir, binaryName);
-  if (existsSync(binaryPath) && isExpectedCachedBinary(binaryPath, tag)) {
+  if (existsSync2(binaryPath) && isExpectedCachedBinary(binaryPath, tag)) {
     return binaryPath;
   }
   const downloadUrl = `https://github.com/${REPO}/releases/download/${tag}/${assetName}`;
@@ -13233,11 +13385,11 @@ async function downloadBinary(version) {
   let checksumTimeout = null;
   const tmpPath = `${binaryPath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
   try {
-    if (!existsSync(versionedCacheDir)) {
+    if (!existsSync2(versionedCacheDir)) {
       mkdirSync(versionedCacheDir, { recursive: true });
     }
     releaseLock = await acquireDownloadLock(lockPath);
-    if (existsSync(binaryPath) && isExpectedCachedBinary(binaryPath, tag)) {
+    if (existsSync2(binaryPath) && isExpectedCachedBinary(binaryPath, tag)) {
       return binaryPath;
     }
     binaryController = new AbortController;
@@ -13302,7 +13454,7 @@ async function downloadBinary(version) {
       renameSync(tmpPath, binaryPath);
     }
     try {
-      if (existsSync(tmpPath))
+      if (existsSync2(tmpPath))
         unlinkSync(tmpPath);
     } catch {
       warn(`Could not clean up temporary download file ${tmpPath} — it can be removed manually.`);
@@ -13312,7 +13464,7 @@ async function downloadBinary(version) {
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     error(`Failed to download AFT binary: ${msg}`);
-    if (existsSync(tmpPath)) {
+    if (existsSync2(tmpPath)) {
       try {
         unlinkSync(tmpPath);
       } catch {}
@@ -13356,7 +13508,7 @@ async function acquireDownloadLock(lockPath) {
           closeSync(fd);
         } catch {}
         try {
-          if (readFileSync(lockPath, "utf-8") === owner) {
+          if (readFileSync2(lockPath, "utf-8") === owner) {
             rmSync(lockPath, { force: true });
           }
         } catch {}
@@ -13377,7 +13529,7 @@ async function acquireDownloadLock(lockPath) {
       if (Date.now() - startedAt > DOWNLOAD_LOCK_TIMEOUT_MS) {
         throw new Error(`Timed out waiting for download lock: ${lockPath}`);
       }
-      await new Promise((resolve2) => setTimeout(resolve2, 100));
+      await new Promise((resolve3) => setTimeout(resolve3, 100));
     }
   }
 }
@@ -13474,20 +13626,71 @@ function stripJsoncSymbols(value) {
 }
 // ../aft-bridge/dist/migration.js
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync4, mkdirSync as mkdirSync4 } from "node:fs";
-import { homedir as homedir6, tmpdir } from "node:os";
-import { dirname as dirname2, join as join6 } from "node:path";
+import { closeSync as closeSync3, existsSync as existsSync5, mkdirSync as mkdirSync4, openSync as openSync3, readFileSync as readFileSync4, renameSync as renameSync4, rmSync as rmSync2, statSync as statSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir7, tmpdir } from "node:os";
+import { basename, dirname as dirname2, join as join6, resolve as resolve4 } from "node:path";
 
 // ../aft-bridge/dist/paths.js
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync } from "node:fs";
-import { dirname, join as join4 } from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { dirname, isAbsolute as isAbsolute2, join as join4, resolve as resolve3 } from "node:path";
+function homeDir() {
+  if (process.platform === "win32")
+    return process.env.USERPROFILE || process.env.HOME || homedir5();
+  return process.env.HOME || homedir5();
+}
+function configHome() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg && isAbsolute2(xdg))
+    return xdg;
+  return join4(homeDir(), ".config");
+}
+function legacyOpenCodeConfigDir() {
+  const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  if (envDir)
+    return resolve3(envDir);
+  return join4(configHome(), "opencode");
+}
+function legacyPiAgentDir() {
+  return join4(homeDir(), ".pi", "agent");
+}
+function legacySources(basePath, label, harness) {
+  return [
+    { path: `${basePath}.jsonc`, label: `${label} aft.jsonc`, harness },
+    { path: `${basePath}.json`, label: `${label} aft.json`, harness }
+  ];
+}
+function resolveCortexKitUserConfigPath() {
+  return join4(configHome(), "cortexkit", "aft.jsonc");
+}
+function resolveCortexKitProjectConfigPath(projectDirectory) {
+  return join4(projectDirectory, ".cortexkit", "aft.jsonc");
+}
+function resolveCortexKitConfigPaths(projectDirectory) {
+  return {
+    userConfigPath: resolveCortexKitUserConfigPath(),
+    projectConfigPath: resolveCortexKitProjectConfigPath(projectDirectory)
+  };
+}
+function resolveLegacyAftConfigSources(projectDirectory) {
+  return {
+    user: [
+      ...legacySources(join4(legacyOpenCodeConfigDir(), "aft"), "OpenCode user", "opencode"),
+      ...legacySources(join4(legacyPiAgentDir(), "aft"), "Pi user", "pi")
+    ],
+    project: [
+      ...legacySources(join4(projectDirectory, ".opencode", "aft"), "OpenCode project", "opencode"),
+      ...legacySources(join4(projectDirectory, ".pi", "aft"), "Pi project", "pi")
+    ]
+  };
+}
 function resolveHarnessStoragePath(storageRoot, harness, ...segments) {
   return join4(storageRoot, harness, ...segments);
 }
 function repairRootScopedStorageFile(storageRoot, harness, fileName) {
   const harnessPath = resolveHarnessStoragePath(storageRoot, harness, fileName);
   const rootPath = join4(storageRoot, fileName);
-  if (existsSync2(harnessPath) || !existsSync2(rootPath))
+  if (existsSync3(harnessPath) || !existsSync3(rootPath))
     return harnessPath;
   try {
     mkdirSync2(dirname(harnessPath), { recursive: true });
@@ -13501,8 +13704,8 @@ function shouldShowAnnouncement(storageRoot, harness, currentVersion) {
   const versionFile = repairRootScopedStorageFile(storageRoot, harness, "last_announced_version");
   let lastVersion = "";
   try {
-    if (existsSync2(versionFile)) {
-      lastVersion = readFileSync2(versionFile, "utf-8").trim();
+    if (existsSync3(versionFile)) {
+      lastVersion = readFileSync3(versionFile, "utf-8").trim();
     }
   } catch {
     return false;
@@ -13530,9 +13733,9 @@ function markAnnouncementSeen(storageRoot, harness, currentVersion) {
 
 // ../aft-bridge/dist/resolver.js
 import { execSync } from "node:child_process";
-import { chmodSync as chmodSync2, closeSync as closeSync2, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, openSync as openSync2, readSync, renameSync as renameSync3, unlinkSync as unlinkSync2 } from "node:fs";
+import { chmodSync as chmodSync2, closeSync as closeSync2, copyFileSync as copyFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3, openSync as openSync2, readSync, renameSync as renameSync3, unlinkSync as unlinkSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import { join as join5 } from "node:path";
 var ensureBinaryForResolver = ensureBinary;
 function copyToVersionedCache(npmBinaryPath, knownVersion) {
@@ -13545,7 +13748,7 @@ function copyToVersionedCache(npmBinaryPath, knownVersion) {
     const versionedDir = join5(cacheDir, tag);
     const ext = process.platform === "win32" ? ".exe" : "";
     const cachedPath = join5(versionedDir, `aft${ext}`);
-    if (existsSync3(cachedPath)) {
+    if (existsSync4(cachedPath)) {
       const cachedVersion = readBinaryVersion(cachedPath);
       if (cachedVersion === version)
         return cachedPath;
@@ -13557,7 +13760,7 @@ function copyToVersionedCache(npmBinaryPath, knownVersion) {
     if (process.platform !== "win32") {
       chmodSync2(tmpPath, 493);
     }
-    if (process.platform === "win32" && existsSync3(cachedPath)) {
+    if (process.platform === "win32" && existsSync4(cachedPath)) {
       try {
         unlinkSync2(cachedPath);
       } catch {}
@@ -13574,7 +13777,7 @@ function normalizeBareVersion(version) {
   return version.startsWith("v") ? version.slice(1) : version;
 }
 function homeDirFromEnv(env) {
-  return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir5();
+  return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir6();
 }
 function cacheDirFromEnv(env) {
   if (process.platform === "win32") {
@@ -13586,7 +13789,7 @@ function cacheDirFromEnv(env) {
 }
 function cachedBinaryPathFromEnv(version, env, ext) {
   const binaryPath = join5(cacheDirFromEnv(env), version, `aft${ext}`);
-  return existsSync3(binaryPath) ? binaryPath : null;
+  return existsSync4(binaryPath) ? binaryPath : null;
 }
 function isExpectedCachedBinary2(binaryPath, expectedVersion) {
   const expected = normalizeBareVersion(expectedVersion);
@@ -13675,7 +13878,7 @@ function findBinarySync(expectedVersion) {
     const packageBin = `@cortexkit/aft-${key}/bin/aft${ext}`;
     const req = createRequire2(import.meta.url);
     const resolved = req.resolve(packageBin);
-    if (existsSync3(resolved)) {
+    if (existsSync4(resolved)) {
       const npmVersion = readBinaryVersion(resolved);
       if (npmVersion === null) {
         warn(`npm platform package binary at ${resolved} did not report a version; skipping (continuing to PATH lookup)`);
@@ -13705,7 +13908,7 @@ function findBinarySync(expectedVersion) {
     }
   } catch {}
   const cargoPath = join5(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
-  if (existsSync3(cargoPath)) {
+  if (existsSync4(cargoPath)) {
     const usable = probeBinaryCandidate(cargoPath, "cargo", expectedVersion);
     if (usable)
       return usable;
@@ -13750,23 +13953,343 @@ function dataHome() {
   if (process.env.XDG_DATA_HOME)
     return process.env.XDG_DATA_HOME;
   if (process.platform === "win32") {
-    return process.env.LOCALAPPDATA || process.env.APPDATA || join6(homeDir(), "AppData", "Local");
+    return process.env.LOCALAPPDATA || process.env.APPDATA || join6(homeDir2(), "AppData", "Local");
   }
-  return join6(homeDir(), ".local", "share");
+  return join6(homeDir2(), ".local", "share");
 }
-function homeDir() {
+function homeDir2() {
   if (process.platform === "win32")
-    return process.env.USERPROFILE || process.env.HOME || homedir6();
-  return process.env.HOME || homedir6();
+    return process.env.USERPROFILE || process.env.HOME || homedir7();
+  return process.env.HOME || homedir7();
 }
 function resolveLegacyStorageRoot(harness) {
   if (harness === "pi")
-    return join6(homeDir(), ".pi", "agent", "aft");
+    return join6(homeDir2(), ".pi", "agent", "aft");
   return join6(dataHome(), "opencode", "storage", "plugin", "aft");
 }
 function resolveCortexKitStorageRoot() {
   return join6(dataHome(), "cortexkit", "aft");
 }
+function stripJsoncForParse(input) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0;i < input.length; i++) {
+    const ch = input[i];
+    const next = input[i + 1];
+    if (inString) {
+      out += ch;
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      while (i < input.length && input[i] !== `
+`)
+        i++;
+      out += `
+`;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i += 2;
+      while (i < input.length && !(input[i] === "*" && input[i + 1] === "/"))
+        i++;
+      i++;
+      out += " ";
+      continue;
+    }
+    out += ch;
+  }
+  let withoutTrailingCommas = "";
+  inString = false;
+  escaped = false;
+  for (let i = 0;i < out.length; i++) {
+    const ch = out[i];
+    if (inString) {
+      withoutTrailingCommas += ch;
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      withoutTrailingCommas += ch;
+      continue;
+    }
+    if (ch === ",") {
+      let j = i + 1;
+      while (j < out.length && /\s/.test(out[j]))
+        j++;
+      if (out[j] === "}" || out[j] === "]")
+        continue;
+    }
+    withoutTrailingCommas += ch;
+  }
+  return withoutTrailingCommas;
+}
+function sortJson(value) {
+  if (Array.isArray(value))
+    return value.map(sortJson);
+  if (value && typeof value === "object") {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      sorted[key] = sortJson(value[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function normalizedJsoncSemantics(content) {
+  return JSON.stringify(sortJson(JSON.parse(stripJsoncForParse(content))));
+}
+function fileSemanticsMatch(a, b) {
+  try {
+    return normalizedJsoncSemantics(a) === normalizedJsoncSemantics(b);
+  } catch {
+    return a === b;
+  }
+}
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function acquireConfigMigrationLock(lockDir) {
+  const deadline = Date.now() + 30000;
+  while (true) {
+    try {
+      mkdirSync4(lockDir, { recursive: false });
+      return () => {
+        try {
+          rmSync2(lockDir, { recursive: true, force: true });
+        } catch {}
+      };
+    } catch (err) {
+      const code = err?.code;
+      if (code !== "EEXIST")
+        throw err;
+      try {
+        const ageMs = Date.now() - statSync2(lockDir).mtimeMs;
+        if (ageMs > 60000) {
+          rmSync2(lockDir, { recursive: true, force: true });
+          continue;
+        }
+      } catch {}
+      if (Date.now() >= deadline) {
+        throw new Error(`timed out waiting for config migration lock ${lockDir}`);
+      }
+      sleepSync(25);
+    }
+  }
+}
+function atomicCopyConfigFile(sourcePath, targetPath) {
+  mkdirSync4(dirname2(targetPath), { recursive: true });
+  const tmpPath = join6(dirname2(targetPath), `.${basename(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+  let fd = null;
+  try {
+    fd = openSync3(tmpPath, "wx", 384);
+    writeFileSync2(fd, readFileSync4(sourcePath));
+    closeSync3(fd);
+    fd = null;
+    renameSync4(tmpPath, targetPath);
+  } catch (err) {
+    if (fd !== null) {
+      try {
+        closeSync3(fd);
+      } catch {}
+    }
+    try {
+      unlinkSync3(tmpPath);
+    } catch {}
+    throw err;
+  }
+}
+function atomicWriteConfigFile(targetPath, content) {
+  mkdirSync4(dirname2(targetPath), { recursive: true });
+  const tmpPath = join6(dirname2(targetPath), `.${basename(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+  let fd = null;
+  try {
+    fd = openSync3(tmpPath, "wx", 384);
+    writeFileSync2(fd, content);
+    closeSync3(fd);
+    fd = null;
+    renameSync4(tmpPath, targetPath);
+  } catch (err) {
+    if (fd !== null) {
+      try {
+        closeSync3(fd);
+      } catch {}
+    }
+    try {
+      unlinkSync3(tmpPath);
+    } catch {}
+    throw err;
+  }
+}
+var MOVED_MARKER_SUFFIX = ".MOVED_READPLEASE";
+function nonClobberingSidecarPath(desiredPath) {
+  if (!existsSync5(desiredPath))
+    return desiredPath;
+  for (let index = 1;index < Number.MAX_SAFE_INTEGER; index++) {
+    const candidate = `${desiredPath}.${index}`;
+    if (!existsSync5(candidate))
+      return candidate;
+  }
+  throw new Error(`could not find available preservation sidecar path for ${desiredPath}`);
+}
+function movedMarkerContent(targetPath, originalName, originalContent) {
+  const header = [
+    "// AFT configuration moved.",
+    "//",
+    "// AFT now reads its configuration from one shared CortexKit location",
+    "// instead of a per-agent path. The settings that were in this file have",
+    "// been moved to:",
+    "//",
+    `//     ${targetPath}`,
+    "//",
+    "// Edit that file to change AFT settings. This location is no longer read",
+    "// by AFT.",
+    "//",
+    `// To undo, rename this file back to "${originalName}" (and remove the`,
+    "// CortexKit copy above if you want this location to take precedence).",
+    "//",
+    "// Your original settings are preserved below for reference.",
+    "",
+    ""
+  ].join(`
+`);
+  return `${header}${originalContent}`;
+}
+function markLegacySourcesMovedAside(sources, targetPath, logger) {
+  const warnings = [];
+  const info = logger?.info ?? logger?.log;
+  for (const source of sources) {
+    const desiredMarkerPath = `${source.path}${MOVED_MARKER_SUFFIX}`;
+    const markerPath = nonClobberingSidecarPath(desiredMarkerPath);
+    try {
+      const original = readFileSync4(source.path, "utf-8");
+      if (markerPath !== desiredMarkerPath) {
+        logger?.warn?.(`Preserving existing legacy AFT marker ${desiredMarkerPath}; writing new marker to ${markerPath}`);
+      }
+      atomicWriteConfigFile(markerPath, movedMarkerContent(targetPath, basename(source.path), original));
+      unlinkSync3(source.path);
+      info?.(`Moved legacy AFT config ${source.path} aside to ${markerPath}; AFT now reads ${targetPath}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      warnings.push(`AFT could not move legacy config ${source.path} aside (${msg}); it is now stale and ignored. Delete it manually — AFT reads ${targetPath}.`);
+      logger?.warn?.(`Could not move legacy AFT config ${source.path} aside (${msg}); AFT reads ${targetPath}`);
+    }
+  }
+  return warnings;
+}
+var PRESERVED_OLD_SUFFIX = "_OLD";
+function preservedOldContent(losingHarness, winningHarness, targetPath, originalContent) {
+  const winnerLine = winningHarness ? `// configs differed, so ${winningHarness}'s config won (first harness to run the` : "// configs differed, so the config that was migrated first won and is the";
+  const header = [
+    `// AFT config from ${losingHarness} — preserved, NOT read.`,
+    "//",
+    "// AFT now reads one shared config for all harnesses. Your OpenCode and Pi",
+    winnerLine,
+    winningHarness ? "// migration) and is now the active config at:" : "// active config at:",
+    "//",
+    `//     ${targetPath}`,
+    "//",
+    `// This file holds ${losingHarness}'s previous settings. Merge anything you`,
+    "// want to keep into the active config above, then delete this file. AFT does",
+    "// not read this path.",
+    "",
+    ""
+  ].join(`
+`);
+  return `${header}${originalContent}`;
+}
+function preserveDifferingSourceAsOld(source, winningHarness, targetPath, logger) {
+  const losingHarness = source.harness ?? "pi";
+  const desiredOldPath = `${targetPath}.${losingHarness}${PRESERVED_OLD_SUFFIX}`;
+  const oldPath = nonClobberingSidecarPath(desiredOldPath);
+  try {
+    if (oldPath !== desiredOldPath) {
+      logger?.warn?.(`Preserving existing ${losingHarness} config sidecar ${desiredOldPath}; writing new preserved config to ${oldPath}`);
+    }
+    atomicWriteConfigFile(oldPath, preservedOldContent(losingHarness, winningHarness, targetPath, source.content));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger?.warn?.(`Could not preserve ${losingHarness} config as ${oldPath} (${msg})`);
+  }
+  const usingDesc = winningHarness ? `${winningHarness}'s config` : "the existing shared config";
+  return `AFT found different OpenCode and Pi configs during config unification. ` + `Using ${usingDesc} at ${targetPath}; preserved ${losingHarness}'s previous ` + `config at ${oldPath} — merge any settings you want to keep, then delete it.`;
+}
+function visibleConfigMigrationWarning(scope, targetPath, paths, reason) {
+  const uniquePaths = [...new Set([targetPath, ...paths])];
+  return `AFT ${scope} config migration refused: ${reason}. ` + `Legacy and CortexKit config paths collapse to one file, but AFT will not overwrite or merge them automatically. ` + `Please consolidate manually into ${targetPath}. Paths: ${uniquePaths.join(" ; ")}`;
+}
+function migrateAftConfigFile(opts) {
+  const warnings = [];
+  const resolvedTarget = resolve4(opts.targetPath);
+  const existingSources = opts.legacySources.filter((source) => existsSync5(source.path) && resolve4(source.path) !== resolvedTarget);
+  const info = opts.logger?.info ?? opts.logger?.log;
+  if (existingSources.length === 0) {
+    return { migrated: false, conflict: false, targetPath: opts.targetPath, warnings };
+  }
+  mkdirSync4(dirname2(opts.targetPath), { recursive: true });
+  const release = acquireConfigMigrationLock(`${opts.targetPath}.lock`);
+  try {
+    const sources = existingSources.map((source) => ({
+      ...source,
+      content: readFileSync4(source.path, "utf-8")
+    }));
+    if (existsSync5(opts.targetPath)) {
+      const targetContent = readFileSync4(opts.targetPath, "utf-8");
+      for (const source of sources) {
+        if (fileSemanticsMatch(source.content, targetContent))
+          continue;
+        warnings.push(preserveDifferingSourceAsOld(source, undefined, opts.targetPath, opts.logger));
+      }
+      info?.(`AFT ${opts.scope} config already present at ${opts.targetPath}; reconciled ${sources.length} legacy source(s)`);
+      warnings.push(...markLegacySourcesMovedAside(sources, opts.targetPath, opts.logger));
+      return { migrated: false, conflict: false, targetPath: opts.targetPath, warnings };
+    }
+    const winner = (opts.operatingHarness ? sources.find((source) => source.harness === opts.operatingHarness) : undefined) ?? sources[0];
+    atomicCopyConfigFile(winner.path, opts.targetPath);
+    info?.(`Migrated AFT ${opts.scope} config from ${winner.path} to ${opts.targetPath}`);
+    for (const source of sources) {
+      if (source.path === winner.path)
+        continue;
+      if (fileSemanticsMatch(source.content, winner.content))
+        continue;
+      warnings.push(preserveDifferingSourceAsOld(source, winner.harness, opts.targetPath, opts.logger));
+    }
+    warnings.push(...markLegacySourcesMovedAside(sources, opts.targetPath, opts.logger));
+    return {
+      migrated: true,
+      conflict: false,
+      sourcePath: winner.path,
+      targetPath: opts.targetPath,
+      warnings
+    };
+  } catch (err) {
+    const message = visibleConfigMigrationWarning(opts.scope, opts.targetPath, existingSources.map((source) => source.path), `migration failed (${err instanceof Error ? err.message : String(err)})`);
+    warnings.push(message);
+    opts.logger?.warn?.(message);
+    return { migrated: false, conflict: true, targetPath: opts.targetPath, warnings };
+  } finally {
+    release();
+  }
+}
 function tail(value) {
   if (!value)
     return "";
@@ -13794,11 +14317,11 @@ async function ensureStorageMigrated(opts) {
   const newRoot = resolveCortexKitStorageRoot();
   const targetMarker = resolveHarnessStoragePath(newRoot, opts.harness, TARGET_MARKER);
   const info = opts.logger?.info ?? opts.logger?.log;
-  if (existsSync4(targetMarker)) {
+  if (existsSync5(targetMarker)) {
     info?.(`AFT storage already migrated for ${opts.harness}; using ${newRoot}`);
     return;
   }
-  if (!existsSync4(legacyRoot)) {
+  if (!existsSync5(legacyRoot)) {
     info?.(`AFT storage migration skipped for ${opts.harness}: no legacy data at ${legacyRoot}; ` + `using ${newRoot} for fresh install`);
     return;
   }
@@ -13846,14 +14369,14 @@ async function ensureStorageMigrated(opts) {
   throw new Error(`AFT storage migration failed (${detail}). ` + `Harness: ${opts.harness}. Legacy: ${legacyRoot}. Target: ${newRoot}. ` + `See log: ${logPath}. ` + `Plugin load aborted to prevent legacy/new state divergence.` + (stderrTail ? ` Stderr tail: ${stderrTail}` : "") + (stdoutTail ? ` Stdout tail: ${stdoutTail}` : ""));
 }
 // ../aft-bridge/dist/npm-resolver.js
-import { readdirSync, statSync as statSync2 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import { delimiter, dirname as dirname3, isAbsolute as isAbsolute2, join as join7 } from "node:path";
+import { readdirSync, statSync as statSync3 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { delimiter, dirname as dirname3, isAbsolute as isAbsolute3, join as join7 } from "node:path";
 function defaultDeps() {
   return {
     platform: process.platform,
     env: process.env,
-    home: homedir7(),
+    home: homedir8(),
     execPath: process.execPath
   };
 }
@@ -13862,7 +14385,7 @@ function npmBinaryName(platform) {
 }
 function isFile(p) {
   try {
-    return statSync2(p).isFile();
+    return statSync3(p).isFile();
   } catch {
     return false;
   }
@@ -13872,7 +14395,7 @@ function npmFromPath(deps) {
   const raw = deps.env.PATH ?? deps.env.Path ?? "";
   for (const entry of raw.split(delimiter)) {
     const dir = entry.trim().replace(/^"|"$/g, "");
-    if (!dir || !isAbsolute2(dir))
+    if (!dir || !isAbsolute3(dir))
       continue;
     if (isFile(join7(dir, name)))
       return dir;
@@ -13965,8 +14488,8 @@ function isNpmAvailable(deps = defaultDeps()) {
 // ../aft-bridge/dist/onnx-runtime.js
 import { execFileSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { chmodSync as chmodSync3, closeSync as closeSync3, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync5, openSync as openSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, readlinkSync, realpathSync, rmSync as rmSync2, statSync as statSync3, symlinkSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename, dirname as dirname4, isAbsolute as isAbsolute3, join as join8, relative as relative2, resolve as resolve2, win32 } from "node:path";
+import { chmodSync as chmodSync3, closeSync as closeSync4, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync5, openSync as openSync4, readdirSync as readdirSync2, readFileSync as readFileSync5, readlinkSync, realpathSync, rmSync as rmSync3, statSync as statSync4, symlinkSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute4, join as join8, relative as relative2, resolve as resolve5, win32 } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
 var ORT_VERSION = "1.24.4";
@@ -14036,7 +14559,7 @@ async function ensureOnnxRuntime(storageDir) {
   const libName = info?.libName ?? "libonnxruntime.dylib";
   const resolvedOrtDir = resolveCachedOnnxRuntimeDir(ortVersionDir, libName);
   const libPath = join8(resolvedOrtDir, libName);
-  if (existsSync5(libPath)) {
+  if (existsSync6(libPath)) {
     const meta = readOnnxInstalledMeta(ortVersionDir);
     if (meta?.sha256) {
       try {
@@ -14098,7 +14621,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
             abandoned = true;
           } else {
             try {
-              const ageMs = Date.now() - statSync3(stagingDir).mtimeMs;
+              const ageMs = Date.now() - statSync4(stagingDir).mtimeMs;
               abandoned = ageMs > STALE_LOCK_MS;
             } catch {
               abandoned = true;
@@ -14113,7 +14636,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
       if (abandoned) {
         log(`[onnx] removing abandoned staging dir ${stagingDir}`);
         try {
-          rmSync2(stagingDir, { recursive: true, force: true });
+          rmSync3(stagingDir, { recursive: true, force: true });
         } catch (err) {
           warn(`[onnx] failed to remove ${stagingDir}: ${err}`);
         }
@@ -14123,9 +14646,9 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
 }
 function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
-    if (existsSync5(ortDir) && !existsSync5(join8(ortDir, ONNX_INSTALLED_META_FILE))) {
+    if (existsSync6(ortDir) && !existsSync6(join8(ortDir, ONNX_INSTALLED_META_FILE))) {
       log(`[onnx] removing half-populated install dir ${ortDir} (no meta file)`);
-      rmSync2(ortDir, { recursive: true, force: true });
+      rmSync3(ortDir, { recursive: true, force: true });
     }
   } catch (err) {
     warn(`[onnx] failed to sweep ${ortDir}: ${err}`);
@@ -14135,7 +14658,7 @@ var REQUIRED_ORT_MAJOR = 1;
 var REQUIRED_ORT_MIN_MINOR = 20;
 var INVALID_ORT_VERSION = "<invalid>";
 function parseOnnxVersionFromPath(value) {
-  const name = basename(value);
+  const name = basename2(value);
   const semverish = name.match(/(?:^|[._-])(\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?)(?:\.(?:dylib|dll))?$/);
   if (semverish)
     return semverish[1].split(/[-+]/, 1)[0];
@@ -14152,7 +14675,7 @@ function parseOnnxVersionFromDirectoryPath(value) {
 }
 function isPathInsideRoot(root, candidate) {
   const rel = relative2(root, candidate);
-  return rel === "" || !rel.startsWith("../") && !rel.startsWith("..\\") && rel !== ".." && !isAbsolute3(rel) && !win32.isAbsolute(rel);
+  return rel === "" || !rel.startsWith("../") && !rel.startsWith("..\\") && rel !== ".." && !isAbsolute4(rel) && !win32.isAbsolute(rel);
 }
 function detectOnnxVersion(libDir, libName) {
   try {
@@ -14168,7 +14691,7 @@ function detectOnnxVersion(libDir, libName) {
         return version;
     }
     const base = join8(libDir, libName);
-    if (existsSync5(base)) {
+    if (existsSync6(base)) {
       try {
         const real = realpathSync(base);
         const version = parseOnnxVersionFromPath(real) ?? parseOnnxVersionFromDirectoryPath(real);
@@ -14203,7 +14726,7 @@ function pathEntriesForPlatform() {
   return pathEnvValue().split(delimiter2).map((entry) => entry.trim().replace(/^"|"$/g, "")).filter((entry) => {
     if (!entry || entry === "." || entry.includes("\x00"))
       return false;
-    return isAbsolute3(entry) || win32.isAbsolute(entry);
+    return isAbsolute4(entry) || win32.isAbsolute(entry);
   });
 }
 function directoryContainsLibrary(dir, libName) {
@@ -14219,10 +14742,10 @@ function directoryContainsLibrary(dir, libName) {
   }
 }
 function resolveCachedOnnxRuntimeDir(ortVersionDir, libName) {
-  if (existsSync5(join8(ortVersionDir, libName)))
+  if (existsSync6(join8(ortVersionDir, libName)))
     return ortVersionDir;
   const libSubdir = join8(ortVersionDir, "lib");
-  if (existsSync5(join8(libSubdir, libName)))
+  if (existsSync6(join8(libSubdir, libName)))
     return libSubdir;
   return ortVersionDir;
 }
@@ -14243,7 +14766,7 @@ function findSystemOnnxRuntime(libName) {
       if (!userProfile)
         return nugetPaths;
       const nugetPackageDir = join8(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
-      if (!existsSync5(nugetPackageDir))
+      if (!existsSync6(nugetPackageDir))
         return nugetPaths;
       try {
         for (const entry of readdirSync2(nugetPackageDir, { withFileTypes: true })) {
@@ -14263,7 +14786,7 @@ function findSystemOnnxRuntime(libName) {
   const normalizeCase = process.platform === "win32" || process.platform === "darwin";
   const seen = new Set;
   const uniquePaths = searchPaths.filter((p) => {
-    let key = resolve2(p).replace(/[/\\]+$/, "");
+    let key = resolve5(p).replace(/[/\\]+$/, "");
     if (normalizeCase)
       key = key.toLowerCase();
     if (seen.has(key))
@@ -14277,7 +14800,7 @@ function findSystemOnnxRuntime(libName) {
     if (process.platform === "win32") {
       if (!directoryContainsLibrary(dir, libName))
         continue;
-    } else if (!existsSync5(libPath)) {
+    } else if (!existsSync6(libPath)) {
       continue;
     }
     const version = detectOnnxVersion(dir, libName);
@@ -14326,7 +14849,7 @@ async function downloadFileWithCap(url, destPath) {
     await pipeline2(nodeStream, createWriteStream2(destPath), { signal: controller.signal });
   } catch (err) {
     try {
-      unlinkSync3(destPath);
+      unlinkSync4(destPath);
     } catch {}
     throw err;
   } finally {
@@ -14343,15 +14866,15 @@ function validateExtractedTree(stagingRoot) {
       const lst = lstatSync(fullPath);
       if (lst.isSymbolicLink()) {
         const linkTarget = readlinkSync(fullPath);
-        const resolvedTarget = resolve2(dirname4(fullPath), linkTarget);
+        const resolvedTarget = resolve5(dirname4(fullPath), linkTarget);
         const rel2 = relative2(realRoot, resolvedTarget);
-        if (rel2.startsWith("..") || isAbsolute3(rel2) || win32.isAbsolute(rel2)) {
+        if (rel2.startsWith("..") || isAbsolute4(rel2) || win32.isAbsolute(rel2)) {
           throw new Error(`extracted symlink ${fullPath} points outside staging root: ${linkTarget}`);
         }
         continue;
       }
       const rel = relative2(realRoot, fullPath);
-      if (rel.startsWith("..") || isAbsolute3(rel) || win32.isAbsolute(rel)) {
+      if (rel.startsWith("..") || isAbsolute4(rel) || win32.isAbsolute(rel)) {
         throw new Error(`extracted entry ${fullPath} escapes staging root`);
       }
       if (lst.isDirectory()) {
@@ -14387,11 +14910,11 @@ async function downloadOnnxRuntime(info, targetDir) {
       await extractZipArchive(archivePath, tmpDir);
     }
     try {
-      unlinkSync3(archivePath);
+      unlinkSync4(archivePath);
     } catch {}
     validateExtractedTree(tmpDir);
     const extractedDir = join8(tmpDir, info.assetName, "lib");
-    if (!existsSync5(extractedDir)) {
+    if (!existsSync6(extractedDir)) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
     mkdirSync5(targetDir, { recursive: true });
@@ -14422,16 +14945,16 @@ async function downloadOnnxRuntime(info, targetDir) {
       warn(`Could not hash newly-installed ONNX library at ${libPath}: ${err}`);
     }
     writeOnnxInstalledMeta(targetDir, ORT_VERSION, libHash, archiveSha256);
-    rmSync2(tmpDir, { recursive: true, force: true });
+    rmSync3(tmpDir, { recursive: true, force: true });
     log(`ONNX Runtime v${ORT_VERSION} installed to ${targetDir}`);
     return targetDir;
   } catch (err) {
     error(`Failed to download ONNX Runtime: ${err}`);
     try {
-      rmSync2(tmpDir, { recursive: true, force: true });
+      rmSync3(tmpDir, { recursive: true, force: true });
     } catch {}
     try {
-      rmSync2(targetDir, { recursive: true, force: true });
+      rmSync3(targetDir, { recursive: true, force: true });
     } catch {}
     return null;
   }
@@ -14448,7 +14971,7 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       }
     } catch (copyErr) {
       if (requiredLibs.has(libFile)) {
-        rmSync2(targetDir, { recursive: true, force: true });
+        rmSync3(targetDir, { recursive: true, force: true });
         throw copyErr;
       }
       log(`ORT extract: failed to copy optional ${libFile}: ${copyErr}`);
@@ -14458,14 +14981,14 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
   for (const link of symlinks) {
     const dst = join8(targetDir, link.name);
     try {
-      unlinkSync3(dst);
+      unlinkSync4(dst);
     } catch {}
     const dstForContainment = join8(targetRoot, link.name);
-    const resolvedTarget = resolve2(dirname4(dstForContainment), link.target);
+    const resolvedTarget = resolve5(dirname4(dstForContainment), link.target);
     if (!isPathInsideRoot(targetRoot, resolvedTarget)) {
       const message = `ONNX Runtime symlink ${link.name} points outside install dir: ${link.target}`;
       if (requiredLibs.has(link.name)) {
-        rmSync2(targetDir, { recursive: true, force: true });
+        rmSync3(targetDir, { recursive: true, force: true });
         throw new Error(message);
       }
       log(`ORT extract: skipping optional symlink ${link.name}: ${message}`);
@@ -14475,15 +14998,15 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       symlinkSync(link.target, dst);
     } catch (symlinkErr) {
       if (requiredLibs.has(link.name)) {
-        rmSync2(targetDir, { recursive: true, force: true });
+        rmSync3(targetDir, { recursive: true, force: true });
         throw symlinkErr;
       }
       log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
     }
   }
   const requiredPath = join8(targetDir, info.libName);
-  if (!existsSync5(requiredPath)) {
-    rmSync2(targetDir, { recursive: true, force: true });
+  if (!existsSync6(requiredPath)) {
+    rmSync3(targetDir, { recursive: true, force: true });
     throw new Error(`Required ONNX Runtime library missing after install: ${requiredPath}`);
   }
 }
@@ -14508,7 +15031,7 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
       ...sha256 ? { sha256 } : {},
       archiveSha256
     };
-    writeFileSync2(join8(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync3(join8(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
   } catch (err) {
     log(`[onnx] failed to write installed-meta in ${installDir}: ${err}`);
   }
@@ -14516,9 +15039,9 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
 function readOnnxInstalledMeta(installDir) {
   const path2 = join8(installDir, ONNX_INSTALLED_META_FILE);
   try {
-    if (!statSync3(path2).isFile())
+    if (!statSync4(path2).isFile())
       return null;
-    const raw = readFileSync3(path2, "utf8");
+    const raw = readFileSync5(path2, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
@@ -14534,19 +15057,19 @@ function readOnnxInstalledMeta(installDir) {
 }
 function sha256File(path2) {
   const hash = createHash2("sha256");
-  hash.update(readFileSync3(path2));
+  hash.update(readFileSync5(path2));
   return hash.digest("hex");
 }
 function acquireLock(lockPath) {
   const tryClaim = () => {
     try {
-      const fd = openSync3(lockPath, "wx");
+      const fd = openSync4(lockPath, "wx");
       try {
-        writeFileSync2(fd, `${process.pid}
+        writeFileSync3(fd, `${process.pid}
 ${new Date().toISOString()}
 `);
       } finally {
-        closeSync3(fd);
+        closeSync4(fd);
       }
       return true;
     } catch (err) {
@@ -14562,12 +15085,12 @@ ${new Date().toISOString()}
   let owningPid = null;
   let lockMtimeMs = 0;
   try {
-    const raw = readFileSync3(lockPath, "utf8");
+    const raw = readFileSync5(lockPath, "utf8");
     const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
     const parsed = Number.parseInt(firstLine, 10);
     if (Number.isFinite(parsed) && parsed > 0)
       owningPid = parsed;
-    lockMtimeMs = statSync3(lockPath).mtimeMs;
+    lockMtimeMs = statSync4(lockPath).mtimeMs;
   } catch {
     return tryClaim();
   }
@@ -14579,7 +15102,7 @@ ${new Date().toISOString()}
   }
   log(`[onnx] reclaiming install lock (owner_pid=${owningPid ?? "unknown"}, alive=${ownerAlive}, age_ms=${age})`);
   try {
-    unlinkSync3(lockPath);
+    unlinkSync4(lockPath);
   } catch {}
   return tryClaim();
 }
@@ -14587,7 +15110,7 @@ function releaseLock(lockPath) {
   try {
     let owningPid = null;
     try {
-      const raw = readFileSync3(lockPath, "utf8");
+      const raw = readFileSync5(lockPath, "utf8");
       const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
       const parsed = Number.parseInt(firstLine, 10);
       if (Number.isFinite(parsed) && parsed > 0)
@@ -14599,601 +15122,93 @@ function releaseLock(lockPath) {
       warn(`[onnx] could not read lock ${lockPath} during release: ${readErr}`);
       return;
     }
-    if (owningPid !== process.pid) {
-      log(`[onnx] not releasing lock ${lockPath}: owned by pid ${owningPid ?? "unknown"} (we are ${process.pid})`);
-      return;
-    }
-    try {
-      unlinkSync3(lockPath);
-    } catch (unlinkErr) {
-      const code = unlinkErr.code;
-      if (code !== "ENOENT") {
-        warn(`[onnx] failed to release lock ${lockPath}: ${unlinkErr}`);
-      }
-    }
-  } catch (err) {
-    warn(`[onnx] unexpected error releasing lock ${lockPath}: ${err}`);
-  }
-}
-function tasklistPidFromCsvLine(line) {
-  const quoted = line.match(/"([^"]*)"/g);
-  if (quoted && quoted.length >= 2)
-    return quoted[1].slice(1, -1);
-  const cells = line.split(",").map((cell) => cell.trim().replace(/^"|"$/g, ""));
-  return cells[1] ?? null;
-}
-function isWindowsProcessAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0)
-    return false;
-  try {
-    const output = execFileSync("tasklist.exe", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
-      encoding: "utf8",
-      timeout: 2000,
-      windowsHide: true
-    });
-    const expected = String(pid);
-    return output.split(/\r?\n/).some((line) => tasklistPidFromCsvLine(line) === expected);
-  } catch {
-    return false;
-  }
-}
-function isProcessAlive(pid) {
-  if (process.platform === "win32")
-    return isWindowsProcessAlive(pid);
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    const code = err.code;
-    if (code === "ESRCH")
-      return false;
-    return true;
-  }
-}
-// ../aft-bridge/dist/pipe-strip.js
-var NOISE_FILTERS = new Set([
-  "grep",
-  "rg",
-  "head",
-  "tail",
-  "cat",
-  "less",
-  "more",
-  "sed",
-  "awk",
-  "cut",
-  "sort",
-  "uniq",
-  "tr",
-  "column",
-  "fold"
-]);
-var GREP_GUARD_FLAGS = new Set([
-  "c",
-  "count",
-  "q",
-  "quiet",
-  "o",
-  "only-matching",
-  "l",
-  "files-with-matches"
-]);
-function maybeStripCompressorPipe(command, compressionEnabled) {
-  if (!compressionEnabled)
-    return { command, stripped: false };
-  const chain = splitTopLevelCommandChain(command);
-  if (chain === null)
-    return { command, stripped: false };
-  let stripped = false;
-  const droppedFilterChains = [];
-  const rebuilt = chain.map(({ segment, separator }) => {
-    const result = stripSinglePipelineSegment(segment);
-    if (result.stripped) {
-      stripped = true;
-      droppedFilterChains.push(result.filters);
-    }
-    return `${result.segment}${separator}`;
-  }).join("");
-  if (!stripped)
-    return { command, stripped: false };
-  return {
-    command: rebuilt,
-    stripped: true,
-    note: formatStripNote(droppedFilterChains)
-  };
-}
-function stripSinglePipelineSegment(segment) {
-  const leading = /^\s*/.exec(segment)?.[0] ?? "";
-  const trailing = /\s*$/.exec(segment)?.[0] ?? "";
-  const coreStart = leading.length;
-  const coreEnd = segment.length - trailing.length;
-  if (coreEnd <= coreStart)
-    return { segment, stripped: false };
-  const core = segment.slice(coreStart, coreEnd);
-  if (containsUnsplittableConstruct(core))
-    return { segment, stripped: false };
-  if (hasUnquotedBackground(core))
-    return { segment, stripped: false };
-  const stages = splitTopLevelPipeline(core);
-  if (stages.length < 2)
-    return { segment, stripped: false };
-  const firstStage = stages[0]?.trim() ?? "";
-  if (!isCompressorHandledRunner(firstStage))
-    return { segment, stripped: false };
-  const filterStages = stages.slice(1).map((stage) => stage.trim());
-  for (const stage of filterStages) {
-    if (!filterStageIsSafeToDrop(stage))
-      return { segment, stripped: false };
-  }
-  return {
-    segment: `${leading}${firstStage}${trailing}`,
-    stripped: true,
-    filters: filterStages.join(" | ")
-  };
-}
-function formatStripNote(droppedFilterChains) {
-  const filters = droppedFilterChains.map((filter) => `\`| ${filter}\``).join(", ");
-  return `[AFT dropped ${filters} (compressed:false to keep)]`;
-}
-function splitTopLevelCommandChain(command) {
-  const segments = [];
-  let start = 0;
-  let quote = null;
-  let escaped = false;
-  let inBacktick = false;
-  let parenDepth = 0;
-  for (let index = 0;index < command.length; index++) {
-    const char = command[index];
-    const next = command[index + 1];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (inBacktick) {
-      if (char === "\\")
-        escaped = true;
-      else if (char === "`")
-        inBacktick = false;
-      continue;
-    }
-    if (char === "\\" && quote !== "'") {
-      escaped = true;
-      continue;
-    }
-    if (quote) {
-      if (char === quote)
-        quote = null;
-      continue;
-    }
-    if (char === "'" || char === '"') {
-      quote = char;
-      continue;
-    }
-    if (char === "`") {
-      inBacktick = true;
-      continue;
-    }
-    if (char === "(") {
-      parenDepth++;
-      continue;
-    }
-    if (char === ")") {
-      if (parenDepth === 0)
-        return null;
-      parenDepth--;
-      continue;
-    }
-    if (parenDepth > 0)
-      continue;
-    if (char === `
-` || char === "\r")
-      return null;
-    if (char === "#" && (index === 0 || command[index - 1] === " " || command[index - 1] === "\t"))
-      return null;
-    if (char === "&" && next === "&") {
-      segments.push({ segment: command.slice(start, index), separator: "&&" });
-      start = index + 2;
-      index++;
-      continue;
-    }
-    if (char === "|" && next === "|") {
-      segments.push({ segment: command.slice(start, index), separator: "||" });
-      start = index + 2;
-      index++;
-      continue;
-    }
-    if (char === ";") {
-      segments.push({ segment: command.slice(start, index), separator: ";" });
-      start = index + 1;
-    }
-  }
-  if (escaped || quote || inBacktick || parenDepth !== 0)
-    return null;
-  segments.push({ segment: command.slice(start), separator: "" });
-  return segments;
-}
-function splitTopLevelPipeline(command) {
-  const stages = [];
-  let start = 0;
-  let quote = null;
-  let escaped = false;
-  for (let index = 0;index < command.length; index++) {
-    const char = command[index];
-    const next = command[index + 1];
-    const previous = command[index - 1];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (char === "\\" && quote !== "'") {
-      escaped = true;
-      continue;
-    }
-    if (quote) {
-      if (char === quote)
-        quote = null;
-      continue;
-    }
-    if (char === "'" || char === '"') {
-      quote = char;
-      continue;
-    }
-    if (char === "|" && previous !== "|" && next !== "|") {
-      stages.push(command.slice(start, index));
-      start = index + 1;
-    }
-  }
-  stages.push(command.slice(start));
-  return stages;
-}
-function isCompressorHandledRunner(stage) {
-  const tokens = tokenizeStage(stage);
-  if (tokens.length === 0)
-    return false;
-  if (tokens.some((token) => token === "&&" || token === "||" || token.includes(";"))) {
-    return false;
-  }
-  let tokenOffset = 0;
-  while (tokenOffset < tokens.length && isEnvAssignment(tokens[tokenOffset])) {
-    tokenOffset++;
-  }
-  const first = runnerName(tokens[tokenOffset]);
-  const runnerArgs = tokens.slice(tokenOffset + 1);
-  const second = runnerArgs[0];
-  const third = runnerArgs[1];
-  const rest = runnerArgs;
-  if (!first)
-    return false;
-  if (first === "bun") {
-    let args = rest;
-    if (args[0] === "--cwd")
-      args = args.slice(2);
-    else if (args[0]?.startsWith("--cwd="))
-      args = args.slice(1);
-    const sub = args[0];
-    const subNext = args[1];
-    return sub === "test" || sub === "run" && isJsVerificationScript(subNext);
-  }
-  if (first === "npm" || first === "pnpm") {
-    return second === "test" || second === "run" && isJsVerificationScript(third);
-  }
-  if (first === "yarn") {
-    return isJsVerificationScript(second) || second === "run" && isJsVerificationScript(third);
-  }
-  if (first === "deno")
-    return ["test", "lint", "check", "bench"].includes(second ?? "");
-  if (first === "npx") {
-    return ["tsc", "eslint", "vitest", "jest", "playwright", "biome"].includes(second ?? "");
-  }
-  if (first === "playwright")
-    return second === "test";
-  if (first === "cargo") {
-    return ["test", "build", "check", "clippy", "nextest"].includes(second ?? "");
-  }
-  if (first === "go")
-    return ["test", "build", "vet"].includes(second ?? "");
-  if (first === "gradle" || first === "gradlew") {
-    return hasBuildTask(rest, ["test", "check", "build", "assemble", "clean"]);
-  }
-  if (first === "mvn" || first === "mvnw") {
-    return hasBuildTask(rest, ["test", "verify", "package", "install", "clean"]);
-  }
-  if (first === "dotnet")
-    return ["test", "build"].includes(second ?? "");
-  if (first === "rspec")
-    return true;
-  if (first === "rake") {
-    const positionals = rest.filter((a) => !a.startsWith("-"));
-    if (positionals.length === 0)
-      return false;
-    if (positionals.some((a) => a.includes("/") || a.includes(".") || a.includes("=")))
-      return false;
-    return positionals.some((a) => a === "test" || a === "spec");
-  }
-  if (first === "phpunit" || first === "pest")
-    return true;
-  if (first === "xcodebuild")
-    return xcodebuildHasBuildAction(rest);
-  if (first === "swift")
-    return second === "test" || second === "build";
-  if (first === "make" || first === "gmake") {
-    return hasBuildTask(rest, ["test", "check", "lint", "clean"]);
-  }
-  return [
-    "vitest",
-    "jest",
-    "pytest",
-    "tsc",
-    "eslint",
-    "biome",
-    "ruff",
-    "mypy",
-    "tox",
-    "nox"
-  ].includes(first);
-}
-function isEnvAssignment(token) {
-  if (!token)
-    return false;
-  return /^[a-zA-Z_][a-zA-Z0-9_]*=/.test(token);
-}
-function runnerName(token) {
-  if (!token)
-    return "";
-  const slash = token.lastIndexOf("/");
-  return slash === -1 ? token : token.slice(slash + 1);
-}
-function hasBuildTask(args, tasks) {
-  const isAllowedTask = (arg) => tasks.some((task) => arg === task || arg.endsWith(`:${task}`));
-  const isFlagOrProperty = (arg) => arg.startsWith("-") || arg.includes("=");
-  let sawAllowed = false;
-  for (const arg of args) {
-    if (isFlagOrProperty(arg))
-      continue;
-    if (!isAllowedTask(arg))
-      return false;
-    sawAllowed = true;
-  }
-  return sawAllowed;
-}
-function isJsVerificationScript(token) {
-  if (!token)
-    return false;
-  return token.startsWith("test") || token === "typecheck" || token.startsWith("typecheck:");
-}
-var XCODEBUILD_VALUE_FLAGS = new Set([
-  "-scheme",
-  "-target",
-  "-project",
-  "-workspace",
-  "-configuration",
-  "-sdk",
-  "-destination",
-  "-arch",
-  "-derivedDataPath",
-  "-resultBundlePath",
-  "-xcconfig",
-  "-toolchain"
-]);
-var XCODEBUILD_BUILD_ACTIONS = new Set([
-  "build",
-  "test",
-  "build-for-testing",
-  "test-without-building",
-  "analyze"
-]);
-function xcodebuildHasBuildAction(args) {
-  for (let i = 0;i < args.length; i++) {
-    const arg = args[i];
-    if (arg.startsWith("-")) {
-      if (XCODEBUILD_VALUE_FLAGS.has(arg))
-        i++;
-      continue;
-    }
-    if (XCODEBUILD_BUILD_ACTIONS.has(arg))
-      return true;
-  }
-  return false;
-}
-function containsUnsplittableConstruct(command) {
-  let quote = null;
-  let escaped = false;
-  for (let i = 0;i < command.length; i++) {
-    const char = command[i];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (char === "\\" && quote !== "'") {
-      escaped = true;
-      continue;
-    }
-    if (quote === "'") {
-      if (char === "'")
-        quote = null;
-      continue;
-    }
-    if (quote === '"') {
-      if (char === '"')
-        quote = null;
-      else if (char === "`")
-        return true;
-      else if (char === "$" && command[i + 1] === "(")
-        return true;
-      continue;
+    if (owningPid !== process.pid) {
+      log(`[onnx] not releasing lock ${lockPath}: owned by pid ${owningPid ?? "unknown"} (we are ${process.pid})`);
+      return;
     }
-    if (char === "'" || char === '"') {
-      quote = char;
-      continue;
+    try {
+      unlinkSync4(lockPath);
+    } catch (unlinkErr) {
+      const code = unlinkErr.code;
+      if (code !== "ENOENT") {
+        warn(`[onnx] failed to release lock ${lockPath}: ${unlinkErr}`);
+      }
     }
-    if (char === "`")
-      return true;
-    if (char === "(" || char === ")")
-      return true;
+  } catch (err) {
+    warn(`[onnx] unexpected error releasing lock ${lockPath}: ${err}`);
   }
-  return false;
 }
-var READS_FILE_OPERAND = new Set(["cat", "tac", "nl", "less", "more"]);
-function filterStageIsSafeToDrop(stage) {
-  const head = tokenizeStage(stage)[0];
-  if (!head)
-    return false;
-  if (head === "wc")
-    return false;
-  if (!NOISE_FILTERS.has(head))
-    return false;
-  if (/[<>]/.test(stage))
+function tasklistPidFromCsvLine(line) {
+  const quoted = line.match(/"([^"]*)"/g);
+  if (quoted && quoted.length >= 2)
+    return quoted[1].slice(1, -1);
+  const cells = line.split(",").map((cell) => cell.trim().replace(/^"|"$/g, ""));
+  return cells[1] ?? null;
+}
+function isWindowsProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
     return false;
-  if (hasUnquotedBackground(stage))
+  try {
+    const output = execFileSync("tasklist.exe", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+      encoding: "utf8",
+      timeout: 2000,
+      windowsHide: true
+    });
+    const expected = String(pid);
+    return output.split(/\r?\n/).some((line) => tasklistPidFromCsvLine(line) === expected);
+  } catch {
     return false;
-  const args = tokenizeStage(stage).slice(1);
-  const hasFlag = (...names) => args.some((a) => names.some((n) => a === n || a.startsWith(`${n}=`)));
-  if (head === "grep" || head === "rg") {
-    if (hasIntentChangingGrepFlag(args))
-      return false;
-    if (countBareOperands(args) > 1)
-      return false;
-    return true;
-  }
-  if (head === "head" || head === "tail") {
-    if (bareOperands(args).some((op) => !/^\d+$/.test(op)))
-      return false;
-    return true;
-  }
-  if (READS_FILE_OPERAND.has(head)) {
-    if (countBareOperands(args) > 0)
-      return false;
-    return true;
   }
-  if (head === "sed") {
-    if (hasFlag("-i", "--in-place"))
-      return false;
-    if (countBareOperands(args) > 1)
-      return false;
+}
+function isProcessAlive(pid) {
+  if (process.platform === "win32")
+    return isWindowsProcessAlive(pid);
+  try {
+    process.kill(pid, 0);
     return true;
-  }
-  if (head === "awk") {
-    if (countBareOperands(args) > 1)
+  } catch (err) {
+    const code = err.code;
+    if (code === "ESRCH")
       return false;
     return true;
   }
-  if (head === "sort" && hasFlag("-o", "--output"))
-    return false;
-  if (bareOperands(args).some((op) => op.includes("/") || op.includes(".")))
-    return false;
-  return true;
 }
-function bareOperands(args) {
-  const out = [];
-  let afterDoubleDash = false;
-  for (const arg of args) {
-    if (!afterDoubleDash && arg === "--") {
-      afterDoubleDash = true;
-      continue;
-    }
-    if (!afterDoubleDash && arg.startsWith("-") && arg !== "-")
-      continue;
-    out.push(arg);
+// ../aft-bridge/dist/project-identity.js
+import { createHash as createHash3 } from "node:crypto";
+import { realpathSync as realpathSync2 } from "node:fs";
+import { resolve as resolve6 } from "node:path";
+function canonicalizeProjectRoot(dir) {
+  const trimmed = dir.replace(/[/\\]+$/, "");
+  let canonical;
+  try {
+    canonical = realpathSync2(trimmed);
+  } catch {
+    canonical = resolve6(trimmed);
   }
-  return out;
+  return normalizeWindowsRoot(canonical);
 }
-function countBareOperands(args) {
-  return bareOperands(args).length;
-}
-function hasUnquotedBackground(stage) {
-  let quote = null;
-  let escaped = false;
-  for (let i = 0;i < stage.length; i++) {
-    const char = stage[i];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (char === "\\" && quote !== "'") {
-      escaped = true;
-      continue;
-    }
-    if (quote) {
-      if (char === quote)
-        quote = null;
-      continue;
-    }
-    if (char === "'" || char === '"') {
-      quote = char;
-      continue;
-    }
-    if (char === "&") {
-      const prev = stage[i - 1];
-      const next = stage[i + 1];
-      if (prev === "&" || next === "&" || prev === ">" || next === ">")
-        continue;
-      return true;
-    }
+function normalizeWindowsRoot(p) {
+  if (process.platform !== "win32")
+    return p;
+  let s = p;
+  if (s.startsWith("\\\\?\\UNC\\")) {
+    s = `\\\\${s.slice("\\\\?\\UNC\\".length)}`;
+  } else if (s.startsWith("\\\\?\\")) {
+    s = s.slice("\\\\?\\".length);
   }
-  return false;
-}
-function hasIntentChangingGrepFlag(args) {
-  for (const arg of args) {
-    if (arg === "--")
-      return false;
-    if (!arg.startsWith("-") || arg === "-")
-      continue;
-    if (arg.startsWith("--")) {
-      const flag = arg.slice(2).split("=", 1)[0];
-      if (GREP_GUARD_FLAGS.has(flag))
-        return true;
-      continue;
-    }
-    for (const flag of arg.slice(1)) {
-      if (GREP_GUARD_FLAGS.has(flag))
-        return true;
+  if (s.length >= 2 && s[1] === ":") {
+    const drive = s.charCodeAt(0);
+    if (drive >= 97 && drive <= 122) {
+      s = s[0].toUpperCase() + s.slice(1);
     }
   }
-  return false;
+  return s;
 }
-function tokenizeStage(stage) {
-  const tokens = [];
-  let current = "";
-  let quote = null;
-  let escaped = false;
-  for (let index = 0;index < stage.length; index++) {
-    const char = stage[index];
-    if (escaped) {
-      current += char;
-      escaped = false;
-      continue;
-    }
-    if (char === "\\" && quote !== "'") {
-      escaped = true;
-      continue;
-    }
-    if (quote) {
-      if (char === quote) {
-        quote = null;
-      } else {
-        current += char;
-      }
-      continue;
-    }
-    if (char === "'" || char === '"') {
-      quote = char;
-      continue;
-    }
-    if (/\s/.test(char)) {
-      if (current.length > 0) {
-        tokens.push(current);
-        current = "";
-      }
-      continue;
-    }
-    current += char;
-  }
-  if (current.length > 0)
-    tokens.push(current);
-  return tokens;
+function projectRootKeyHash(dir) {
+  return createHash3("sha256").update(canonicalizeProjectRoot(dir)).digest("hex").slice(0, 16);
 }
+
 // ../aft-bridge/dist/pool.js
-import { realpathSync as realpathSync2 } from "node:fs";
 var DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 var DEFAULT_MAX_POOL_SIZE = 8;
 var CLEANUP_INTERVAL_MS = 60 * 1000;
@@ -15364,12 +15379,7 @@ class BridgePool {
   }
 }
 function normalizeKey(projectRoot) {
-  const stripped = projectRoot.replace(/[/\\]+$/, "");
-  try {
-    return realpathSync2(stripped);
-  } catch {
-    return stripped;
-  }
+  return canonicalizeProjectRoot(projectRoot);
 }
 // ../aft-bridge/dist/tool-format.js
 function asPlainObject(value) {
@@ -15560,7 +15570,7 @@ function unwrapRustZoomBatchEnvelope(response) {
   return { names, responses };
 }
 // src/bg-notifications.ts
-import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
 
 // src/logger.ts
 import * as fs from "node:fs";
@@ -15724,7 +15734,7 @@ async function resolvePromptContext(client, sessionId) {
 
 // src/bg-notifications.ts
 function hashReminder(text) {
-  return createHash3("sha256").update(text).digest("hex").slice(0, 16);
+  return createHash4("sha256").update(text).digest("hex").slice(0, 16);
 }
 var CONSUMED_TASKIDS_CAP = 256;
 var sessionBgStates = new Map;
@@ -16398,9 +16408,7 @@ function formatDuration(completion) {
 }
 
 // src/config.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4, renameSync as renameSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync4 } from "node:fs";
 var import_comment_json = __toESM(require_src2(), 1);
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
@@ -30062,89 +30070,7 @@ var AftConfigSchema = exports_external.object({
   auto_update: exports_external.boolean().optional(),
   bridge: BridgeConfigSchema.optional()
 }).strict();
-function normalizeLspExtension(extension) {
-  return extension.trim().replace(/^\.+/, "");
-}
-function resolveLspConfigForConfigure(config2) {
-  const overrides = {};
-  const disabled = new Set(config2.lsp?.disabled ?? []);
-  let experimentalTy = config2.experimental?.lsp_ty;
-  switch (config2.lsp?.python ?? "auto") {
-    case "ty":
-      experimentalTy = true;
-      disabled.add("python");
-      break;
-    case "pyright":
-      experimentalTy = false;
-      disabled.add("ty");
-      break;
-    case "auto":
-      break;
-  }
-  if (experimentalTy !== undefined) {
-    overrides.experimental_lsp_ty = experimentalTy;
-  }
-  const servers = Object.entries(config2.lsp?.servers ?? {}).map(([id, server]) => {
-    const entry = {
-      id,
-      args: server.args,
-      root_markers: server.root_markers,
-      disabled: server.disabled
-    };
-    if (server.extensions && server.extensions.length > 0) {
-      entry.extensions = server.extensions.map(normalizeLspExtension);
-    }
-    if (server.binary) {
-      entry.binary = server.binary;
-    }
-    if (server.env && Object.keys(server.env).length > 0) {
-      entry.env = server.env;
-    }
-    if (server.initialization_options !== undefined) {
-      entry.initialization_options = server.initialization_options;
-    }
-    return entry;
-  });
-  if (servers.length > 0) {
-    overrides.lsp_servers = servers;
-  }
-  if (disabled.size > 0) {
-    overrides.disabled_lsp = [...disabled];
-  }
-  return overrides;
-}
-function resolveProjectOverridesForConfigure(config2) {
-  const overrides = {};
-  if (config2.format_on_edit !== undefined)
-    overrides.format_on_edit = config2.format_on_edit;
-  if (config2.formatter_timeout_secs !== undefined)
-    overrides.formatter_timeout_secs = config2.formatter_timeout_secs;
-  if (config2.validate_on_edit !== undefined)
-    overrides.validate_on_edit = config2.validate_on_edit;
-  if (config2.formatter !== undefined)
-    overrides.formatter = config2.formatter;
-  if (config2.checker !== undefined)
-    overrides.checker = config2.checker;
-  overrides.restrict_to_project_root = config2.restrict_to_project_root ?? false;
-  if (config2.search_index !== undefined)
-    overrides.search_index = config2.search_index;
-  if (config2.semantic_search !== undefined)
-    overrides.semantic_search = config2.semantic_search;
-  if (config2.callgraph_store !== undefined)
-    overrides.callgraph_store = config2.callgraph_store;
-  if (config2.callgraph_chunk_size !== undefined)
-    overrides.callgraph_chunk_size = config2.callgraph_chunk_size;
-  Object.assign(overrides, resolveExperimentalConfigForConfigure(config2));
-  Object.assign(overrides, resolveLspConfigForConfigure(config2));
-  if (config2.semantic !== undefined)
-    overrides.semantic = config2.semantic;
-  if (config2.inspect !== undefined)
-    overrides.inspect = config2.inspect;
-  if (config2.max_callgraph_files !== undefined)
-    overrides.max_callgraph_files = config2.max_callgraph_files;
-  return overrides;
-}
-var FOREGROUND_WAIT_WINDOW_DEFAULT_MS = 8000;
+var FOREGROUND_WAIT_WINDOW_DEFAULT_MS = 15000;
 var FOREGROUND_WAIT_WINDOW_MIN_MS = 5000;
 function resolveBashConfig(config2) {
   const top = config2.bash;
@@ -30203,23 +30129,6 @@ function resolveBashConfig(config2) {
     background: surfaceDefaultEnabled
   };
 }
-function resolveExperimentalConfigForConfigure(config2) {
-  const overrides = {};
-  const bash = resolveBashConfig(config2);
-  overrides.experimental_bash_rewrite = bash.rewrite;
-  overrides.experimental_bash_compress = bash.compress;
-  overrides.experimental_bash_background = bash.background;
-  if (bash.long_running_reminder_enabled !== undefined) {
-    overrides.bash_long_running_reminder_enabled = bash.long_running_reminder_enabled;
-  }
-  if (bash.long_running_reminder_interval_ms !== undefined) {
-    overrides.bash_long_running_reminder_interval_ms = bash.long_running_reminder_interval_ms;
-  }
-  if (config2.experimental?.lsp_ty !== undefined) {
-    overrides.experimental_lsp_ty = config2.experimental.lsp_ty;
-  }
-  return overrides;
-}
 var CONFIG_MIGRATIONS = [
   { oldKey: "experimental_search_index", newPath: ["search_index"] },
   { oldKey: "experimental_semantic_search", newPath: ["semantic_search"] },
@@ -30329,14 +30238,14 @@ function migrateExperimentalBashBlock(rawConfig, configPath, logger) {
   }
   return movedKeys;
 }
-function migrateAftConfigFile(configPath, logger = { log: log2, warn: warn2 }) {
-  if (!existsSync6(configPath)) {
+function migrateAftConfigFile2(configPath, logger = { log: log2, warn: warn2 }) {
+  if (!existsSync7(configPath)) {
     return { migrated: false, oldKeys: [] };
   }
   let tmpPath = null;
   let oldKeys = [];
   try {
-    const content = readFileSync4(configPath, "utf-8");
+    const content = readFileSync6(configPath, "utf-8");
     const rawConfig = import_comment_json.parse(content);
     if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) {
       return { migrated: false, oldKeys: [] };
@@ -30353,14 +30262,14 @@ function migrateAftConfigFile(configPath, logger = { log: log2, warn: warn2 }) {
 `)}
 ${serialized}` : serialized;
     tmpPath = `${configPath}.tmp.${process.pid}`;
-    writeFileSync3(tmpPath, nextContent, "utf-8");
-    renameSync4(tmpPath, configPath);
+    writeFileSync4(tmpPath, nextContent, "utf-8");
+    renameSync5(tmpPath, configPath);
     logger.log(`Migrated config at ${configPath}: removed ${oldKeys.join(", ")}`);
     return { migrated: true, oldKeys };
   } catch (err) {
     if (tmpPath) {
       try {
-        unlinkSync4(tmpPath);
+        unlinkSync5(tmpPath);
       } catch {}
     }
     if (isWritableMigrationError(err)) {
@@ -30371,17 +30280,6 @@ ${serialized}` : serialized;
     return { migrated: false, oldKeys: [] };
   }
 }
-function detectConfigFile(basePath) {
-  const jsoncPath = `${basePath}.jsonc`;
-  const jsonPath = `${basePath}.json`;
-  if (existsSync6(jsoncPath)) {
-    return { format: "jsonc", path: jsoncPath };
-  }
-  if (existsSync6(jsonPath)) {
-    return { format: "json", path: jsonPath };
-  }
-  return { format: "none", path: jsonPath };
-}
 function parseConfigPartially(rawConfig) {
   const fullResult = AftConfigSchema.safeParse(rawConfig);
   if (fullResult.success) {
@@ -30421,10 +30319,10 @@ function recordConfigParseFailure(configPath, errorMessage) {
 }
 function loadConfigFromPath(configPath) {
   try {
-    if (!existsSync6(configPath)) {
+    if (!existsSync7(configPath)) {
       return null;
     }
-    const content = readFileSync4(configPath, "utf-8");
+    const content = readFileSync6(configPath, "utf-8");
     const rawConfig = import_comment_json.parse(content);
     migrateRawConfig(rawConfig, configPath, { log: log2, warn: warn2 });
     const cleanConfig = stripJsoncSymbols(rawConfig);
@@ -30627,27 +30525,43 @@ function resolveBridgePoolTransportOptions(config2) {
     hangThreshold: config2.bridge?.hang_threshold ?? DEFAULT_BRIDGE_HANG_THRESHOLD
   };
 }
-function getOpenCodeConfigDir() {
-  const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  if (envDir) {
-    return envDir;
-  }
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join10(homedir8(), ".config");
-  return join10(xdgConfig, "opencode");
+function migrateAftConfigLocations(projectDirectory, logger = { log: log2, warn: warn2 }) {
+  const paths = resolveCortexKitConfigPaths(projectDirectory);
+  const legacy = resolveLegacyAftConfigSources(projectDirectory);
+  return [
+    migrateAftConfigFile({
+      scope: "user",
+      targetPath: paths.userConfigPath,
+      legacySources: legacy.user,
+      operatingHarness: "opencode",
+      logger
+    }),
+    migrateAftConfigFile({
+      scope: "project",
+      targetPath: paths.projectConfigPath,
+      legacySources: legacy.project,
+      operatingHarness: "opencode",
+      logger
+    })
+  ];
+}
+function resolveAftConfigPaths(projectDirectory) {
+  const paths = resolveCortexKitConfigPaths(projectDirectory);
+  migrateAftConfigFile2(paths.userConfigPath);
+  migrateAftConfigFile2(paths.projectConfigPath);
+  return paths;
+}
+function buildConfigTierConfigureParams(projectDirectory, processState = {}) {
+  const paths = resolveAftConfigPaths(projectDirectory);
+  return {
+    ...processState,
+    cortexkit_user_config_path: paths.userConfigPath,
+    config: readConfigTiers(paths)
+  };
 }
 function loadAftConfig(projectDirectory) {
   configLoadErrors = [];
-  const configDir = getOpenCodeConfigDir();
-  const userBasePath = join10(configDir, "aft");
-  migrateAftConfigFile(`${userBasePath}.jsonc`);
-  migrateAftConfigFile(`${userBasePath}.json`);
-  const userDetected = detectConfigFile(userBasePath);
-  const userConfigPath = userDetected.format !== "none" ? userDetected.path : `${userBasePath}.json`;
-  const projectBasePath = join10(projectDirectory, ".opencode", "aft");
-  migrateAftConfigFile(`${projectBasePath}.jsonc`);
-  migrateAftConfigFile(`${projectBasePath}.json`);
-  const projectDetected = detectConfigFile(projectBasePath);
-  const projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : `${projectBasePath}.json`;
+  const { userConfigPath, projectConfigPath } = resolveAftConfigPaths(projectDirectory);
   let config2 = loadConfigFromPath(userConfigPath) ?? {};
   const projectConfig = loadConfigFromPath(projectConfigPath);
   if (projectConfig) {
@@ -30668,9 +30582,9 @@ function loadAftConfig(projectDirectory) {
 }
 
 // src/notifications.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
 import { homedir as homedir9, platform } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join10 } from "node:path";
 function isTuiMode() {
   return process.env.OPENCODE_CLIENT === "cli";
 }
@@ -30693,25 +30607,25 @@ function getDesktopStatePath() {
   const os3 = platform();
   const home = homedir9();
   if (os3 === "darwin") {
-    return join11(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
+    return join10(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os3 === "linux") {
-    const xdgConfig = process.env.XDG_CONFIG_HOME || join11(home, ".config");
-    return join11(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join10(home, ".config");
+    return join10(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os3 === "win32") {
-    const appData = process.env.APPDATA || join11(home, "AppData", "Roaming");
-    return join11(appData, "ai.opencode.desktop", "opencode.global.dat");
+    const appData = process.env.APPDATA || join10(home, "AppData", "Roaming");
+    return join10(appData, "ai.opencode.desktop", "opencode.global.dat");
   }
   return null;
 }
 function readDesktopState() {
   const statePath = getDesktopStatePath();
-  if (!statePath || !existsSync7(statePath)) {
+  if (!statePath || !existsSync8(statePath)) {
     return { serverUrl: null };
   }
   try {
-    const raw = readFileSync5(statePath, "utf-8");
+    const raw = readFileSync7(statePath, "utf-8");
     const state = JSON.parse(raw);
     let serverUrl = null;
     const serverStr = state.server;
@@ -30972,9 +30886,13 @@ function warningTitle(warning) {
       return "LSP binary is missing";
     case "config_parse_failed":
       return "Config failed to parse";
+    case "config_key_dropped":
+      return "Config key ignored";
   }
 }
 function formatConfigureWarningLine(warning) {
+  if (warning.kind === "config_key_dropped")
+    return `• ${warning.hint}`;
   const details = [];
   if (warning.language)
     details.push(`language: ${warning.language}`);
@@ -30990,6 +30908,8 @@ function formatConfigureWarningLine(warning) {
   ${warning.hint}`;
 }
 function formatConfigureWarningChat(warning) {
+  if (warning.kind === "config_key_dropped")
+    return `${WARNING_MARKER} ${warning.hint}`;
   return `${WARNING_MARKER} ${formatConfigureWarningLine(warning).replace(/^• /, "")}`;
 }
 function formatConfigureWarningsBatch(warnings) {
@@ -31099,7 +31019,7 @@ function isConfigureWarning(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return false;
   const warning = value;
-  return (warning.kind === "formatter_not_installed" || warning.kind === "checker_not_installed" || warning.kind === "lsp_binary_missing" || warning.kind === "config_parse_failed") && typeof warning.hint === "string";
+  return (warning.kind === "formatter_not_installed" || warning.kind === "checker_not_installed" || warning.kind === "lsp_binary_missing" || warning.kind === "config_parse_failed" || warning.kind === "config_key_dropped") && typeof warning.hint === "string";
 }
 function configParseWarningsFromErrors(errors3) {
   return errors3.map((entry) => ({
@@ -31127,6 +31047,20 @@ function drainPendingConfigParseWarnings(projectRoot) {
 function coerceConfigureWarnings(warnings) {
   return warnings.filter(isConfigureWarning);
 }
+function isDroppedConfigKey(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const dropped = value;
+  return typeof dropped.key === "string" && typeof dropped.tier === "string" && typeof dropped.reason === "string";
+}
+function coerceDroppedKeyWarnings(droppedKeys) {
+  if (!Array.isArray(droppedKeys))
+    return [];
+  return formatDroppedKeyWarnings(droppedKeys.filter(isDroppedConfigKey)).map((hint) => ({
+    kind: "config_key_dropped",
+    hint
+  }));
+}
 function drainPendingEagerWarnings(projectRoot) {
   const pending = pendingEagerWarnings.get(projectRoot) ?? [];
   pendingEagerWarnings.delete(projectRoot);
@@ -31135,7 +31069,8 @@ function drainPendingEagerWarnings(projectRoot) {
 function enqueueConfigureWarningsForSession(context) {
   const validWarnings = [
     ...drainPendingConfigParseWarnings(context.projectRoot),
-    ...coerceConfigureWarnings(context.warnings)
+    ...coerceConfigureWarnings(context.warnings),
+    ...coerceDroppedKeyWarnings(context.configDroppedKeys)
   ];
   if (!context.sessionId) {
     if (validWarnings.length === 0)
@@ -31185,52 +31120,52 @@ async function flushConfigureWarningsOnIdle(sessionId) {
 
 // src/hooks/auto-update-checker/index.ts
 import {
-  closeSync as closeSync4,
-  existsSync as existsSync10,
+  closeSync as closeSync5,
+  existsSync as existsSync11,
   mkdirSync as mkdirSync6,
-  openSync as openSync4,
-  readFileSync as readFileSync8,
-  renameSync as renameSync5,
-  rmSync as rmSync4,
-  writeFileSync as writeFileSync6
+  openSync as openSync5,
+  readFileSync as readFileSync10,
+  renameSync as renameSync6,
+  rmSync as rmSync5,
+  writeFileSync as writeFileSync7
 } from "node:fs";
 import { dirname as dirname7 } from "node:path";
 
 // src/hooks/auto-update-checker/cache.ts
 import { spawn as spawn2 } from "node:child_process";
-import { cpSync, existsSync as existsSync9, mkdtempSync, readFileSync as readFileSync7, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { cpSync, existsSync as existsSync10, mkdtempSync, readFileSync as readFileSync9, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { basename as basename2, dirname as dirname6, join as join14 } from "node:path";
+import { basename as basename3, dirname as dirname6, join as join13 } from "node:path";
 var import_comment_json3 = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/checker.ts
 var import_comment_json2 = __toESM(require_src2(), 1);
-import { existsSync as existsSync8, readFileSync as readFileSync6, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync8, statSync as statSync5, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
-import { dirname as dirname5, isAbsolute as isAbsolute4, join as join13, resolve as resolve3 } from "node:path";
+import { dirname as dirname5, isAbsolute as isAbsolute5, join as join12, resolve as resolve7 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/hooks/auto-update-checker/constants.ts
 import { homedir as homedir10, platform as platform2 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join11 } from "node:path";
 var PACKAGE_NAME = "@cortexkit/aft-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var NPM_FETCH_TIMEOUT = 1e4;
 function getOpenCodeCacheRoot() {
   if (platform2() === "win32") {
-    return join12(process.env.LOCALAPPDATA ?? homedir10(), "opencode");
+    return join11(process.env.LOCALAPPDATA ?? homedir10(), "opencode");
   }
-  return join12(homedir10(), ".cache", "opencode");
+  return join11(homedir10(), ".cache", "opencode");
 }
 function getOpenCodeConfigRoot() {
   if (platform2() === "win32") {
-    return join12(process.env.APPDATA ?? join12(homedir10(), "AppData", "Roaming"), "opencode");
+    return join11(process.env.APPDATA ?? join11(homedir10(), "AppData", "Roaming"), "opencode");
   }
-  return join12(process.env.XDG_CONFIG_HOME ?? join12(homedir10(), ".config"), "opencode");
+  return join11(process.env.XDG_CONFIG_HOME ?? join11(homedir10(), ".config"), "opencode");
 }
-var CACHE_DIR = join12(getOpenCodeCacheRoot(), "packages");
-var USER_OPENCODE_CONFIG = join12(getOpenCodeConfigRoot(), "opencode.json");
-var USER_OPENCODE_CONFIG_JSONC = join12(getOpenCodeConfigRoot(), "opencode.jsonc");
+var CACHE_DIR = join11(getOpenCodeCacheRoot(), "packages");
+var USER_OPENCODE_CONFIG = join11(getOpenCodeConfigRoot(), "opencode.json");
+var USER_OPENCODE_CONFIG_JSONC = join11(getOpenCodeConfigRoot(), "opencode.jsonc");
 
 // src/hooks/auto-update-checker/types.ts
 var NpmPackageEnvelopeSchema = exports_external.object({
@@ -31288,8 +31223,8 @@ function extractChannel(version2) {
 }
 function getConfigPaths(directory) {
   return [
-    join13(directory, ".opencode", "opencode.json"),
-    join13(directory, ".opencode", "opencode.jsonc"),
+    join12(directory, ".opencode", "opencode.json"),
+    join12(directory, ".opencode", "opencode.jsonc"),
     USER_OPENCODE_CONFIG,
     USER_OPENCODE_CONFIG_JSONC
   ];
@@ -31302,26 +31237,26 @@ function resolvePathPluginSpec(spec, configPath) {
       return spec.replace(/^file:\/\//, "");
     }
   }
-  if (isAbsolute4(spec) || /^[A-Za-z]:[\\/]/.test(spec))
+  if (isAbsolute5(spec) || /^[A-Za-z]:[\\/]/.test(spec))
     return spec;
-  return resolve3(dirname5(configPath), spec);
+  return resolve7(dirname5(configPath), spec);
 }
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync8(configPath))
+      if (!existsSync9(configPath))
         continue;
-      const rawConfig = parseJsonConfig(readFileSync6(configPath, "utf-8"));
+      const rawConfig = parseJsonConfig(readFileSync8(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
       for (const entry of plugins) {
         if (entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))
           continue;
-        if (entry.startsWith("file://") || entry.startsWith(".") || isAbsolute4(entry)) {
+        if (entry.startsWith("file://") || entry.startsWith(".") || isAbsolute5(entry)) {
           const localPath = resolvePathPluginSpec(entry, configPath);
           const pkgPath = findPackageJsonUp(localPath);
           if (!pkgPath)
             continue;
-          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync6(pkgPath, "utf-8")));
+          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync8(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
             return localPath;
         }
@@ -31332,13 +31267,13 @@ function getLocalDevPath(directory) {
 }
 function findPackageJsonUp(startPath) {
   try {
-    const stat = statSync4(startPath);
+    const stat = statSync5(startPath);
     let dir = stat.isDirectory() ? startPath : dirname5(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = join13(dir, "package.json");
-      if (existsSync8(pkgPath)) {
+      const pkgPath = join12(dir, "package.json");
+      if (existsSync9(pkgPath)) {
         try {
-          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync6(pkgPath, "utf-8")));
+          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync8(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
             return pkgPath;
         } catch {}
@@ -31359,7 +31294,7 @@ function getLocalDevVersion(directory) {
     const pkgPath = findPackageJsonUp(localPath);
     if (!pkgPath)
       return null;
-    const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync6(pkgPath, "utf-8")));
+    const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync8(pkgPath, "utf-8")));
     return pkg.success ? pkg.data.version ?? null : null;
   } catch {
     return null;
@@ -31376,9 +31311,9 @@ function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync8(configPath))
+      if (!existsSync9(configPath))
         continue;
-      const rawConfig = parseJsonConfig(readFileSync6(configPath, "utf-8"));
+      const rawConfig = parseJsonConfig(readFileSync8(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
       for (const entry of plugins) {
         if (entry === PACKAGE_NAME) {
@@ -31396,7 +31331,7 @@ function findPluginEntry(directory) {
 }
 var cachedPackageVersion = null;
 function getSpecCachePackageJsonPath(spec) {
-  return join13(CACHE_DIR, spec, "node_modules", PACKAGE_NAME, "package.json");
+  return join12(CACHE_DIR, spec, "node_modules", PACKAGE_NAME, "package.json");
 }
 function getCachedVersion(spec) {
   if (!spec && cachedPackageVersion)
@@ -31405,13 +31340,13 @@ function getCachedVersion(spec) {
     getCurrentRuntimePackageJsonPath(),
     spec ? getSpecCachePackageJsonPath(spec) : null,
     getSpecCachePackageJsonPath(`${PACKAGE_NAME}@latest`),
-    join13(homedir11(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
+    join12(homedir11(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
   ].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
-      if (!existsSync8(packageJsonPath))
+      if (!existsSync9(packageJsonPath))
         continue;
-      const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync6(packageJsonPath, "utf-8")));
+      const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync8(packageJsonPath, "utf-8")));
       if (pkg.success && pkg.data.version) {
         if (!spec)
           cachedPackageVersion = pkg.data.version;
@@ -31453,17 +31388,17 @@ async function getLatestVersion(channel = "latest", options = {}) {
 // src/hooks/auto-update-checker/cache.ts
 var pendingSnapshots = new Map;
 function createAutoUpdateSnapshot(installDir, packageJsonPath, packageName) {
-  const packageDir = join14(installDir, "node_modules", packageName);
-  const lockfilePath = join14(installDir, "package-lock.json");
-  const tempDir = mkdtempSync(join14(tmpdir3(), "aft-auto-update-"));
-  const stagedPackageDir = existsSync9(packageDir) ? join14(tempDir, "package") : null;
+  const packageDir = join13(installDir, "node_modules", packageName);
+  const lockfilePath = join13(installDir, "package-lock.json");
+  const tempDir = mkdtempSync(join13(tmpdir3(), "aft-auto-update-"));
+  const stagedPackageDir = existsSync10(packageDir) ? join13(tempDir, "package") : null;
   if (stagedPackageDir)
     cpSync(packageDir, stagedPackageDir, { recursive: true });
   return {
     packageJsonPath,
-    packageJson: existsSync9(packageJsonPath) ? readFileSync7(packageJsonPath, "utf-8") : null,
+    packageJson: existsSync10(packageJsonPath) ? readFileSync9(packageJsonPath, "utf-8") : null,
     lockfilePath,
-    lockfile: existsSync9(lockfilePath) ? readFileSync7(lockfilePath, "utf-8") : null,
+    lockfile: existsSync10(lockfilePath) ? readFileSync9(lockfilePath, "utf-8") : null,
     packageDir,
     stagedPackageDir,
     tempDir
@@ -31472,36 +31407,36 @@ function createAutoUpdateSnapshot(installDir, packageJsonPath, packageName) {
 function restoreAutoUpdateSnapshot(snapshot) {
   try {
     if (snapshot.packageJson === null)
-      rmSync3(snapshot.packageJsonPath, { force: true });
+      rmSync4(snapshot.packageJsonPath, { force: true });
     else
-      writeFileSync5(snapshot.packageJsonPath, snapshot.packageJson);
+      writeFileSync6(snapshot.packageJsonPath, snapshot.packageJson);
     if (snapshot.lockfile === null)
-      rmSync3(snapshot.lockfilePath, { force: true });
+      rmSync4(snapshot.lockfilePath, { force: true });
     else
-      writeFileSync5(snapshot.lockfilePath, snapshot.lockfile);
-    rmSync3(snapshot.packageDir, { recursive: true, force: true });
+      writeFileSync6(snapshot.lockfilePath, snapshot.lockfile);
+    rmSync4(snapshot.packageDir, { recursive: true, force: true });
     if (snapshot.stagedPackageDir) {
       cpSync(snapshot.stagedPackageDir, snapshot.packageDir, { recursive: true });
     }
   } finally {
-    rmSync3(snapshot.tempDir, { recursive: true, force: true });
+    rmSync4(snapshot.tempDir, { recursive: true, force: true });
   }
 }
 function stripPackageNameFromPath(pathValue, packageName) {
   let current = pathValue;
   for (const segment of [...packageName.split("/")].reverse()) {
-    if (basename2(current) !== segment)
+    if (basename3(current) !== segment)
       return null;
     current = dirname6(current);
   }
   return current;
 }
 function removeFromPackageLock(installDir, packageName) {
-  const lockPath = join14(installDir, "package-lock.json");
-  if (!existsSync9(lockPath))
+  const lockPath = join13(installDir, "package-lock.json");
+  if (!existsSync10(lockPath))
     return false;
   try {
-    const lock = import_comment_json3.parse(readFileSync7(lockPath, "utf-8"));
+    const lock = import_comment_json3.parse(readFileSync9(lockPath, "utf-8"));
     let modified = false;
     if (lock.packages) {
       const key = `node_modules/${packageName}`;
@@ -31515,7 +31450,7 @@ function removeFromPackageLock(installDir, packageName) {
       modified = true;
     }
     if (modified) {
-      writeFileSync5(lockPath, JSON.stringify(lock, null, 2));
+      writeFileSync6(lockPath, JSON.stringify(lock, null, 2));
       log2(`[auto-update-checker] Removed from package-lock.json: ${packageName}`);
     }
     return modified;
@@ -31524,10 +31459,10 @@ function removeFromPackageLock(installDir, packageName) {
   }
 }
 function ensureDependencyVersion(packageJsonPath, packageName, version2) {
-  if (!existsSync9(packageJsonPath))
+  if (!existsSync10(packageJsonPath))
     return false;
   try {
-    const raw = import_comment_json3.parse(readFileSync7(packageJsonPath, "utf-8"));
+    const raw = import_comment_json3.parse(readFileSync9(packageJsonPath, "utf-8"));
     const pkgJson = PackageJsonSchema.safeParse(raw);
     if (!pkgJson.success)
       return false;
@@ -31537,7 +31472,7 @@ function ensureDependencyVersion(packageJsonPath, packageName, version2) {
       return true;
     dependencies[packageName] = version2;
     nextPackageJson.dependencies = dependencies;
-    writeFileSync5(packageJsonPath, JSON.stringify(nextPackageJson, null, 2));
+    writeFileSync6(packageJsonPath, JSON.stringify(nextPackageJson, null, 2));
     log2(`[auto-update-checker] Updated dependency in package.json: ${packageName} → ${version2}`);
     return true;
   } catch (err) {
@@ -31546,10 +31481,10 @@ function ensureDependencyVersion(packageJsonPath, packageName, version2) {
   }
 }
 function removeInstalledPackage(installDir, packageName) {
-  const packageDir = join14(installDir, "node_modules", packageName);
-  if (!existsSync9(packageDir))
+  const packageDir = join13(installDir, "node_modules", packageName);
+  if (!existsSync10(packageDir))
     return false;
-  rmSync3(packageDir, { recursive: true, force: true });
+  rmSync4(packageDir, { recursive: true, force: true });
   log2(`[auto-update-checker] Package removed: ${packageDir}`);
   return true;
 }
@@ -31557,16 +31492,16 @@ function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackage
   if (runtimePackageJsonPath) {
     const packageDir = dirname6(runtimePackageJsonPath);
     const nodeModulesDir = stripPackageNameFromPath(packageDir, PACKAGE_NAME);
-    if (nodeModulesDir && basename2(nodeModulesDir) === "node_modules") {
+    if (nodeModulesDir && basename3(nodeModulesDir) === "node_modules") {
       const installDir = dirname6(nodeModulesDir);
-      const packageJsonPath = join14(installDir, "package.json");
-      if (existsSync9(packageJsonPath))
+      const packageJsonPath = join13(installDir, "package.json");
+      if (existsSync10(packageJsonPath))
         return { installDir, packageJsonPath };
     }
     return null;
   }
-  const legacyPackageJsonPath = join14(dirname6(CACHE_DIR), "package.json");
-  if (existsSync9(legacyPackageJsonPath)) {
+  const legacyPackageJsonPath = join13(dirname6(CACHE_DIR), "package.json");
+  if (existsSync10(legacyPackageJsonPath)) {
     return { installDir: dirname6(CACHE_DIR), packageJsonPath: legacyPackageJsonPath };
   }
   return null;
@@ -31652,7 +31587,7 @@ async function runNpmInstallSafe(installDir, options = {}) {
     if (!result.ok && snapshot) {
       restoreAutoUpdateSnapshot(snapshot);
     } else if (snapshot) {
-      rmSync3(snapshot.tempDir, { recursive: true, force: true });
+      rmSync4(snapshot.tempDir, { recursive: true, force: true });
     }
     if (!result.ok) {
       warnNpmInstallFailure(result.reason ?? "npm install failed", stderrTail);
@@ -31745,8 +31680,8 @@ function claimCheckSlot(storageDir, intervalMs) {
     const lockPath = `${file2}.lock`;
     let lockFd;
     try {
-      lockFd = openSync4(lockPath, "wx");
-      writeFileSync6(lockFd, JSON.stringify({ pid: process.pid, startedMs: Date.now() }));
+      lockFd = openSync5(lockPath, "wx");
+      writeFileSync7(lockFd, JSON.stringify({ pid: process.pid, startedMs: Date.now() }));
     } catch (err) {
       if (err.code !== "EEXIST") {
         warn2(`[auto-update-checker] Could not acquire update lock: ${String(err)}`);
@@ -31756,9 +31691,9 @@ function claimCheckSlot(storageDir, intervalMs) {
     const lock = {
       release: () => {
         try {
-          closeSync4(lockFd);
+          closeSync5(lockFd);
         } catch {}
-        rmSync4(lockPath, { force: true });
+        rmSync5(lockPath, { force: true });
       }
     };
     try {
@@ -31778,10 +31713,10 @@ function claimCheckSlot(storageDir, intervalMs) {
   }
 }
 function hasRecentCheckTimestamp(file2, intervalMs) {
-  if (!existsSync10(file2))
+  if (!existsSync11(file2))
     return false;
   try {
-    const raw = JSON.parse(readFileSync8(file2, "utf-8"));
+    const raw = JSON.parse(readFileSync10(file2, "utf-8"));
     const last = typeof raw.lastCheckedMs === "number" ? raw.lastCheckedMs : 0;
     return Number.isFinite(last) && Date.now() - last < intervalMs;
   } catch {
@@ -31790,8 +31725,8 @@ function hasRecentCheckTimestamp(file2, intervalMs) {
 }
 function writeCheckTimestamp(file2) {
   const tmp = `${file2}.tmp.${process.pid}`;
-  writeFileSync6(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
-  renameSync5(tmp, file2);
+  writeFileSync7(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
+  renameSync6(tmp, file2);
 }
 async function runStartupCheck(ctx, options) {
   if (options.signal.aborted)
@@ -31885,59 +31820,59 @@ function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
 
 // src/lsp-auto-install.ts
 import { spawn as spawn3 } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import {
   createReadStream,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync11,
-  renameSync as renameSync6,
-  rmSync as rmSync5,
-  statSync as statSync6,
-  writeFileSync as writeFileSync8
+  readFileSync as readFileSync13,
+  renameSync as renameSync7,
+  rmSync as rmSync6,
+  statSync as statSync7,
+  writeFileSync as writeFileSync9
 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join16 } from "node:path";
 
 // src/lsp-cache.ts
 import {
-  closeSync as closeSync5,
+  closeSync as closeSync6,
   mkdirSync as mkdirSync7,
-  openSync as openSync5,
-  readFileSync as readFileSync9,
-  statSync as statSync5,
-  unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync7
+  openSync as openSync6,
+  readFileSync as readFileSync11,
+  statSync as statSync6,
+  unlinkSync as unlinkSync6,
+  writeFileSync as writeFileSync8
 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join14 } from "node: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 || join15(homedir12(), "AppData", "Local");
-    return join15(base2, "aft");
+    const base2 = localAppData || join14(homedir12(), "AppData", "Local");
+    return join14(base2, "aft");
   }
-  const base = process.env.XDG_CACHE_HOME || join15(homedir12(), ".cache");
-  return join15(base, "aft");
+  const base = process.env.XDG_CACHE_HOME || join14(homedir12(), ".cache");
+  return join14(base, "aft");
 }
 function lspCacheRoot() {
-  return join15(aftCacheBase(), "lsp-packages");
+  return join14(aftCacheBase(), "lsp-packages");
 }
 function lspPackageDir(npmPackage) {
-  return join15(lspCacheRoot(), encodeURIComponent(npmPackage));
+  return join14(lspCacheRoot(), encodeURIComponent(npmPackage));
 }
 function lspBinaryPath(npmPackage, binary) {
-  return join15(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+  return join14(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
 }
 function lspBinDir(npmPackage) {
-  return join15(lspPackageDir(npmPackage), "node_modules", ".bin");
+  return join14(lspPackageDir(npmPackage), "node_modules", ".bin");
 }
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync5(join15(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync6(join14(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -31957,17 +31892,17 @@ function writeInstalledMetaIn(installDir, version2, sha256) {
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeFileSync7(join15(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
+    writeFileSync8(join14(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 path3 = join15(installDir, INSTALLED_META_FILE);
+  const path3 = join14(installDir, INSTALLED_META_FILE);
   try {
-    if (!statSync5(path3).isFile())
+    if (!statSync6(path3).isFile())
       return null;
-    const raw = readFileSync9(path3, "utf8");
+    const raw = readFileSync11(path3, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
@@ -31987,7 +31922,7 @@ function readInstalledMeta(packageKey) {
   return readInstalledMetaIn(lspPackageDir(packageKey));
 }
 function lockPath(npmPackage) {
-  return join15(lspPackageDir(npmPackage), ".aft-installing");
+  return join14(lspPackageDir(npmPackage), ".aft-installing");
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
@@ -31995,13 +31930,13 @@ function acquireInstallLock(lockKey) {
   const lock = lockPath(lockKey);
   const tryClaim = () => {
     try {
-      const fd = openSync5(lock, "wx");
+      const fd = openSync6(lock, "wx");
       try {
-        writeFileSync7(fd, `${process.pid}
+        writeFileSync8(fd, `${process.pid}
 ${new Date().toISOString()}
 `);
       } finally {
-        closeSync5(fd);
+        closeSync6(fd);
       }
       return true;
     } catch (err) {
@@ -32017,12 +31952,12 @@ ${new Date().toISOString()}
   let owningPid = null;
   let lockMtimeMs = 0;
   try {
-    const raw = readFileSync9(lock, "utf8");
+    const raw = readFileSync11(lock, "utf8");
     const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
     const parsed = Number.parseInt(firstLine, 10);
     if (Number.isFinite(parsed) && parsed > 0)
       owningPid = parsed;
-    lockMtimeMs = statSync5(lock).mtimeMs;
+    lockMtimeMs = statSync6(lock).mtimeMs;
   } catch {
     return tryClaim();
   }
@@ -32035,7 +31970,7 @@ ${new Date().toISOString()}
   }
   log2(`[lsp] reclaiming install lock for ${lockKey} (owner_pid=${owningPid ?? "unknown"}, alive=${ownerAlive}, age_ms=${age})`);
   try {
-    unlinkSync5(lock);
+    unlinkSync6(lock);
   } catch {}
   return tryClaim();
 }
@@ -32055,7 +31990,7 @@ function releaseInstallLock(lockKey) {
   try {
     let owningPid = null;
     try {
-      const raw = readFileSync9(lock, "utf8");
+      const raw = readFileSync11(lock, "utf8");
       const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
       const parsed = Number.parseInt(firstLine, 10);
       if (Number.isFinite(parsed) && parsed > 0)
@@ -32072,7 +32007,7 @@ function releaseInstallLock(lockKey) {
       return;
     }
     try {
-      unlinkSync5(lock);
+      unlinkSync6(lock);
     } catch (unlinkErr) {
       const code = unlinkErr.code;
       if (code !== "ENOENT") {
@@ -32094,9 +32029,9 @@ async function withInstallLock(lockKey, task) {
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
-  const file2 = join15(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file2 = join14(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
-    const raw = readFileSync9(file2, "utf8");
+    const raw = readFileSync11(file2, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.last_checked === "string") {
       return {
@@ -32111,12 +32046,12 @@ function readVersionCheck(npmPackage) {
 }
 function writeVersionCheck(npmPackage, latest) {
   mkdirSync7(lspPackageDir(npmPackage), { recursive: true });
-  const file2 = join15(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file2 = join14(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record2 = {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
   };
-  writeFileSync7(file2, JSON.stringify(record2, null, 2));
+  writeFileSync8(file2, JSON.stringify(record2, null, 2));
 }
 function shouldRecheckVersion(record2, weeklyCheckIntervalMs = 7 * 24 * 60 * 60 * 1000) {
   if (!record2)
@@ -32273,8 +32208,8 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync10 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync3, readFileSync as readFileSync12 } from "node:fs";
+import { join as join15 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
 var NOISE_DIRS = new Set([
@@ -32291,7 +32226,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync11(join16(projectRoot, marker)))
+    if (existsSync12(join15(projectRoot, marker)))
       return true;
   }
   return false;
@@ -32315,7 +32250,7 @@ function hasPackageJsonDep(projectRoot, depNames) {
 }
 function readPackageJson(projectRoot) {
   try {
-    const raw = readFileSync10(join16(projectRoot, "package.json"), "utf8");
+    const raw = readFileSync12(join15(projectRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null)
       return null;
@@ -32345,7 +32280,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: join16(current.dir, entry.name), depth: current.depth + 1 });
+          queue.push({ dir: join15(current.dir, entry.name), depth: current.depth + 1 });
         }
         continue;
       }
@@ -32472,9 +32407,9 @@ async function resolveTargetVersion(spec, config2, fetchImpl = fetch) {
 }
 function ensureInstallAnchor(cwd) {
   try {
-    const stub = join17(cwd, "package.json");
-    if (!existsSync12(stub)) {
-      writeFileSync8(stub, `${JSON.stringify({ name: "aft-lsp-cache", version: "0.0.0", private: true })}
+    const stub = join16(cwd, "package.json");
+    if (!existsSync13(stub)) {
+      writeFileSync9(stub, `${JSON.stringify({ name: "aft-lsp-cache", version: "0.0.0", private: true })}
 `);
     }
   } catch (err) {
@@ -32482,18 +32417,18 @@ function ensureInstallAnchor(cwd) {
   }
 }
 function runInstall(spec, version2, cwd, signal) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve8) => {
     const target = `${spec.npm}@${version2}`;
     log2(`[lsp] installing ${target} to ${cwd}`);
     if (signal?.aborted) {
       warn2(`[lsp] install ${target} aborted before spawn`);
-      resolve4(false);
+      resolve8(false);
       return;
     }
     const npm = resolveNpm();
     if (!npm) {
       warn2(`[lsp] npm not found on PATH or known locations; cannot install ${target}`);
-      resolve4(false);
+      resolve8(false);
       return;
     }
     ensureInstallAnchor(cwd);
@@ -32516,7 +32451,7 @@ function runInstall(spec, version2, cwd, signal) {
         return;
       settled = true;
       cleanup();
-      resolve4(ok);
+      resolve8(ok);
     };
     const onAbort = () => {
       warn2(`[lsp] install ${target} aborted during shutdown`);
@@ -32617,7 +32552,7 @@ function cachedPackageDir(npmPackage) {
   return lspBinDir(npmPackage).replace(/[\\/]node_modules[\\/]\.bin[\\/]?$/, "");
 }
 function hashInstalledBinary(spec) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve8, reject) => {
     const candidates = process.platform === "win32" ? [
       lspBinaryPath(spec.npm, spec.binary),
       lspBinaryPath(spec.npm, `${spec.binary}.cmd`),
@@ -32627,7 +32562,7 @@ function hashInstalledBinary(spec) {
     let pathToHash = null;
     for (const p of candidates) {
       try {
-        if (statSync6(p).isFile()) {
+        if (statSync7(p).isFile()) {
           pathToHash = p;
           break;
         }
@@ -32637,11 +32572,11 @@ function hashInstalledBinary(spec) {
       reject(new Error(`installed binary not found at any of: ${candidates.join(", ")}`));
       return;
     }
-    const hash2 = createHash4("sha256");
+    const hash2 = createHash5("sha256");
     const stream = createReadStream(pathToHash);
     stream.on("error", reject);
     stream.on("data", (chunk) => hash2.update(chunk));
-    stream.on("end", () => resolve4(hash2.digest("hex")));
+    stream.on("end", () => resolve8(hash2.digest("hex")));
   });
 }
 function installedBinaryPath(spec) {
@@ -32653,23 +32588,23 @@ function installedBinaryPath(spec) {
   ] : [lspBinaryPath(spec.npm, spec.binary)];
   for (const candidate of candidates) {
     try {
-      if (statSync6(candidate).isFile())
+      if (statSync7(candidate).isFile())
         return candidate;
     } catch {}
   }
   return null;
 }
 function sha256OfFileSync(path3) {
-  return createHash4("sha256").update(readFileSync11(path3)).digest("hex");
+  return createHash5("sha256").update(readFileSync13(path3)).digest("hex");
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
-  const dest = join17(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
+  const dest = join16(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync8(join17(dest, ".."), { recursive: true });
-    rmSync5(dest, { recursive: true, force: true });
-    renameSync6(packageDir, dest);
+    mkdirSync8(join16(dest, ".."), { recursive: true });
+    rmSync6(dest, { recursive: true, force: true });
+    renameSync7(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.npm}: failed to quarantine cache entry: ${err}`);
   }
@@ -32745,25 +32680,25 @@ function runAutoInstall(projectRoot, config2, fetchImpl = fetch) {
 
 // src/lsp-github-install.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { createHash as createHash5, randomBytes } from "node:crypto";
+import { createHash as createHash6, randomBytes } from "node:crypto";
 import {
   copyFileSync as copyFileSync4,
   createReadStream as createReadStream2,
   createWriteStream as createWriteStream3,
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync9,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync14,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync3,
-  renameSync as renameSync7,
-  rmSync as rmSync6,
-  statSync as statSync7,
-  unlinkSync as unlinkSync6,
-  writeFileSync as writeFileSync9
+  renameSync as renameSync8,
+  rmSync as rmSync7,
+  statSync as statSync8,
+  unlinkSync as unlinkSync7,
+  writeFileSync as writeFileSync10
 } from "node:fs";
-import { dirname as dirname8, join as join18, relative as relative3, resolve as resolve4 } from "node:path";
+import { dirname as dirname8, join as join17, relative as relative3, resolve as resolve8 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 
@@ -32853,26 +32788,26 @@ function detectHostPlatform() {
 
 // src/lsp-github-install.ts
 function ghCacheRoot() {
-  return join18(aftCacheBase(), "lsp-binaries");
+  return join17(aftCacheBase(), "lsp-binaries");
 }
 function ghPackageDir(spec) {
-  return join18(ghCacheRoot(), spec.id);
+  return join17(ghCacheRoot(), spec.id);
 }
 function ghBinDir(spec) {
-  return join18(ghPackageDir(spec), "bin");
+  return join17(ghPackageDir(spec), "bin");
 }
 function ghExtractDir(spec) {
-  return join18(ghPackageDir(spec), "extracted");
+  return join17(ghPackageDir(spec), "extracted");
 }
 var INSTALLED_META_FILE2 = ".aft-installed";
 function ghBinaryPath(spec, platform3) {
   const ext = platform3 === "win32" ? ".exe" : "";
-  return join18(ghBinDir(spec), `${spec.binary}${ext}`);
+  return join17(ghBinDir(spec), `${spec.binary}${ext}`);
 }
 function isGithubInstalled(spec, platform3) {
   for (const candidate of ghBinaryCandidates(spec, platform3)) {
     try {
-      if (statSync7(join18(ghBinDir(spec), candidate)).isFile())
+      if (statSync8(join17(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -32885,10 +32820,10 @@ function ghBinaryCandidates(spec, platform3) {
 }
 function readGithubInstalledMetaIn(installDir) {
   try {
-    const path3 = join18(installDir, INSTALLED_META_FILE2);
-    if (!statSync7(path3).isFile())
+    const path3 = join17(installDir, INSTALLED_META_FILE2);
+    if (!statSync8(path3).isFile())
       return null;
-    const parsed = JSON.parse(readFileSync12(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync14(path3, "utf8"));
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
     return {
@@ -32912,7 +32847,7 @@ function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveS
       binarySha256,
       ...archiveSha256 ? { archiveSha256 } : {}
     };
-    writeFileSync9(join18(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
+    writeFileSync10(join17(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
   } catch (err) {
     warn2(`[lsp] failed to write github installed metadata in ${installDir}: ${err}`);
   }
@@ -32920,16 +32855,16 @@ function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveS
 var MAX_DOWNLOAD_BYTES3 = 256 * 1024 * 1024;
 var MAX_EXTRACT_BYTES2 = 1024 * 1024 * 1024;
 function sha256OfFile(path3) {
-  return new Promise((resolve5, reject) => {
-    const hash2 = createHash5("sha256");
+  return new Promise((resolve9, reject) => {
+    const hash2 = createHash6("sha256");
     const stream = createReadStream2(path3);
     stream.on("error", reject);
     stream.on("data", (chunk) => hash2.update(chunk));
-    stream.on("end", () => resolve5(hash2.digest("hex")));
+    stream.on("end", () => resolve9(hash2.digest("hex")));
   });
 }
 function sha256OfFileSync2(path3) {
-  return createHash5("sha256").update(readFileSync12(path3)).digest("hex");
+  return createHash6("sha256").update(readFileSync14(path3)).digest("hex");
 }
 async function fetchReleaseByTag(githubRepo, tag, fetchImpl, signal) {
   const candidates = [];
@@ -33122,7 +33057,7 @@ async function downloadFile(url2, destPath, fetchImpl, assetSize, signal) {
     await pipeline3(nodeStream, createWriteStream3(destPath), { signal: timeout.signal });
   } catch (err) {
     try {
-      unlinkSync6(destPath);
+      unlinkSync7(destPath);
     } catch {}
     throw err;
   } finally {
@@ -33161,7 +33096,7 @@ function validateExtraction(stagingRoot) {
       throw new Error(`failed to read staging dir ${dir}: ${err}`);
     }
     for (const entry of entries) {
-      const full = join18(dir, entry);
+      const full = join17(dir, entry);
       let lst;
       try {
         lst = lstatSync2(full);
@@ -33182,7 +33117,7 @@ function validateExtraction(stagingRoot) {
         throw new Error(`failed to realpath ${full}: ${err}`);
       }
       const rel = relative3(realStagingRoot, realFull);
-      if (rel.startsWith("..") || resolve4(realStagingRoot, rel) !== realFull) {
+      if (rel.startsWith("..") || resolve8(realStagingRoot, rel) !== realFull) {
         throw new Error(`archive entry escapes staging root: ${full} → ${realFull} (zip-slip defense)`);
       }
       if (lst.isDirectory()) {
@@ -33229,7 +33164,7 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
   const suffix = randomBytes(8).toString("hex");
   const stagingDir = `${destDir}.staging-${suffix}`;
   try {
-    rmSync6(stagingDir, { recursive: true, force: true });
+    rmSync7(stagingDir, { recursive: true, force: true });
   } catch {}
   mkdirSync9(stagingDir, { recursive: true });
   try {
@@ -33237,24 +33172,24 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
     runPlatformExtractor(archivePath, stagingDir, archiveType);
     validateExtraction(stagingDir);
     try {
-      rmSync6(destDir, { recursive: true, force: true });
+      rmSync7(destDir, { recursive: true, force: true });
     } catch {}
-    renameSync7(stagingDir, destDir);
+    renameSync8(stagingDir, destDir);
   } catch (err) {
     try {
-      rmSync6(stagingDir, { recursive: true, force: true });
+      rmSync7(stagingDir, { recursive: true, force: true });
     } catch {}
     throw err;
   }
 }
 function quarantineCachedGithubInstall(spec, reason) {
   const packageDir = ghPackageDir(spec);
-  const dest = join18(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
+  const dest = join17(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
     mkdirSync9(dirname8(dest), { recursive: true });
-    rmSync6(dest, { recursive: true, force: true });
-    renameSync7(packageDir, dest);
+    rmSync7(dest, { recursive: true, force: true });
+    renameSync8(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.id}: failed to quarantine cache entry: ${err}`);
   }
@@ -33262,9 +33197,9 @@ function quarantineCachedGithubInstall(spec, reason) {
 function validateCachedGithubInstall(spec, platform3) {
   const packageDir = ghPackageDir(spec);
   const meta3 = readGithubInstalledMetaIn(packageDir);
-  const binaryPath = ghBinaryCandidates(spec, platform3).map((candidate) => join18(ghBinDir(spec), candidate)).find((candidate) => {
+  const binaryPath = ghBinaryCandidates(spec, platform3).map((candidate) => join17(ghBinDir(spec), candidate)).find((candidate) => {
     try {
-      return statSync7(candidate).isFile();
+      return statSync8(candidate).isFile();
     } catch {
       return false;
     }
@@ -33340,7 +33275,7 @@ async function downloadAndInstall(spec, tag, assets, platform3, arch, fetchImpl,
   }
   const pkgDir = ghPackageDir(spec);
   const extractDir = ghExtractDir(spec);
-  const archivePath = join18(pkgDir, expected.name);
+  const archivePath = join17(pkgDir, expected.name);
   log2(`[lsp] downloading ${spec.id} ${tag} → ${matchingAsset.url}`);
   try {
     await downloadFile(matchingAsset.url, archivePath, fetchImpl, matchingAsset.size, signal);
@@ -33354,7 +33289,7 @@ async function downloadAndInstall(spec, tag, assets, platform3, arch, fetchImpl,
   } catch (err) {
     error2(`[lsp] hash ${spec.id} failed: ${err}`);
     try {
-      unlinkSync6(archivePath);
+      unlinkSync7(archivePath);
     } catch {}
     return null;
   }
@@ -33365,7 +33300,7 @@ async function downloadAndInstall(spec, tag, assets, platform3, arch, fetchImpl,
     if (previousArchiveSha256 !== archiveSha256) {
       error2(`[lsp] ${spec.id} ${tag}: TOFU sha256 mismatch — refusing install. ` + `Previously installed archive sha256=${previousArchiveSha256}, downloaded sha256=${archiveSha256}. ` + `This means the published release for tag ${tag} changed. Investigate before proceeding. ` + `Run \`aft doctor --clear\` to wipe the cache and force a fresh install if you've verified the change.`);
       try {
-        unlinkSync6(archivePath);
+        unlinkSync7(archivePath);
       } catch {}
       return null;
     }
@@ -33377,11 +33312,11 @@ async function downloadAndInstall(spec, tag, assets, platform3, arch, fetchImpl,
     return null;
   } finally {
     try {
-      unlinkSync6(archivePath);
+      unlinkSync7(archivePath);
     } catch {}
   }
-  const innerBinaryPath = join18(extractDir, spec.binaryPathInArchive(platform3, arch, version2));
-  if (!existsSync13(innerBinaryPath)) {
+  const innerBinaryPath = join17(extractDir, spec.binaryPathInArchive(platform3, arch, version2));
+  if (!existsSync14(innerBinaryPath)) {
     error2(`[lsp] ${spec.id}: extracted binary not found at ${innerBinaryPath}`);
     return null;
   }
@@ -33465,7 +33400,7 @@ function runGithubAutoInstall(relevantServers, config2, fetchImpl = fetch) {
   if (!host) {
     for (const spec of GITHUB_LSP_TABLE) {
       try {
-        if (existsSync13(ghBinDir(spec))) {
+        if (existsSync14(ghBinDir(spec))) {
           cachedBinDirs.push(ghBinDir(spec));
         }
       } catch {}
@@ -33703,33 +33638,77 @@ function renderScreen(state, rows = state.rows, cols = state.cols) {
 `);
 }
 function writeTerminal(terminal, data) {
-  return new Promise((resolve5) => terminal.write(data, resolve5));
+  return new Promise((resolve9) => terminal.write(data, resolve9));
+}
+
+// src/shared/rpc-notifications.ts
+var queue = [];
+var nextNotificationId = 1;
+var lastDrainAtBySession = new Map;
+var lastDrainAtAny = 0;
+var TUI_CONNECTED_WINDOW_MS = 3000;
+function pushNotification(type, payload, sessionId) {
+  queue.push({ id: nextNotificationId++, type, payload, sessionId });
+  if (queue.length > 100) {
+    const newestPerSession = new Map;
+    for (const notification of queue) {
+      const previous = newestPerSession.get(notification.sessionId);
+      if (previous === undefined || notification.id > previous) {
+        newestPerSession.set(notification.sessionId, notification.id);
+      }
+    }
+    const mustKeep = new Set(newestPerSession.values());
+    const byNewest = [...queue].sort((a, b) => b.id - a.id);
+    const kept = [];
+    for (const notification of byNewest) {
+      if (kept.length < 50 || mustKeep.has(notification.id))
+        kept.push(notification);
+    }
+    queue = kept.sort((a, b) => a.id - b.id);
+  }
+}
+function drainNotifications(lastReceivedId = 0, sessionId) {
+  const now = Date.now();
+  lastDrainAtAny = now;
+  if (sessionId !== undefined)
+    lastDrainAtBySession.set(sessionId, now);
+  const matchesClient = (notification) => sessionId === undefined || notification.sessionId === undefined || notification.sessionId === sessionId;
+  if (lastReceivedId > 0) {
+    queue = queue.filter((notification) => !(notification.id <= lastReceivedId && matchesClient(notification)));
+  }
+  return queue.filter((notification) => notification.id > lastReceivedId && matchesClient(notification));
+}
+function isTuiConnected(sessionId) {
+  const now = Date.now();
+  if (sessionId !== undefined) {
+    const at = lastDrainAtBySession.get(sessionId) ?? 0;
+    return at > 0 && now - at < TUI_CONNECTED_WINDOW_MS;
+  }
+  return lastDrainAtAny > 0 && now - lastDrainAtAny < TUI_CONNECTED_WINDOW_MS;
 }
 
 // src/shared/rpc-server.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 import {
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   mkdirSync as mkdirSync10,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync13,
-  renameSync as renameSync8,
-  unlinkSync as unlinkSync7,
-  writeFileSync as writeFileSync10
+  readFileSync as readFileSync15,
+  renameSync as renameSync9,
+  unlinkSync as unlinkSync8,
+  writeFileSync as writeFileSync11
 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname9, join as join20 } from "node:path";
+import { dirname as dirname9, join as join19 } from "node:path";
 
 // src/shared/rpc-utils.ts
-import { createHash as createHash6 } from "node:crypto";
-import { join as join19 } from "node:path";
+import { join as join18 } from "node:path";
 function projectHash(directory) {
-  const normalized = directory.replace(/\/+$/, "");
-  return createHash6("sha256").update(normalized).digest("hex").slice(0, 16);
+  return projectRootKeyHash(directory);
 }
 function rpcPortFileDir(storageDir, directory) {
   const hash2 = projectHash(directory);
-  return join19(storageDir, "rpc", hash2, "ports");
+  return join18(storageDir, "rpc", hash2, "ports");
 }
 function isPidAlive(pid) {
   if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
@@ -33782,13 +33761,13 @@ class AftRpcServer {
   constructor(storageDir, directory) {
     this.portsDir = rpcPortFileDir(storageDir, directory);
     this.instanceId = randomBytes2(8).toString("hex");
-    this.portFilePath = join20(this.portsDir, `${this.instanceId}.json`);
+    this.portFilePath = join19(this.portsDir, `${this.instanceId}.json`);
   }
   handle(method, handler) {
     this.handlers.set(method, handler);
   }
   async start() {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve9, reject) => {
       const server = createServer((req, res) => this.dispatch(req, res));
       server.on("error", (err) => {
         warn2(`RPC server error: ${err.message}`);
@@ -33807,13 +33786,13 @@ class AftRpcServer {
           const dir = dirname9(this.portFilePath);
           mkdirSync10(dir, { recursive: true, mode: 448 });
           const tmpPath = `${this.portFilePath}.tmp`;
-          writeFileSync10(tmpPath, JSON.stringify({
+          writeFileSync11(tmpPath, JSON.stringify({
             port: this.port,
             token: this.token,
             pid: process.pid,
             started_at: Date.now()
           }), { encoding: "utf-8", mode: 384 });
-          renameSync8(tmpPath, this.portFilePath);
+          renameSync9(tmpPath, this.portFilePath);
           log2(`RPC server listening on 127.0.0.1:${this.port}`);
           this.heartbeatTimer = setInterval(() => this.ensurePortFile(), PORT_FILE_HEARTBEAT_MS);
           this.heartbeatTimer.unref?.();
@@ -33821,7 +33800,7 @@ class AftRpcServer {
         } catch (err) {
           warn2(`Failed to write RPC port file: ${err}`);
         }
-        resolve5(this.port);
+        resolve9(this.port);
       });
       server.unref();
     });
@@ -33836,17 +33815,17 @@ class AftRpcServer {
     for (const entry of entries) {
       if (!entry.endsWith(".json"))
         continue;
-      const filePath = join20(this.portsDir, entry);
+      const filePath = join19(this.portsDir, entry);
       if (filePath === this.portFilePath)
         continue;
       try {
-        const record2 = parseRpcPortRecord(readFileSync13(filePath, "utf-8"));
+        const record2 = parseRpcPortRecord(readFileSync15(filePath, "utf-8"));
         if (record2 === null) {
-          unlinkSync7(filePath);
+          unlinkSync8(filePath);
           continue;
         }
         if (record2.pid !== undefined && !isPidAlive(record2.pid)) {
-          unlinkSync7(filePath);
+          unlinkSync8(filePath);
         }
       } catch {}
     }
@@ -33855,16 +33834,16 @@ class AftRpcServer {
     if (!this.server || this.token === null)
       return;
     try {
-      if (existsSync14(this.portFilePath))
+      if (existsSync15(this.portFilePath))
         return;
       const tmpPath = `${this.portFilePath}.tmp`;
-      writeFileSync10(tmpPath, JSON.stringify({
+      writeFileSync11(tmpPath, JSON.stringify({
         port: this.port,
         token: this.token,
         pid: process.pid,
         started_at: Date.now()
       }), { encoding: "utf-8", mode: 384 });
-      renameSync8(tmpPath, this.portFilePath);
+      renameSync9(tmpPath, this.portFilePath);
       log2(`RPC port file was missing; rewrote ${this.portFilePath}`);
     } catch {}
   }
@@ -33879,7 +33858,7 @@ class AftRpcServer {
     }
     this.token = null;
     try {
-      unlinkSync7(this.portFilePath);
+      unlinkSync8(this.portFilePath);
     } catch {}
   }
   dispatch(req, res) {
@@ -34240,33 +34219,33 @@ function formatStatusMarkdown(status) {
 
 // src/shared/tui-config.ts
 var import_comment_json4 = __toESM(require_src2(), 1);
-import { existsSync as existsSync15, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname10, join as join22 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync16, writeFileSync as writeFileSync12 } from "node:fs";
+import { dirname as dirname10, join as join21 } from "node:path";
 
 // src/shared/opencode-config-dir.ts
 import { homedir as homedir13 } from "node:os";
-import { join as join21, resolve as resolve5 } from "node:path";
+import { join as join20, resolve as resolve9 } from "node:path";
 function getCliConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envConfigDir) {
-    return resolve5(envConfigDir);
+    return resolve9(envConfigDir);
   }
   if (process.platform === "win32") {
-    return join21(homedir13(), ".config", "opencode");
+    return join20(homedir13(), ".config", "opencode");
   }
-  return join21(process.env.XDG_CONFIG_HOME || join21(homedir13(), ".config"), "opencode");
+  return join20(process.env.XDG_CONFIG_HOME || join20(homedir13(), ".config"), "opencode");
 }
-function getOpenCodeConfigDir2(_options) {
+function getOpenCodeConfigDir(_options) {
   return getCliConfigDir();
 }
 function getOpenCodeConfigPaths(options) {
-  const configDir = getOpenCodeConfigDir2(options);
+  const configDir = getOpenCodeConfigDir(options);
   return {
     configDir,
-    configJson: join21(configDir, "opencode.json"),
-    configJsonc: join21(configDir, "opencode.jsonc"),
-    packageJson: join21(configDir, "package.json"),
-    omoConfig: join21(configDir, "magic-context.jsonc")
+    configJson: join20(configDir, "opencode.json"),
+    configJsonc: join20(configDir, "opencode.jsonc"),
+    packageJson: join20(configDir, "package.json"),
+    omoConfig: join20(configDir, "magic-context.jsonc")
   };
 }
 
@@ -34275,11 +34254,11 @@ var PLUGIN_NAME = "@cortexkit/aft-opencode";
 var PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
 function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join22(configDir, "tui.jsonc");
-  const jsonPath = join22(configDir, "tui.json");
-  if (existsSync15(jsoncPath))
+  const jsoncPath = join21(configDir, "tui.jsonc");
+  const jsonPath = join21(configDir, "tui.json");
+  if (existsSync16(jsoncPath))
     return jsoncPath;
-  if (existsSync15(jsonPath))
+  if (existsSync16(jsonPath))
     return jsonPath;
   return jsonPath;
 }
@@ -34287,8 +34266,8 @@ function ensureTuiPluginEntry() {
   try {
     const configPath = resolveTuiConfigPath();
     let config2 = {};
-    if (existsSync15(configPath)) {
-      config2 = import_comment_json4.parse(readFileSync14(configPath, "utf-8")) ?? {};
+    if (existsSync16(configPath)) {
+      config2 = import_comment_json4.parse(readFileSync16(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"))) {
@@ -34297,7 +34276,7 @@ function ensureTuiPluginEntry() {
     plugins.push(PLUGIN_ENTRY);
     config2.plugin = plugins;
     mkdirSync11(dirname10(configPath), { recursive: true });
-    writeFileSync11(configPath, `${import_comment_json4.stringify(config2, null, 2)}
+    writeFileSync12(configPath, `${import_comment_json4.stringify(config2, null, 2)}
 `);
     log2(`[aft-plugin] added TUI plugin entry to ${configPath}`);
     return true;
@@ -34365,8 +34344,8 @@ function installProcessHandlers() {
       }
       signalShutdownStarted = true;
       process.exitCode = SIGNAL_EXIT_CODES[sig];
-      const timeout = new Promise((resolve6) => {
-        setTimeout(resolve6, SIGNAL_CLEANUP_TIMEOUT_MS);
+      const timeout = new Promise((resolve10) => {
+        setTimeout(resolve10, SIGNAL_CLEANUP_TIMEOUT_MS);
       });
       Promise.race([runCleanups(sig), timeout]).finally(() => {
         process.exit(SIGNAL_EXIT_CODES[sig]);
@@ -34477,7 +34456,6 @@ function instrumentToolMap(tools) {
 import { tool as tool3 } from "@opencode-ai/plugin";
 
 // src/tools/_shared.ts
-import * as fs3 from "node:fs";
 import * as os3 from "node:os";
 import * as path3 from "node:path";
 import { tool as tool2 } from "@opencode-ai/plugin";
@@ -34485,12 +34463,7 @@ var z2 = tool2.schema;
 var optionalInt = (min, max) => z2.number().int().min(min).max(max).optional();
 var BASH_TRANSPORT_TIMEOUT_MS = 30000;
 function canonicalizeDirectory(dir) {
-  const trimmed = dir.replace(/[/\\]+$/, "");
-  try {
-    return fs3.realpathSync(trimmed);
-  } catch {
-    return path3.resolve(trimmed);
-  }
+  return canonicalizeProjectRoot(dir);
 }
 function projectRootFor(runtime) {
   const cached2 = getSessionDirectoryCached(runtime.sessionID);
@@ -34559,7 +34532,7 @@ async function callBashBridge(ctx, runtime, command, params = {}, options) {
 }
 
 // src/tools/permissions.ts
-import * as fs4 from "node:fs";
+import * as fs3 from "node:fs";
 import * as path4 from "node:path";
 var UNSUPPORTED_ASK_HOST = "AFT requires OpenCode 1.15.5 or newer for permission asks; please upgrade OpenCode";
 var RESTRICT_NOTICE_THROTTLE_MS = 5 * 60 * 1000;
@@ -34646,7 +34619,7 @@ function normalizePath(p) {
     return p;
   const resolved = path4.resolve(windowsPath(p));
   try {
-    return fs4.realpathSync.native(resolved);
+    return fs3.realpathSync.native(resolved);
   } catch {
     return resolved;
   }
@@ -34828,8 +34801,9 @@ function astTools(ctx) {
         params.paths = paths;
       if (!isEmptyParam(args.globs))
         params.globs = args.globs;
-      if (args.contextLines !== undefined)
-        params.context = Number(args.contextLines);
+      const contextLines = coerceOptionalInt(args.contextLines, "contextLines", 1, Number.MAX_SAFE_INTEGER);
+      if (contextLines !== undefined)
+        params.context = contextLines;
       const response = await callBridge(ctx, context, "ast_search", params);
       if (response.success === false) {
         throw new Error(response.message || "ast_search failed");
@@ -34913,7 +34887,7 @@ ${hint}`;
       dryRun: z3.boolean().optional().describe("Preview changes without applying (default: false)")
     },
     execute: async (args, context) => {
-      const isDryRun = args.dryRun === true;
+      const isDryRun = coerceBoolean(args.dryRun);
       const paths = await resolveAstPaths(ctx, context, args.paths);
       const externalDenied = await checkAstPathsPermission(ctx, context, paths);
       if (externalDenied)
@@ -34945,7 +34919,7 @@ ${hint}`;
         params.paths = paths;
       if (!isEmptyParam(args.globs))
         params.globs = args.globs;
-      params.dry_run = args.dryRun === true;
+      params.dry_run = coerceBoolean(args.dryRun);
       const response = await callBridge(ctx, context, "ast_replace", params);
       if (response.success === false) {
         throw new Error(response.message || "ast_replace failed");
@@ -35118,8 +35092,8 @@ function resolveForegroundWaitMs(configured) {
 }
 function bashToolDescription(aftSearchRegistered, compressionOn, backgroundOn) {
   const searchSteer = aftSearchRegistered ? "use aft_search (concepts, identifiers, regex, literals), read, aft_outline, or aft_zoom instead" : "use the grep tool, read, aft_outline, or aft_zoom instead";
-  const compression = compressionOn ? " Output is compressed by default; pass compressed: false for raw output." : "";
-  const tasks = backgroundOn ? ' Pass background: true to run in the background and get a taskId for bash_status/bash_watch/bash_kill. Pass pty: true for interactive programs (REPLs, TUIs) and drive them with bash_status({ outputMode: "screen" }) plus bash_write (pty implies background automatically). Use bash_watch to wait for exit or output patterns (sync blocks, async notifies). Do not loop bash_status to wait.' : " Commands run in the foreground to completion; timeout is the hard kill cap (default 30 minutes).";
+  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." : "";
+  const tasks = backgroundOn ? ' Commands run in the foreground and return inline; a long-running one auto-promotes to background and delivers a completion reminder when it finishes — so for the common "I am waiting on this result" case, just run it and wait, no flags needed. Use background: true yourself ONLY when you have other useful work to do while it runs; then bash_watch waits on the task (sync blocks until exit/pattern, async notifies) and bash_status peeks at it — 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. 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).";
   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}.`;
@@ -35200,14 +35174,12 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
       const description = args2.description;
       const metadata = context.metadata;
       const rawCommand = args2.command;
-      const compressionEnabled = bashCfg.compress && args2.compressed !== false;
-      const pipeStrip = maybeStripCompressorPipe(rawCommand, compressionEnabled);
-      const command = pipeStrip.command;
+      const command = rawCommand;
       const cwd = args2.workdir ?? context.directory;
       const isSubagent = await resolveIsSubagent(ctx.client, context.sessionID, context.directory);
       const backgroundDisabled = !bashCfg.background;
-      const requestedPty = !backgroundDisabled && args2.pty === true;
-      const requestedBackground = !backgroundDisabled && (args2.background === true || requestedPty);
+      const requestedPty = !backgroundDisabled && coerceBoolean(args2.pty);
+      const requestedBackground = !backgroundDisabled && (coerceBoolean(args2.background) || requestedPty);
       if (requestedPty && isSubagent) {
         throw new Error("PTY mode is not available in subagent sessions; subagents cannot drive interactive terminals.");
       }
@@ -35215,7 +35187,10 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
       const subagentForcedForeground = isSubagent && !allowSubagentBg;
       const blockToCompletion = subagentForcedForeground || backgroundDisabled;
       const effectiveBackground = blockToCompletion ? false : requestedBackground;
-      const rawTimeout = args2.timeout;
+      const rawTimeout = coerceOptionalInt(args2.timeout, "timeout", 1, Number.MAX_SAFE_INTEGER);
+      const ptyRows = coerceOptionalInt(args2.ptyRows, "ptyRows", 1, 60);
+      const ptyCols = coerceOptionalInt(args2.ptyCols, "ptyCols", 1, 140);
+      const compressed = coerceBoolean(args2.compressed, true);
       const effectiveTimeout = effectiveBackground || backgroundDisabled ? rawTimeout : resolveBashKillTimeout(rawTimeout, bashCfg.foreground_wait_window_ms);
       if (subagentForcedForeground && requestedBackground) {
         sessionLog(context.sessionID, "[bash] subagent + background:true → converting to foreground (subagent would lose task_id)");
@@ -35229,10 +35204,10 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
         description,
         background: effectiveBackground,
         notify_on_completion: effectiveBackground,
-        compressed: args2.compressed,
+        compressed,
         pty: requestedPty,
-        pty_rows: args2.ptyRows,
-        pty_cols: args2.ptyCols,
+        pty_rows: ptyRows,
+        pty_cols: ptyCols,
         permissions_requested: true
       }, callBashBridge, {
         onProgress: ({ text }) => {
@@ -35251,7 +35226,6 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
           let startedLine = formatBackgroundLaunch(taskId, requestedPty);
           if (isSubagent && allowSubagentBg)
             startedLine += subagentGuidance(taskId);
-          startedLine = appendPipeStripNote(startedLine, pipeStrip.note);
           const metadataPayload2 = { description, output: startedLine, status: "running", taskId };
           metadata?.(metadataPayload2);
           return { output: startedLine, title: uiTitle, metadata: metadataPayload2 };
@@ -35265,7 +35239,7 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
             throw new Error(status.message ?? "bash_status failed");
           }
           if (isTerminalStatus(status.status)) {
-            const rendered2 = maybeAppendGrepSearchHint(appendPipeStripNote(formatForegroundResult(status), pipeStrip.note), command, aftSearchRegistered, projectRootFor(context));
+            const rendered2 = maybeAppendGrepSearchHint(formatForegroundResult(status), command, aftSearchRegistered, projectRootFor(context));
             const metadataPayload2 = foregroundMetadata(description, status, rendered2);
             metadata?.(metadataPayload2);
             return { output: rendered2, title: uiTitle, metadata: metadataPayload2 };
@@ -35285,7 +35259,6 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
             let message = formatPromotionMessage(taskId, effectiveTimeout, foregroundWaitMs);
             if (isSubagent && allowSubagentBg)
               message += subagentGuidance(taskId);
-            message = appendPipeStripNote(message, pipeStrip.note);
             const metadataPayload2 = { description, output: message, status: "running", taskId };
             metadata?.(metadataPayload2);
             return { output: message, title: uiTitle, metadata: metadataPayload2 };
@@ -35320,7 +35293,6 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
         rendered += `
 [exit code: ${exit}]`;
       }
-      rendered = appendPipeStripNote(rendered, pipeStrip.note);
       return {
         output: rendered,
         title: description ?? shortenCommand(command),
@@ -35501,7 +35473,7 @@ function conflictTools(ctx) {
 }
 
 // src/tools/hoisted.ts
-import * as fs6 from "node:fs";
+import * as fs5 from "node:fs";
 import * as path5 from "node:path";
 import { tool as tool8 } from "@opencode-ai/plugin";
 
@@ -35641,6 +35613,16 @@ function normalizeUnicode(str) {
 function normalizeIndent(str) {
   return str.replace(/^[\t ]+/, (m) => " ".repeat(m.length));
 }
+var REFLOW_NON_WS_TOLERANCE = 8;
+function normalizeReflowWhitespace(str) {
+  return str.replace(/\s+/gu, " ").trim();
+}
+function stripReflowWhitespace(str) {
+  return str.replace(/\s+/gu, "");
+}
+function hasReflowContent(str) {
+  return /\S/u.test(str);
+}
 function tryMatch(lines, pattern, startIndex, compare, eof) {
   if (eof) {
     const fromEnd = lines.length - pattern.length;
@@ -35655,6 +35637,7 @@ function tryMatch(lines, pattern, startIndex, compare, eof) {
       if (matches)
         return fromEnd;
     }
+    return -1;
   }
   for (let i = startIndex;i <= lines.length - pattern.length; i++) {
     let matches = true;
@@ -35669,24 +35652,69 @@ function tryMatch(lines, pattern, startIndex, compare, eof) {
   }
   return -1;
 }
+function findReflowMatch(lines, pattern, startIndex) {
+  const needleText = pattern.join(`
+`);
+  const normalizedNeedle = normalizeReflowWhitespace(needleText);
+  const needleNonWhitespace = stripReflowWhitespace(needleText);
+  if (normalizedNeedle.length === 0 || needleNonWhitespace.length === 0)
+    return null;
+  const minNonWhitespace = Math.max(0, needleNonWhitespace.length - REFLOW_NON_WS_TOLERANCE);
+  const maxNonWhitespace = needleNonWhitespace.length + REFLOW_NON_WS_TOLERANCE;
+  const matches = [];
+  const seen = new Set;
+  for (let start = Math.max(0, startIndex);start < lines.length; start++) {
+    if (!hasReflowContent(lines[start]))
+      continue;
+    let windowNonWhitespaceLen = 0;
+    for (let end = start + 1;end <= lines.length; end++) {
+      const line = lines[end - 1];
+      windowNonWhitespaceLen += stripReflowWhitespace(line).length;
+      if (windowNonWhitespaceLen > maxNonWhitespace)
+        break;
+      if (windowNonWhitespaceLen < minNonWhitespace)
+        continue;
+      if (!hasReflowContent(line))
+        continue;
+      const windowText = lines.slice(start, end).join(`
+`);
+      const windowNonWhitespace = stripReflowWhitespace(windowText);
+      if (windowNonWhitespace !== needleNonWhitespace)
+        continue;
+      if (normalizeReflowWhitespace(windowText) !== normalizedNeedle)
+        continue;
+      const key = `${start}:${end}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        matches.push({ found: start, lineCount: end - start });
+      }
+    }
+  }
+  return matches.length === 1 ? matches[0] : null;
+}
 function seekSequenceTiered(lines, pattern, startIndex, eof = false) {
   if (pattern.length === 0)
     return null;
   const exact = tryMatch(lines, pattern, startIndex, (a, b) => a === b, eof);
   if (exact !== -1)
-    return { found: exact, tier: "exact" };
+    return { found: exact, tier: "exact", lineCount: pattern.length };
   const rstrip = tryMatch(lines, pattern, startIndex, (a, b) => a.trimEnd() === b.trimEnd(), eof);
   if (rstrip !== -1)
-    return { found: rstrip, tier: "rstrip" };
+    return { found: rstrip, tier: "rstrip", lineCount: pattern.length };
   const trim = tryMatch(lines, pattern, startIndex, (a, b) => a.trim() === b.trim(), eof);
   if (trim !== -1)
-    return { found: trim, tier: "trim" };
+    return { found: trim, tier: "trim", lineCount: pattern.length };
   const indent = tryMatch(lines, pattern, startIndex, (a, b) => normalizeIndent(a).trimEnd() === normalizeIndent(b).trimEnd(), eof);
   if (indent !== -1)
-    return { found: indent, tier: "indent" };
+    return { found: indent, tier: "indent", lineCount: pattern.length };
   const unicode = tryMatch(lines, pattern, startIndex, (a, b) => normalizeUnicode(a.trim()) === normalizeUnicode(b.trim()), eof);
   if (unicode !== -1)
-    return { found: unicode, tier: "unicode" };
+    return { found: unicode, tier: "unicode", lineCount: pattern.length };
+  if (eof)
+    return null;
+  const reflow = findReflowMatch(lines, pattern, startIndex);
+  if (reflow)
+    return { ...reflow, tier: "reflow" };
   return null;
 }
 function seekSequence(lines, pattern, startIndex, eof = false) {
@@ -35732,11 +35760,11 @@ function applyUpdateChunks(originalContent, filePath, chunks) {
   let lineIndex = 0;
   for (const chunk of chunks) {
     if (chunk.change_context) {
-      const contextIdx = seekSequence(originalLines, [chunk.change_context], lineIndex);
-      if (contextIdx === -1) {
+      const contextMatch = seekSequenceTiered(originalLines, [chunk.change_context], lineIndex);
+      if (!contextMatch) {
         throw new Error(`Failed to find context '${chunk.change_context}' in ${filePath}`);
       }
-      lineIndex = contextIdx + 1;
+      lineIndex = contextMatch.found + contextMatch.lineCount;
     }
     if (chunk.old_lines.length === 0) {
       let insertionIdx;
@@ -35752,17 +35780,17 @@ function applyUpdateChunks(originalContent, filePath, chunks) {
     }
     let pattern = chunk.old_lines;
     let newSlice = chunk.new_lines;
-    let found = seekSequence(originalLines, pattern, lineIndex, chunk.is_end_of_file);
-    if (found === -1 && pattern.length > 0 && pattern[pattern.length - 1] === "") {
+    let match = seekSequenceTiered(originalLines, pattern, lineIndex, chunk.is_end_of_file);
+    if (!match && pattern.length > 0 && pattern[pattern.length - 1] === "") {
       pattern = pattern.slice(0, -1);
       if (newSlice.length > 0 && newSlice[newSlice.length - 1] === "") {
         newSlice = newSlice.slice(0, -1);
       }
-      found = seekSequence(originalLines, pattern, lineIndex, chunk.is_end_of_file);
+      match = seekSequenceTiered(originalLines, pattern, lineIndex, chunk.is_end_of_file);
     }
-    if (found !== -1) {
-      replacements.push([found, pattern.length, newSlice]);
-      lineIndex = found + pattern.length;
+    if (match) {
+      replacements.push([match.found, match.lineCount, newSlice]);
+      lineIndex = match.found + match.lineCount;
     } else {
       const newSliceTrimmed = newSlice.filter((line) => line.trim().length > 0);
       const alreadyApplied = newSliceTrimmed.length > 0 && seekSequence(originalLines, newSliceTrimmed, 0, chunk.is_end_of_file) !== -1;
@@ -35779,7 +35807,7 @@ Closest match starts at line ${closest.lineNumber} ` + `(${closest.matchedLines}
 ` + `  expected: ${JSON.stringify(expectedLine)}
 ` + `  actual:   ${JSON.stringify(actualLine)}`;
       }
-      const triedTiers = "exact, trimEnd, trim, indent (tab/space), unicode";
+      const triedTiers = "exact, trimEnd, trim, indent (tab/space), unicode, reflow (whitespace-normalized)";
       const alreadyAppliedHint = alreadyApplied ? `
 
 Hint: the replacement content for this hunk already appears in the file. ` + "The patch may have been partially applied in a prior turn — re-read the file " + "to confirm which hunks still need to apply." : "";
@@ -35804,7 +35832,7 @@ ${chunk.old_lines.join(`
 }
 
 // src/tools/bash_watch.ts
-import * as fs5 from "node:fs/promises";
+import * as fs4 from "node:fs/promises";
 import { tool as tool6 } from "@opencode-ai/plugin";
 var z6 = tool6.schema;
 var BASH_WAIT_POLL_INTERVAL_MS = 100;
@@ -35826,7 +35854,7 @@ function createBashWatchTool(ctx) {
     },
     execute: async (args, context) => {
       const taskId = args.taskId;
-      const requestedAsync = args.background === true;
+      const requestedAsync = coerceBoolean(args.background);
       const waitFor = parseWaitPattern(args.pattern);
       const bashCfg = resolveBashConfig(ctx.config);
       const isSubagent = await resolveIsSubagent(ctx.client, context.sessionID, context.directory);
@@ -35838,7 +35866,7 @@ function createBashWatchTool(ctx) {
         }
         const notifyParams = {
           task_id: taskId,
-          once: args.once !== false
+          once: coerceBoolean(args.once, true)
         };
         if (waitFor.kind === "regex")
           notifyParams.regex = waitFor.source;
@@ -35865,11 +35893,11 @@ function createBashWatchTool(ctx) {
         return `Watch registered: ${registered.watch_id} on task ${taskId}
 A notification will fire when the pattern matches or the task exits.`;
       }
-      const effectiveWaitMs = subagentForcedSync ? MAX_BASH_STATUS_WAIT_TIMEOUT_MS : Math.min(args.timeoutMs ?? DEFAULT_BASH_STATUS_WAIT_TIMEOUT_MS, MAX_BASH_STATUS_WAIT_TIMEOUT_MS);
+      const effectiveWaitMs = subagentForcedSync ? MAX_BASH_STATUS_WAIT_TIMEOUT_MS : Math.min(coerceOptionalInt(args.timeoutMs, "timeoutMs", 1, MAX_BASH_STATUS_WAIT_TIMEOUT_MS) ?? DEFAULT_BASH_STATUS_WAIT_TIMEOUT_MS, MAX_BASH_STATUS_WAIT_TIMEOUT_MS);
       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, args.once !== false);
+        const convertedText = await convertToAsyncWatchOnAbort(ctx, context, taskId, waitFor, coerceBoolean(args.once, true));
         const metadata2 = context.metadata;
         metadata2?.({ taskId, status: data.status, waited, convertedToAsync: true });
         return convertedText;
@@ -36068,7 +36096,7 @@ async function readNewTaskOutput(runtime, taskId, data, cursor) {
   };
 }
 async function readFileBytesFrom(outputPath, cursor) {
-  const handle = await fs5.open(outputPath, "r");
+  const handle = await fs4.open(outputPath, "r");
   try {
     const chunks = [];
     let offset = cursor;
@@ -36396,7 +36424,7 @@ function diagnosticsOnEditDefault(ctx) {
 }
 async function readCurrentFileForPreview(filePath) {
   try {
-    return await fs6.promises.readFile(filePath, "utf-8");
+    return await fs5.promises.readFile(filePath, "utf-8");
   } catch (error50) {
     if (error50 && typeof error50 === "object" && "code" in error50 && error50.code === "ENOENT") {
       return "";
@@ -36426,7 +36454,7 @@ async function readPatchPreviewContent(virtualFiles, filePath, action, patchPath
     return virtualContent;
   }
   try {
-    return await fs6.promises.readFile(filePath, "utf-8");
+    return await fs5.promises.readFile(filePath, "utf-8");
   } catch (error50) {
     throw new Error(`Failed to ${action} ${patchPath}: ${formatError2(error50)}`);
   }
@@ -36442,7 +36470,7 @@ async function buildApplyPatchPreview(hunks, projectRoot) {
     switch (hunk.type) {
       case "add": {
         const virtualContent = virtualPatchContent(virtualFiles, filePath);
-        const exists = virtualContent !== undefined ? virtualContent !== null : fs6.existsSync(filePath);
+        const exists = virtualContent !== undefined ? virtualContent !== null : fs5.existsSync(filePath);
         if (exists) {
           throw new Error(`Failed to create ${hunk.path}: file already exists. Use *** Update File: to modify, or *** Delete File: first if you want to replace it entirely.`);
         }
@@ -36550,7 +36578,7 @@ function createReadTool(ctx) {
         const label = isImage ? "Image" : "PDF";
         let fileSize = 0;
         try {
-          const stat = await import("node:fs/promises").then((fs7) => fs7.stat(filePath));
+          const stat = await import("node:fs/promises").then((fs6) => fs6.stat(filePath));
           fileSize = stat.size;
         } catch {}
         const sizeStr = fileSize > 1048576 ? `${(fileSize / 1048576).toFixed(1)}MB` : fileSize > 1024 ? `${(fileSize / 1024).toFixed(0)}KB` : `${fileSize} bytes`;
@@ -36566,12 +36594,16 @@ function createReadTool(ctx) {
           }
         };
       }
-      let startLine = args.startLine;
-      let endLine = args.endLine;
-      if (startLine === undefined && args.offset !== undefined) {
-        startLine = args.offset;
-        if (args.limit !== undefined) {
-          endLine = Number(args.offset) + Number(args.limit) - 1;
+      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 params = { file: filePath };
@@ -36579,8 +36611,8 @@ function createReadTool(ctx) {
         params.start_line = startLine;
       if (endLine !== undefined)
         params.end_line = endLine;
-      if (args.limit !== undefined && args.offset === undefined)
-        params.limit = args.limit;
+      if (rawLimit !== undefined && rawOffset === undefined)
+        params.limit = rawLimit;
       const data = await callBridge(ctx, context, "read", params);
       if (data.success === false) {
         throw new Error(data.message || "read failed");
@@ -36598,7 +36630,7 @@ function createReadTool(ctx) {
         return { output: data.message, title: dp, metadata: { title: dp } };
       }
       let output = data.content;
-      const agentSpecifiedRange = args.startLine !== undefined || args.endLine !== undefined || args.offset !== undefined || args.limit !== undefined;
+      const agentSpecifiedRange = rawStartLine !== undefined || rawEndLine !== undefined || rawOffset !== undefined || rawLimit !== undefined;
       const footer = formatReadFooter2(agentSpecifiedRange, data);
       if (footer)
         output += footer;
@@ -36779,6 +36811,7 @@ function createEditTool(ctx, writeToolName = "write") {
           return permissionDeniedResponse(denial2);
       }
       const params = { file: filePath };
+      const occurrence = coerceOptionalInt(args.occurrence, "occurrence", 0, Number.MAX_SAFE_INTEGER);
       let command;
       if (typeof args.appendContent === "string") {
         command = "edit_match";
@@ -36812,10 +36845,10 @@ function createEditTool(ctx, writeToolName = "write") {
         command = "edit_match";
         params.match = args.oldString;
         params.replacement = args.newString ?? "";
-        if (args.replaceAll !== undefined)
-          params.replace_all = args.replaceAll;
-        if (args.occurrence !== undefined)
-          params.occurrence = args.occurrence;
+        if (coerceBoolean(args.replaceAll))
+          params.replace_all = true;
+        if (occurrence !== undefined)
+          params.occurrence = occurrence;
       } else {
         const hint = typeof args.content === "string" ? ` To write the whole file, use the '${writeToolName}' tool. To edit existing content, provide 'oldString' (and optionally 'newString'), 'symbol' + 'content', or an 'edits' array.` : " Provide 'oldString' (+ optional 'newString'), 'symbol' + 'content', or an 'edits' array.";
         throw new Error(`edit: no edit mode resolved from arguments.${hint}`);
@@ -36979,7 +37012,7 @@ function createApplyPatchTool(ctx) {
       const rememberAffectedPath = (abs) => {
         affectedAbs.add(abs);
         if (!initiallyExistsAbs.has(abs)) {
-          initiallyExistsAbs.set(abs, fs6.existsSync(abs));
+          initiallyExistsAbs.set(abs, fs5.existsSync(abs));
         }
       };
       for (const h of hunks) {
@@ -37041,7 +37074,7 @@ function createApplyPatchTool(ctx) {
         const filePath = resolvePathFromProjectRoot(projectRoot, hunk.path);
         switch (hunk.type) {
           case "add": {
-            if (fs6.existsSync(filePath)) {
+            if (fs5.existsSync(filePath)) {
               const msg = `Failed to create ${hunk.path}: file already exists. Use *** Update File: to modify, or *** Delete File: first if you want to replace it entirely.`;
               results.push(msg);
               failures.push({ index: hunkIndex, path: hunk.path });
@@ -37082,9 +37115,9 @@ function createApplyPatchTool(ctx) {
               results.push(msg);
               failures.push({ index: hunkIndex, path: hunk.path });
               const filePath2 = resolvePathFromProjectRoot(projectRoot, hunk.path);
-              if (fs6.existsSync(filePath2)) {
+              if (fs5.existsSync(filePath2)) {
                 try {
-                  fs6.rmSync(filePath2, { force: true });
+                  fs5.rmSync(filePath2, { force: true });
                 } catch {}
               }
             }
@@ -37092,7 +37125,7 @@ function createApplyPatchTool(ctx) {
           }
           case "delete": {
             try {
-              const before = await fs6.promises.readFile(filePath, "utf-8").catch(() => "");
+              const before = await fs5.promises.readFile(filePath, "utf-8").catch(() => "");
               const deleteResult = await callBridge(ctx, context, "delete_file", {
                 file: filePath
               });
@@ -37118,7 +37151,7 @@ function createApplyPatchTool(ctx) {
           }
           case "update": {
             try {
-              const original = await fs6.promises.readFile(filePath, "utf-8");
+              const original = await fs5.promises.readFile(filePath, "utf-8");
               const newContent = applyUpdateChunks(original, filePath, hunk.chunks);
               const targetPath = hunk.move_path ? resolvePathFromProjectRoot(projectRoot, hunk.move_path) : filePath;
               const writeResult = await callBridge(ctx, context, "write", {
@@ -37183,7 +37216,7 @@ ${diagLines}`);
                     if (rollbackResult.success === false) {
                       throw new Error(rollbackResult.message ?? "checkpoint restore failed");
                     }
-                    if (newlyCreatedAbs.has(targetPath) && fs6.existsSync(targetPath)) {
+                    if (newlyCreatedAbs.has(targetPath) && fs5.existsSync(targetPath)) {
                       const cleanupResult = await callBridge(ctx, context, "delete_file", {
                         file: targetPath
                       });
@@ -37312,7 +37345,7 @@ function createDeleteTool(ctx) {
       if (inputs.length === 0) {
         throw new Error("delete: `files` must be a non-empty array of paths");
       }
-      const recursive = args.recursive === true;
+      const recursive = coerceBoolean(args.recursive);
       const projectRoot = await resolveProjectRoot(ctx, context);
       const absolutePaths = inputs.map((f) => resolvePathFromProjectRoot(projectRoot, f));
       {
@@ -37708,7 +37741,7 @@ function createInspectTier2IdleScheduler(options) {
 }
 function inspectTools(ctx) {
   const inspectTool = {
-    description: "Codebase health snapshot. One call returns summary stats for: TODOs, diagnostics, file/symbol metrics, dead code, unused exports, code duplicates. Pass `sections` for per-category drill-down details.\n\n" + "Categories run in tiers — Tier 1 (todos, metrics) return synchronously from cache. Tier 2 (dead_code, unused_exports, duplicates) run as background scans triggered on session idle; calls may return cached `stale_categories: [...]` results or `pending_categories: [...]` while a refresh is in progress (waits up to 1s for fresh data before falling back to cached).\n\n" + `Use when: starting work on unfamiliar code, after multi-edit batches to check diagnostics, before a refactor, before review, or to verify cleanup completeness.
+    description: "Codebase health snapshot. One call returns summary stats for: TODOs, diagnostics, file/symbol metrics, dead code, unused exports, code duplicates. Pass `sections` for per-category drill-down details.\n\n" + "Categories run in tiers — Tier 1 (todos, metrics) return synchronously from cache. Tier 2 (dead_code, unused_exports, duplicates) waits for a fresh reuse scan up to a short deadline; if a category is still scanning the response reports `complete: false` with `pending_categories: [...]` rather than a fabricated clean count.\n\n" + `Use when: starting work on unfamiliar code, after multi-edit batches to check diagnostics, before a refactor, before review, or to verify cleanup completeness.
 
 ` + "Treat `dead_code` as a hint, not proof: reachability is call-based, so symbols reached only via method dispatch or referenced only in type position may be false positives — verify before deleting.",
     args: {
@@ -37723,7 +37756,9 @@ function inspectTools(ctx) {
         return permissionDeniedResponse(scoped.denial);
       const scope = scoped.scope;
       const topK = args.topK === undefined || args.topK === null ? undefined : args.topK;
-      const response = await callBridge(ctx, context, "inspect", { sections, scope, topK });
+      const response = await callBridge(ctx, context, "inspect", { sections, scope, topK }, {
+        keepBridgeOnTimeout: true
+      });
       if (response.success === false) {
         throw new Error(response.message || "inspect failed");
       }
@@ -37800,8 +37835,9 @@ function navigationTools(ctx) {
           file: filePath,
           symbol: args.symbol
         };
-        if (args.depth !== undefined)
-          params.depth = Number(args.depth);
+        const depth = coerceOptionalInt(args.depth, "depth", 1, Number.MAX_SAFE_INTEGER);
+        if (depth !== undefined)
+          params.depth = depth;
         if (!isEmptyParam(args.expression))
           params.expression = args.expression;
         if (!isEmptyParam(args.toSymbol))
@@ -37859,8 +37895,8 @@ function readingTools(ctx) {
         files: z12.boolean().optional().describe("Directory-only mode: when true, target must be a directory or array of directories and the result is a flat file tree with path, language, symbol count, and byte size instead of a symbol outline.")
       },
       execute: async (args, context) => {
-        const target = args.target;
-        const filesMode = args.files === true;
+        const target = coerceTargetParam(args.target);
+        const filesMode = coerceBoolean(args.files);
         const hasUrl = typeof target === "string" && (target.startsWith("http://") || target.startsWith("https://"));
         const isArray = Array.isArray(target) && target.length > 0;
         if (filesMode) {
@@ -37988,7 +38024,8 @@ function readingTools(ctx) {
         const hasUrl = !isEmptyParam(args.url);
         const hasTargets = hasTargetsProvided(args.targets);
         const hasSymbols = !isEmptyParam(args.symbols);
-        const wantCallgraph = args.callgraph === true;
+        const wantCallgraph = coerceBoolean(args.callgraph);
+        const contextLines = coerceOptionalInt(args.contextLines, "contextLines", 1, Number.MAX_SAFE_INTEGER);
         const zoomTitle = buildZoomTitle(args);
         const zoomDisplay = { title: zoomTitle };
         if (hasFilePath)
@@ -38000,8 +38037,8 @@ function readingTools(ctx) {
         }
         if (hasTargets)
           zoomDisplay.targets = JSON.stringify(args.targets);
-        if (args.contextLines !== undefined)
-          zoomDisplay.contextLines = args.contextLines;
+        if (contextLines !== undefined)
+          zoomDisplay.contextLines = contextLines;
         if (wantCallgraph)
           zoomDisplay.callgraph = true;
         const withMeta = (output) => ({
@@ -38034,8 +38071,8 @@ function readingTools(ctx) {
               file: resolvedTargets[index],
               symbol: t.symbol
             };
-            if (args.contextLines !== undefined)
-              params2.context_lines = args.contextLines;
+            if (contextLines !== undefined)
+              params2.context_lines = contextLines;
             if (wantCallgraph)
               params2.callgraph = true;
             return callBridge(ctx, context, "zoom", params2).catch((err) => ({
@@ -38067,8 +38104,8 @@ function readingTools(ctx) {
         if (symbolsArray) {
           const results = await Promise.all(symbolsArray.map((sym) => {
             const params2 = { file: file2, symbol: sym };
-            if (args.contextLines !== undefined)
-              params2.context_lines = args.contextLines;
+            if (contextLines !== undefined)
+              params2.context_lines = contextLines;
             if (wantCallgraph)
               params2.callgraph = true;
             return callBridge(ctx, context, "zoom", params2).catch((err) => ({
@@ -38091,8 +38128,8 @@ function readingTools(ctx) {
           return withMeta(formatZoomBatchResult(targetLabel, symbolsArray, results).text);
         }
         const params = { file: file2 };
-        if (args.contextLines !== undefined)
-          params.context_lines = args.contextLines;
+        if (contextLines !== undefined)
+          params.context_lines = contextLines;
         if (wantCallgraph)
           params.callgraph = true;
         const data = await callBridge(ctx, context, "zoom", params);
@@ -38274,6 +38311,9 @@ function refactoringTools(ctx) {
       },
       execute: async (args, context) => {
         const op = args.op;
+        const startLine = coerceOptionalInt(args.startLine, "startLine", 1, Number.MAX_SAFE_INTEGER);
+        const endLine = coerceOptionalInt(args.endLine, "endLine", 1, Number.MAX_SAFE_INTEGER);
+        const callSiteLine = coerceOptionalInt(args.callSiteLine, "callSiteLine", 1, Number.MAX_SAFE_INTEGER);
         if ((op === "move" || op === "inline") && isEmptyParam(args.symbol)) {
           throw new Error(`'symbol' is required for '${op}' op`);
         }
@@ -38283,12 +38323,12 @@ function refactoringTools(ctx) {
         if (op === "extract") {
           if (isEmptyParam(args.name))
             throw new Error("'name' is required for 'extract' op");
-          if (args.startLine === undefined)
+          if (startLine === undefined)
             throw new Error("'startLine' is required for 'extract' op");
-          if (args.endLine === undefined)
+          if (endLine === undefined)
             throw new Error("'endLine' is required for 'extract' op");
         }
-        if (op === "inline" && args.callSiteLine === undefined) {
+        if (op === "inline" && callSiteLine === undefined) {
           throw new Error("'callSiteLine' is required for 'inline' op");
         }
         const filePath = await resolvePathArg(ctx, context, args.filePath);
@@ -38329,12 +38369,15 @@ function refactoringTools(ctx) {
             break;
           case "extract":
             params.name = args.name;
-            params.start_line = Number(args.startLine);
-            params.end_line = Number(args.endLine) + 1;
+            if (startLine === undefined || endLine === undefined) {
+              throw new Error("'startLine' and 'endLine' are required for 'extract' op");
+            }
+            params.start_line = startLine;
+            params.end_line = endLine + 1;
             break;
           case "inline":
             params.symbol = args.symbol;
-            params.call_site_line = Number(args.callSiteLine);
+            params.call_site_line = callSiteLine;
             break;
         }
         const hints = await queryLspHints(ctx.client, args.symbol ?? args.name, undefined, context.sessionID);
@@ -38497,7 +38540,7 @@ function safetyTools(ctx) {
 }
 
 // src/tools/search.ts
-import * as fs7 from "node:fs";
+import * as fs6 from "node:fs";
 import * as path7 from "node:path";
 function arg2(schema) {
   return schema;
@@ -38533,7 +38576,7 @@ function absoluteSearchPath(projectRoot, target) {
   return resolvePathFromProjectRoot(projectRoot, expandTilde2(target));
 }
 function searchPathExists(projectRoot, target) {
-  return fs7.existsSync(absoluteSearchPath(projectRoot, target));
+  return fs6.existsSync(absoluteSearchPath(projectRoot, target));
 }
 function splitSearchPathArg(projectRoot, raw) {
   if (searchPathExists(projectRoot, raw) || !/\s/.test(raw)) {
@@ -38576,7 +38619,7 @@ ${note}` : note;
 }
 function searchPathKind(projectRoot, target, defaultKind) {
   try {
-    const stat = fs7.lstatSync(absoluteSearchPath(projectRoot, target));
+    const stat = fs6.lstatSync(absoluteSearchPath(projectRoot, target));
     if (defaultKind === "file") {
       return stat.isDirectory() ? "directory" : "file";
     }
@@ -38771,7 +38814,8 @@ function semanticTools(ctx) {
     args: {
       query: arg3(z15.string().describe("Concept, regex, literal text, filename, or capability to find. Examples: 'fuzzy match with whitespace tolerance', '^export', 'Cargo.lock'.")),
       topK: arg3(optionalInt(1, 100).describe("Number of results (default: 10, max: 100)")),
-      hint: arg3(z15.enum(["regex", "literal", "semantic", "auto"]).optional().describe("Optional routing hint. Defaults to 'auto'."))
+      hint: arg3(z15.enum(["regex", "literal", "semantic", "auto"]).optional().describe("Optional routing hint. Defaults to 'auto'.")),
+      includeTests: arg3(z15.boolean().optional().describe("Include test files (*.test.*, *_test.rs, __tests__/, …) plus test-support, fixture, mock, snapshot, and corpus files. Defaults to false."))
     },
     execute: async (args, context) => {
       if (isEmptyParam(args.query) || typeof args.query !== "string" || args.query.trim().length === 0) {
@@ -38786,10 +38830,12 @@ function semanticTools(ctx) {
       }
       const bridgeParams = {
         query,
-        top_k: args.topK ?? 10
+        top_k: coerceOptionalInt(args.topK, "topK", 1, 100) ?? 10
       };
       if (hint)
         bridgeParams.hint = hint;
+      if (typeof args.includeTests === "boolean")
+        bridgeParams.include_tests = args.includeTests;
       const response = await callBridge(ctx, context, "semantic_search", bridgeParams);
       if (response.success === false) {
         const message = typeof response.message === "string" && response.message.length > 0 ? response.message : "semantic_search failed";
@@ -38827,7 +38873,7 @@ function buildWorkflowHints(opts) {
   const hasBgBash = hasBash && opts.bashBackgroundEnabled && !opts.disabledTools.has(bashStatusName);
   if (hasBash && opts.bashCompressionEnabled) {
     sections.push([
-      "**Test/build output**: bash output is auto-compressed — failures and the summary are always kept. DO NOT pipe test/build commands through filters to summarize; that hides failures:",
+      "**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:",
       "- `bun test | grep fail` → run `bun test`",
       "- `cargo test 2>&1 | tail -20` → run `cargo test`",
       "- `npm run build | head -50` → run `npm run build`"
@@ -38866,11 +38912,9 @@ function buildWorkflowHints(opts) {
   }
   if (hasBash && hasBgBash) {
     sections.push([
-      `**Long-running commands** (builds, installs, full test suites): \`${bashName}({ background: true })\` returns a \`taskId\` immediately.`,
-      "1. Nothing else useful to do (a build/test/validation whose result is the next thing you need) → sync `bash_watch` to block until it exits (pass a longer timeoutMs for long commands; the user can interrupt).",
-      "2. Useful parallel work available → end your turn; the completion reminder delivers the result. (Or spawn a subagent for the side work.)",
-      "3. Want to react to a specific early output line → async `bash_watch` (background:true + pattern).",
-      "Never loop `bash_status` to wait — it's a one-shot inspector, not a wait primitive."
+      `**Long-running commands** (builds, installs, full test suites): run them in the FOREGROUND — \`${bashName}({ command })\` waits and returns the result in ONE step, and if it outlives the short wait window it auto-promotes to background and delivers a completion reminder when it finishes. Don't reach for \`background: true\` for the common "I'm waiting on this result" case — that costs an extra turn.`,
+      "- `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(`
 `));
     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: "..." })\`.`);
@@ -38902,11 +38946,20 @@ function buildHintsFromConfig(config2, disabledTools) {
 setActiveLogger(bridgeLogger);
 var STATUS_COMMAND = "aft-status";
 var SENTINEL_PREFIX = "__AFT_STATUS_";
-function isTuiMode2() {
-  return process.env.OPENCODE_CLIENT === "cli";
-}
+var HTTP_SERVER_RESPONSE_TYPE_ID = "~effect/http/HttpServerResponse";
+var HTTP_COOKIES_TYPE_ID = "~effect/http/Cookies";
+var HTTP_BODY_TYPE_ID = "~effect/http/HttpBody";
+var ERROR_REPORTER_IGNORE = "~effect/ErrorReporter/ignore";
 function throwSentinel(command) {
-  throw new Error(`${SENTINEL_PREFIX}${command.toUpperCase().replace(/-/g, "_")}_HANDLED__`);
+  const sentinel = new Error(`${SENTINEL_PREFIX}${command.toUpperCase().replace(/-/g, "_")}_HANDLED__`);
+  sentinel[HTTP_SERVER_RESPONSE_TYPE_ID] = HTTP_SERVER_RESPONSE_TYPE_ID;
+  sentinel[ERROR_REPORTER_IGNORE] = true;
+  sentinel.status = 204;
+  sentinel.statusText = undefined;
+  sentinel.headers = {};
+  sentinel.cookies = { [HTTP_COOKIES_TYPE_ID]: HTTP_COOKIES_TYPE_ID, cookies: {} };
+  sentinel.body = { [HTTP_BODY_TYPE_ID]: HTTP_BODY_TYPE_ID, _tag: "Empty" };
+  throw sentinel;
 }
 var PLUGIN_VERSION = (() => {
   try {
@@ -38916,30 +38969,35 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.39.0";
+var ANNOUNCEMENT_VERSION = "0.40.0";
 var ANNOUNCEMENT_FEATURES = [
-  "Accurate Rust dead code: constructors and associated functions reached through receiver-type inference are no longer mis-reported as dead.",
-  "Code Health scans reparse only the file you changed instead of the whole project on every edit — a single-file edit dropped from ~3s of scan work to ~130ms on this repo, byte-identical results.",
-  "R language support in outline, zoom, and the AST tools.",
-  "Edit approval prompts now show the pending diff instead of 'No diff provided', so you can review a change before approving it."
+  "Groundwork for Subconscious, the CortexKit daemon: configuration now lives in one place under ~/.config/cortexkit/ and <project>/.cortexkit/ (auto-migrated). The daemon integration is dormant — nothing changes in how you run AFT today.",
+  "Bash output never hides a failure: piped commands run exactly as written with their real exit status, cancelled tasks report as failed, and a failing run is never compressed to a clean-looking summary.",
+  "The top aft_search result is now the complete, ready-to-edit symbol (no re-read needed); test files are hidden from results by default.",
+  "format_on_edit is now off by default, and bash commands default to the foreground."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/DSa65w8wuf";
 var plugin = async (input) => initializePluginForDirectory(input);
 async function initializePluginForDirectory(input) {
   const binaryPath = await findBinary(PLUGIN_VERSION);
   await ensureStorageMigrated({ harness: "opencode", binaryPath, logger: bridgeLogger });
+  const deliverConfigMigrationWarnings = (directory, messages) => {
+    for (const message of messages) {
+      sendWarning({ client: input.client, directory }, message).catch((err) => {
+        warn2(`[config] failed to deliver migration warning: ${err}`);
+      });
+    }
+  };
+  deliverConfigMigrationWarnings(input.directory, migrateAftConfigLocations(input.directory, bridgeLogger).flatMap((result) => result.warnings));
   const aftConfig = loadAftConfig(input.directory);
   enqueueConfigParseWarnings(input.directory, getConfigLoadErrors());
   const autoUpdateAbort = new AbortController;
-  const configOverrides = {
-    ...resolveProjectOverridesForConfigure(aftConfig),
-    bash_permissions: true
-  };
-  if (aftConfig.url_fetch_allow_private !== undefined) {
-    configOverrides.url_fetch_allow_private = aftConfig.url_fetch_allow_private;
-  }
+  const storageDir = resolveCortexKitStorageRoot();
+  const configOverrides = buildConfigTierConfigureParams(input.directory, {
+    bash_permissions: true,
+    storage_dir: storageDir
+  });
   const isFastembedSemanticBackend = (aftConfig.semantic?.backend ?? "fastembed") === "fastembed";
-  configOverrides.storage_dir = resolveCortexKitStorageRoot();
   let onnxRuntimePromise = null;
   if (aftConfig.semantic_search && isFastembedSemanticBackend) {
     const storageDir2 = configOverrides.storage_dir;
@@ -39019,11 +39077,10 @@ ${lines}
     minVersion: PLUGIN_VERSION,
     projectConfigLoader: (projectRoot) => {
       try {
-        const projectConfig = loadAftConfig(projectRoot);
-        enqueueConfigParseWarnings(projectRoot, getConfigLoadErrors());
-        return resolveProjectOverridesForConfigure(projectConfig);
+        deliverConfigMigrationWarnings(projectRoot, migrateAftConfigLocations(projectRoot, bridgeLogger).flatMap((result) => result.warnings));
+        return buildConfigTierConfigureParams(projectRoot);
       } catch (err) {
-        warn2(`loadAftConfig(${projectRoot}) failed; falling back to plugin-init config: ${err instanceof Error ? err.message : String(err)}`);
+        warn2(`readConfigTiers(${projectRoot}) failed; falling back to plugin-init config: ${err instanceof Error ? err.message : String(err)}`);
         return {};
       }
     },
@@ -39055,7 +39112,7 @@ ${lines}
       versionUpgradePromises.set(minVersion, upgradePromise);
       return upgradePromise;
     },
-    onConfigureWarnings: ({ projectRoot, sessionId, client, warnings }) => {
+    onConfigureWarnings: ({ projectRoot, sessionId, client, warnings, configDroppedKeys }) => {
       const bridge = pool.getActiveBridgeForRoot(projectRoot);
       if (!bridge)
         return;
@@ -39066,6 +39123,7 @@ ${lines}
         client,
         bridge,
         warnings,
+        configDroppedKeys,
         fallbackClient: input.client,
         storageDir: configOverrides.storage_dir,
         pluginVersion: PLUGIN_VERSION,
@@ -39175,7 +39233,12 @@ ${lines}
     }
     return { ...response, served_directory: servedDirectory };
   });
-  const storageDir = configOverrides.storage_dir;
+  rpcServer.handle("consume-notifications", async (params) => {
+    const rawLastReceivedId = Number(params.lastReceivedId ?? 0);
+    const sessionId = typeof params.sessionId === "string" && params.sessionId.length > 0 ? params.sessionId : undefined;
+    const messages = drainNotifications(Number.isFinite(rawLastReceivedId) ? rawLastReceivedId : 0, sessionId);
+    return { messages };
+  });
   rpcServer.handle("get-announcement", async () => {
     if (!ANNOUNCEMENT_VERSION || ANNOUNCEMENT_FEATURES.length === 0) {
       return { show: false };
@@ -39374,9 +39437,13 @@ Install: ${getManualInstallHint()}`).catch(() => {});
         inspectTier2Idle.clear(toolInput.sessionID);
     },
     "command.execute.before": async (commandInput, _output) => {
-      if (isTuiMode2() || commandInput.command !== STATUS_COMMAND) {
+      if (commandInput.command !== STATUS_COMMAND) {
         return;
       }
+      if (isTuiConnected(commandInput.sessionID)) {
+        pushNotification("action", { action: "show-status-dialog", sessionId: commandInput.sessionID }, commandInput.sessionID);
+        throwSentinel(commandInput.command);
+      }
       const sessionDir = await getSessionDirectory(input.client, commandInput.sessionID, input.directory) ?? input.directory;
       const bridge = ctx.pool.getActiveBridgeForRoot(sessionDir) ?? ctx.pool.getBridge(sessionDir);
       const cached2 = bridge.getCachedStatus();