@cortexkit/aft-opencode 0.27.0 → 0.28.0

package/dist/index.js

@@ -7803,7 +7803,7 @@ var require_src2 = __commonJS((exports, module) => {
 });
 
 // src/index.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync13, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync13, readFileSync as readFileSync13, writeFileSync as writeFileSync12 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { join as join22 } from "path";
 
@@ -8597,13 +8597,14 @@ import { pipeline } from "stream/promises";
 var PLATFORM_ARCH_MAP = {
   darwin: { arm64: "darwin-arm64", x64: "darwin-x64" },
   linux: { arm64: "linux-arm64", x64: "linux-x64" },
-  win32: { arm64: "win32-x64", x64: "win32-x64" }
+  win32: { arm64: "win32-arm64", x64: "win32-x64" }
 };
 var PLATFORM_ASSET_MAP = {
   "darwin-arm64": "aft-darwin-arm64",
   "darwin-x64": "aft-darwin-x64",
   "linux-arm64": "aft-linux-arm64",
   "linux-x64": "aft-linux-x64",
+  "win32-arm64": "aft-win32-arm64.exe",
   "win32-x64": "aft-win32-x64.exe"
 };
 
@@ -9664,6 +9665,7 @@ class BridgePool {
   idleTimeoutMs;
   bridgeOptions;
   configOverrides;
+  projectConfigLoader;
   logger;
   cleanupTimer = null;
   constructor(binaryPath, options = {}, configOverrides = {}) {
@@ -9671,6 +9673,7 @@ class BridgePool {
     this.maxPoolSize = options.maxPoolSize ?? DEFAULT_MAX_POOL_SIZE;
     this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
     this.logger = options.logger;
+    this.projectConfigLoader = options.projectConfigLoader;
     this.bridgeOptions = {
       timeoutMs: options.timeoutMs,
       maxRestarts: options.maxRestarts,
@@ -9706,7 +9709,17 @@ class BridgePool {
     if (this.bridges.size >= this.maxPoolSize) {
       this.evictLRU();
     }
-    const bridge = new BinaryBridge(this.binaryPath, key, this.bridgeOptions, this.configOverrides);
+    let projectOverrides = {};
+    if (this.projectConfigLoader) {
+      try {
+        projectOverrides = this.projectConfigLoader(key) ?? {};
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.error(`projectConfigLoader failed; using global overrides only: ${message}`);
+      }
+    }
+    const mergedOverrides = { ...this.configOverrides, ...projectOverrides };
+    const bridge = new BinaryBridge(this.binaryPath, key, this.bridgeOptions, mergedOverrides);
     this.bridges.set(key, { bridge, lastUsed: Date.now() });
     return bridge;
   }
@@ -10172,6 +10185,9 @@ function formatZoomText(targetLabel, response) {
   return out.join(`
 `);
 }
+// src/bg-notifications.ts
+import { createHash as createHash4, randomUUID } from "crypto";
+
 // src/logger.ts
 import * as fs from "fs";
 import * as os from "os";
@@ -10348,6 +10364,9 @@ async function resolvePromptContext(client, sessionId) {
 }
 
 // src/bg-notifications.ts
+function hashReminder(text) {
+  return createHash4("sha256").update(text).digest("hex").slice(0, 16);
+}
 var sessionBgStates = new Map;
 var SESSION_BG_STATE_IDLE_TTL_MS = 60 * 60 * 1000;
 var DEBOUNCE_STEP_MS = 200;
@@ -10418,6 +10437,13 @@ async function appendInTurnBgCompletions(drainContext, output) {
   const deliveredCompletions = [...state.pendingCompletions];
   const reminder = formatCombinedSystemReminder(state.pendingCompletions, state.pendingLongRunning);
   output.output = appendReminder(output.output ?? "", reminder);
+  sessionLog(drainContext.sessionID, `${LOG_PREFIX} in-turn append`, {
+    event: "bash_completion_in_turn_append",
+    task_ids: deliveredCompletions.map((c) => c.task_id),
+    long_running_task_ids: state.pendingLongRunning.map((r) => r.task_id),
+    reminder_sha256: hashReminder(reminder),
+    reminder_chars: reminder.length
+  });
   state.pendingCompletions = [];
   state.pendingLongRunning = [];
   state.wakeRetryAttempts = 0;
@@ -10461,14 +10487,53 @@ async function triggerWakeIfPending(drainContext, skipDrain) {
     }
     if (promptContext?.variant)
       body.variant = promptContext.variant;
-    await client.session.promptAsync({
-      path: { id: drainContext.sessionID },
-      body
+    const deliveryID = `aftdel_${randomUUID()}`;
+    const taskIDs = deliveredCompletions.map((c) => c.task_id);
+    const wakeMeta = {
+      delivery_id: deliveryID,
+      attempt: state.wakeRetryAttempts + 1,
+      task_ids: taskIDs,
+      directory: drainContext.directory,
+      reminder_sha256: hashReminder(reminder),
+      reminder_chars: reminder.length,
+      prompt_context: promptContext ? {
+        agent: promptContext.agent,
+        model: promptContext.model ? {
+          providerID: promptContext.model.providerID,
+          modelID: promptContext.model.modelID
+        } : null,
+        variant: promptContext.variant ?? null
+      } : null
+    };
+    sessionLog(drainContext.sessionID, `${LOG_PREFIX} wake promptAsync start`, {
+      event: "bash_completion_wake_prompt_async_start",
+      ...wakeMeta
     });
-    await ackCompletions(drainContext, deliveredCompletions);
+    try {
+      await client.session.promptAsync({
+        path: { id: drainContext.sessionID },
+        body
+      });
+    } catch (err) {
+      sessionWarn(drainContext.sessionID, `${LOG_PREFIX} wake promptAsync error`, {
+        event: "bash_completion_wake_prompt_async_error",
+        delivery_id: deliveryID,
+        attempt: state.wakeRetryAttempts + 1,
+        task_ids: taskIDs,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
+    sessionLog(drainContext.sessionID, `${LOG_PREFIX} wake promptAsync ok`, {
+      event: "bash_completion_wake_prompt_async_ok",
+      delivery_id: deliveryID,
+      attempt: state.wakeRetryAttempts + 1,
+      task_ids: taskIDs
+    });
+    await ackCompletions(drainContext, deliveredCompletions, deliveryID);
   }, (err, hardStopped) => {
     sessionWarn(drainContext.sessionID, hardStopped ? `${LOG_PREFIX} wake send failed ${MAX_WAKE_SEND_ATTEMPTS} times; stopping retries: ${err instanceof Error ? err.message : String(err)}` : `${LOG_PREFIX} wake send failed: ${err instanceof Error ? err.message : String(err)}`);
-  });
+  }, drainContext.sessionID);
 }
 function formatSystemReminder(completions) {
   const bullets = completions.map((completion) => formatCompletion(completion)).join(`
@@ -10532,7 +10597,7 @@ async function drainCompletions({ ctx, directory, sessionID }) {
     sessionWarn(sessionID, `${LOG_PREFIX} drain failed: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-async function ackCompletions({ ctx, directory, sessionID }, completions) {
+async function ackCompletions({ ctx, directory, sessionID }, completions, deliveryID) {
   const taskIds = [...new Set(completions.map((completion) => completion.task_id))];
   if (taskIds.length === 0)
     return;
@@ -10544,12 +10609,18 @@ async function ackCompletions({ ctx, directory, sessionID }, completions) {
     });
     if (response.success === false) {
       sessionWarn(sessionID, `${LOG_PREFIX} ack failed: ${String(response.message ?? "unknown error")}`);
+      return;
     }
+    sessionLog(sessionID, `${LOG_PREFIX} ack ok`, {
+      event: "bash_completion_ack_ok",
+      delivery_id: deliveryID ?? null,
+      task_ids: taskIds
+    });
   } catch (err) {
     sessionWarn(sessionID, `${LOG_PREFIX} ack failed: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-function scheduleWake(state, sendWake, onSendFailure) {
+function scheduleWake(state, sendWake, onSendFailure, sessionID) {
   if (state.wakeHardStopped)
     return;
   const now = Date.now();
@@ -10568,6 +10639,13 @@ function scheduleWake(state, sendWake, onSendFailure) {
   if (state.debounceTimer)
     clearTimeout(state.debounceTimer);
   const delay = state.retryDelayMs ?? Math.max(0, (state.scheduledFireAt ?? now) - now);
+  sessionLog(sessionID, `${LOG_PREFIX} wake scheduled`, {
+    event: "bash_completion_wake_scheduled",
+    delay_ms: delay,
+    pending_completions: state.pendingCompletions.length,
+    pending_long_running: state.pendingLongRunning.length,
+    retry_attempt: state.wakeRetryAttempts
+  });
   state.debounceTimer = setTimeout(() => {
     const pending = state.pendingCompletions;
     const pendingLongRunning = state.pendingLongRunning;
@@ -10578,6 +10656,14 @@ function scheduleWake(state, sendWake, onSendFailure) {
     if (pending.length === 0 && pendingLongRunning.length === 0)
       return;
     const reminder = formatCombinedSystemReminder(pending, pendingLongRunning);
+    sessionLog(sessionID, `${LOG_PREFIX} wake fire`, {
+      event: "bash_completion_wake_fire",
+      task_ids: pending.map((c) => c.task_id),
+      long_running_task_ids: pendingLongRunning.map((r) => r.task_id),
+      reminder_sha256: hashReminder(reminder),
+      reminder_chars: reminder.length,
+      retry_attempt: state.wakeRetryAttempts
+    });
     state.pendingCompletions = [];
     state.pendingLongRunning = [];
     sendWake(reminder, pending).then(() => {
@@ -10596,7 +10682,7 @@ function scheduleWake(state, sendWake, onSendFailure) {
       }
       state.retryDelayMs = Math.min((delay || DEBOUNCE_STEP_MS) * 2, DEBOUNCE_CAP_MS);
       onSendFailure(err, false);
-      scheduleWake(state, sendWake, onSendFailure);
+      scheduleWake(state, sendWake, onSendFailure, sessionID);
     });
   }, delay);
   state.debounceTimer.unref?.();
@@ -24334,7 +24420,16 @@ var ExperimentalConfigSchema = exports_external.object({
   }).optional(),
   lsp_ty: exports_external.boolean().optional()
 });
+var BashFeaturesSchema = exports_external.object({
+  rewrite: exports_external.boolean().optional(),
+  compress: exports_external.boolean().optional(),
+  background: exports_external.boolean().optional(),
+  long_running_reminder_enabled: exports_external.boolean().optional(),
+  long_running_reminder_interval_ms: exports_external.number().int().positive().optional()
+});
+var BashConfigSchema = exports_external.union([exports_external.boolean(), BashFeaturesSchema]);
 var AftConfigSchema = exports_external.object({
+  $schema: exports_external.string().optional(),
   format_on_edit: exports_external.boolean().optional(),
   formatter_timeout_secs: exports_external.number().int().min(1).max(600).optional(),
   validate_on_edit: exports_external.enum(["syntax", "full"]).optional(),
@@ -24346,6 +24441,7 @@ var AftConfigSchema = exports_external.object({
   restrict_to_project_root: exports_external.boolean().optional(),
   search_index: exports_external.boolean().optional(),
   semantic_search: exports_external.boolean().optional(),
+  bash: BashConfigSchema.optional(),
   experimental: ExperimentalConfigSchema.optional(),
   lsp: LspConfigSchema.optional(),
   url_fetch_allow_private: exports_external.boolean().optional(),
@@ -24400,22 +24496,93 @@ function resolveLspConfigForConfigure(config2) {
   }
   return overrides;
 }
-function resolveExperimentalConfigForConfigure(config2) {
+function resolveProjectOverridesForConfigure(config2) {
   const overrides = {};
-  if (config2.experimental?.bash?.rewrite !== undefined) {
-    overrides.experimental_bash_rewrite = config2.experimental.bash.rewrite;
-  }
-  if (config2.experimental?.bash?.compress !== undefined) {
-    overrides.experimental_bash_compress = config2.experimental.bash.compress;
+  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;
+  Object.assign(overrides, resolveExperimentalConfigForConfigure(config2));
+  Object.assign(overrides, resolveLspConfigForConfigure(config2));
+  if (config2.semantic !== undefined)
+    overrides.semantic = config2.semantic;
+  if (config2.max_callgraph_files !== undefined)
+    overrides.max_callgraph_files = config2.max_callgraph_files;
+  return overrides;
+}
+function resolveBashConfig(config2) {
+  const top = config2.bash;
+  const legacy = config2.experimental?.bash;
+  const surface = config2.tool_surface ?? "recommended";
+  const surfaceDefaultEnabled = surface !== "minimal";
+  const reminderEnabled = (typeof top === "object" && top !== null ? top.long_running_reminder_enabled : undefined) ?? legacy?.long_running_reminder_enabled;
+  const reminderInterval = (typeof top === "object" && top !== null ? top.long_running_reminder_interval_ms : undefined) ?? legacy?.long_running_reminder_interval_ms;
+  const base = {
+    enabled: false,
+    rewrite: false,
+    compress: false,
+    background: false,
+    long_running_reminder_enabled: reminderEnabled,
+    long_running_reminder_interval_ms: reminderInterval
+  };
+  if (top === false) {
+    return base;
+  }
+  if (top === true) {
+    return { ...base, enabled: true, rewrite: true, compress: true, background: true };
+  }
+  if (typeof top === "object" && top !== null) {
+    return {
+      ...base,
+      enabled: true,
+      rewrite: top.rewrite ?? true,
+      compress: top.compress ?? true,
+      background: top.background ?? true
+    };
   }
-  if (config2.experimental?.bash?.background !== undefined) {
-    overrides.experimental_bash_background = config2.experimental.bash.background;
+  const hasLegacyFeatureFlag = legacy && (legacy.rewrite !== undefined || legacy.compress !== undefined || legacy.background !== undefined);
+  if (hasLegacyFeatureFlag) {
+    const rewrite = legacy.rewrite === true;
+    const compress = legacy.compress === true;
+    const background = legacy.background === true;
+    return {
+      ...base,
+      enabled: rewrite || compress || background,
+      rewrite,
+      compress,
+      background
+    };
   }
-  if (config2.experimental?.bash?.long_running_reminder_enabled !== undefined) {
-    overrides.bash_long_running_reminder_enabled = config2.experimental.bash.long_running_reminder_enabled;
+  return {
+    ...base,
+    enabled: surfaceDefaultEnabled,
+    rewrite: surfaceDefaultEnabled,
+    compress: surfaceDefaultEnabled,
+    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 (config2.experimental?.bash?.long_running_reminder_interval_ms !== undefined) {
-    overrides.bash_long_running_reminder_interval_ms = config2.experimental.bash.long_running_reminder_interval_ms;
+  if (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;
@@ -24486,8 +24653,51 @@ function migrateRawConfig(rawConfig, configPath, logger) {
     delete rawConfig[migration.oldKey];
     oldKeys.push(migration.oldKey);
   }
+  oldKeys.push(...migrateExperimentalBashBlock(rawConfig, configPath, logger));
   return oldKeys;
 }
+function migrateExperimentalBashBlock(rawConfig, configPath, logger) {
+  const experimental = rawConfig.experimental;
+  if (typeof experimental !== "object" || experimental === null || Array.isArray(experimental)) {
+    return [];
+  }
+  const expRecord = experimental;
+  if (!Object.hasOwn(expRecord, "bash"))
+    return [];
+  const legacyBash = expRecord.bash;
+  if (typeof legacyBash !== "object" || legacyBash === null || Array.isArray(legacyBash)) {
+    delete expRecord.bash;
+    if (Object.keys(expRecord).length === 0)
+      delete rawConfig.experimental;
+    return ["experimental.bash"];
+  }
+  const bashRecord = legacyBash;
+  const hasFeatureFlag = "rewrite" in bashRecord || "compress" in bashRecord || "background" in bashRecord;
+  if (!hasFeatureFlag)
+    return [];
+  const movedKeys = Object.keys(bashRecord).map((k) => `experimental.bash.${k}`);
+  if (Object.hasOwn(rawConfig, "bash")) {
+    logger?.warn(`Config migration conflict at ${configPath}: experimental.bash dropped because top-level "bash" is already set`);
+  } else {
+    const migrated = {
+      rewrite: bashRecord.rewrite === true,
+      compress: bashRecord.compress === true,
+      background: bashRecord.background === true
+    };
+    if (bashRecord.long_running_reminder_enabled !== undefined) {
+      migrated.long_running_reminder_enabled = bashRecord.long_running_reminder_enabled;
+    }
+    if (bashRecord.long_running_reminder_interval_ms !== undefined) {
+      migrated.long_running_reminder_interval_ms = bashRecord.long_running_reminder_interval_ms;
+    }
+    rawConfig.bash = migrated;
+  }
+  delete expRecord.bash;
+  if (Object.keys(expRecord).length === 0) {
+    delete rawConfig.experimental;
+  }
+  return movedKeys;
+}
 function migrateAftConfigFile(configPath, logger = { log: log2, warn: warn2 }) {
   if (!existsSync6(configPath)) {
     return { migrated: false, oldKeys: [] };
@@ -24623,6 +24833,22 @@ function mergeLspConfig(baseLsp, overrideLsp) {
   }
   return Object.fromEntries(Object.entries(lsp).filter(([, value]) => value !== undefined));
 }
+function mergeBashConfig(baseBash, overrideBash) {
+  if (baseBash === undefined && overrideBash === undefined)
+    return;
+  if (baseBash === undefined)
+    return overrideBash;
+  if (overrideBash === undefined)
+    return baseBash;
+  const expand = (value) => {
+    if (value === true)
+      return { rewrite: true, compress: true, background: true };
+    if (value === false)
+      return { rewrite: false, compress: false, background: false };
+    return { ...value ?? {} };
+  };
+  return { ...expand(baseBash), ...expand(overrideBash) };
+}
 function mergeExperimentalConfig(baseExperimental, overrideExperimental) {
   const bash = {
     ...baseExperimental?.bash,
@@ -24666,7 +24892,8 @@ var PROJECT_SAFE_TOP_LEVEL_FIELDS = new Set([
   "validate_on_edit",
   "search_index",
   "semantic_search",
-  "experimental"
+  "experimental",
+  "bash"
 ]);
 function pickProjectSafeFields(override) {
   const safe = {};
@@ -24696,13 +24923,16 @@ function mergeConfigs(base, override) {
   const semantic = mergeSemanticConfig(base.semantic, override.semantic);
   const lsp = mergeLspConfig(base.lsp, override.lsp);
   const experimental = mergeExperimentalConfig(base.experimental, override.experimental);
+  const bash = mergeBashConfig(base.bash, override.bash);
   const safeOverride = pickProjectSafeFields(override);
+  delete safeOverride.bash;
   return {
     ...base,
     ...safeOverride,
     ...Object.keys(formatter).length > 0 ? { formatter } : {},
     ...Object.keys(checker).length > 0 ? { checker } : {},
     ...lsp ? { lsp } : {},
+    ...bash !== undefined ? { bash } : {},
     experimental,
     semantic,
     ...disabledTools.length > 0 ? { disabled_tools: [...new Set(disabledTools)] } : {}
@@ -25360,8 +25590,8 @@ function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
 
 // src/lsp-auto-install.ts
 import { spawn as spawn3 } from "child_process";
-import { createHash as createHash4 } from "crypto";
-import { createReadStream, mkdirSync as mkdirSync8, readFileSync as readFileSync8, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync5 } from "fs";
+import { createHash as createHash5 } from "crypto";
+import { createReadStream, mkdirSync as mkdirSync8, readFileSync as readFileSync9, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync5 } from "fs";
 import { join as join15 } from "path";
 
 // src/lsp-cache.ts
@@ -25695,19 +25925,33 @@ var NPM_LSP_TABLE = [
     id: "vue",
     npm: "@vue/language-server",
     binary: "vue-language-server",
-    extensions: ["vue"]
+    extensions: ["vue"],
+    rootMarkers: [
+      "vue.config.js",
+      "vue.config.mjs",
+      "vue.config.ts",
+      "nuxt.config.js",
+      "nuxt.config.mjs",
+      "nuxt.config.ts",
+      "nuxt.config.cjs"
+    ],
+    packageJsonDeps: ["vue", "@vue/runtime-core", "nuxt"]
   },
   {
     id: "astro",
     npm: "@astrojs/language-server",
     binary: "astro-ls",
-    extensions: ["astro"]
+    extensions: ["astro"],
+    rootMarkers: ["astro.config.js", "astro.config.mjs", "astro.config.ts", "astro.config.cjs"],
+    packageJsonDeps: ["astro"]
   },
   {
     id: "svelte",
     npm: "svelte-language-server",
     binary: "svelteserver",
-    extensions: ["svelte"]
+    extensions: ["svelte"],
+    rootMarkers: ["svelte.config.js", "svelte.config.mjs", "svelte.config.ts", "svelte.config.cjs"],
+    packageJsonDeps: ["svelte", "@sveltejs/kit"]
   },
   {
     id: "php-intelephense",
@@ -25725,7 +25969,7 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync10, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync3, readFileSync as readFileSync8 } from "fs";
 import { join as join14 } from "path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
@@ -25748,6 +25992,34 @@ function hasRootMarker(projectRoot, rootMarkers) {
   }
   return false;
 }
+function hasPackageJsonDep(projectRoot, depNames) {
+  if (!depNames || depNames.length === 0)
+    return false;
+  const pkg = readPackageJson(projectRoot);
+  if (!pkg)
+    return false;
+  const merged = {
+    ...typeof pkg.dependencies === "object" && pkg.dependencies ? pkg.dependencies : {},
+    ...typeof pkg.devDependencies === "object" && pkg.devDependencies ? pkg.devDependencies : {},
+    ...typeof pkg.peerDependencies === "object" && pkg.peerDependencies ? pkg.peerDependencies : {}
+  };
+  for (const name of depNames) {
+    if (Object.hasOwn(merged, name))
+      return true;
+  }
+  return false;
+}
+function readPackageJson(projectRoot) {
+  try {
+    const raw = readFileSync8(join14(projectRoot, "package.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null)
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
 function relevantExtensionsInProject(projectRoot, extToServer) {
   const wanted = new Set(Object.keys(extToServer).map((ext) => ext.toLowerCase()));
   const found = new Set;
@@ -25840,6 +26112,8 @@ async function probeRegistry(npmPackage, graceDays, fetchImpl = fetch) {
 function isProjectRelevant(spec, projectRoot, projectExtensions) {
   if (hasRootMarker(projectRoot, spec.rootMarkers))
     return true;
+  if (hasPackageJsonDep(projectRoot, spec.packageJsonDeps))
+    return true;
   const extensions = projectExtensions();
   return spec.extensions.some((ext) => extensions.has(ext.toLowerCase()));
 }
@@ -25901,8 +26175,9 @@ function runInstall(spec, version2, cwd, signal) {
       resolve3(false);
       return;
     }
-    const child = spawn3("bun", ["add", target, "--cwd", cwd, "--ignore-scripts", "--silent"], {
-      stdio: ["ignore", "pipe", "pipe"]
+    const child = spawn3("npm", ["install", "--no-save", "--ignore-scripts", "--silent", target], {
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd
     });
     child.unref();
     let stderrBuf = "";
@@ -26039,7 +26314,7 @@ 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));
@@ -26062,7 +26337,7 @@ function installedBinaryPath(spec) {
   return null;
 }
 function sha256OfFileSync(path2) {
-  return createHash4("sha256").update(readFileSync8(path2)).digest("hex");
+  return createHash5("sha256").update(readFileSync9(path2)).digest("hex");
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
@@ -26147,7 +26422,7 @@ function runAutoInstall(projectRoot, config2, fetchImpl = fetch) {
 
 // src/lsp-github-install.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { createHash as createHash5, randomBytes } from "crypto";
+import { createHash as createHash6, randomBytes } from "crypto";
 import {
   copyFileSync as copyFileSync3,
   createReadStream as createReadStream2,
@@ -26156,7 +26431,7 @@ import {
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync9,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync3,
   renameSync as renameSync6,
@@ -26290,7 +26565,7 @@ function readGithubInstalledMetaIn(installDir) {
     const path2 = join16(installDir, INSTALLED_META_FILE2);
     if (!statSync6(path2).isFile())
       return null;
-    const parsed = JSON.parse(readFileSync9(path2, "utf8"));
+    const parsed = JSON.parse(readFileSync10(path2, "utf8"));
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
     return {
@@ -26323,7 +26598,7 @@ var MAX_DOWNLOAD_BYTES3 = 256 * 1024 * 1024;
 var MAX_EXTRACT_BYTES2 = 1024 * 1024 * 1024;
 function sha256OfFile(path2) {
   return new Promise((resolve4, reject) => {
-    const hash2 = createHash5("sha256");
+    const hash2 = createHash6("sha256");
     const stream = createReadStream2(path2);
     stream.on("error", reject);
     stream.on("data", (chunk) => hash2.update(chunk));
@@ -26331,7 +26606,7 @@ function sha256OfFile(path2) {
   });
 }
 function sha256OfFileSync2(path2) {
-  return createHash5("sha256").update(readFileSync9(path2)).digest("hex");
+  return createHash6("sha256").update(readFileSync10(path2)).digest("hex");
 }
 async function fetchReleaseByTag(githubRepo, tag, fetchImpl, signal) {
   const candidates = [];
@@ -27030,7 +27305,7 @@ function normalizeToolMap(tools) {
 }
 
 // src/notifications.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync10, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
 import { homedir as homedir9, platform as platform2 } from "os";
 import { join as join17 } from "path";
 function isTuiMode() {
@@ -27073,7 +27348,7 @@ function readDesktopState(directory) {
     return { sessionId: null, serverUrl: null };
   }
   try {
-    const raw = readFileSync10(statePath, "utf-8");
+    const raw = readFileSync11(statePath, "utf-8");
     const state = JSON.parse(raw);
     let serverUrl = null;
     const serverStr = state.server;
@@ -27169,25 +27444,34 @@ async function sendWarning(opts, message) {
   sessionLog(sessionId, `[aft-plugin] sending warning to session ${sessionId}`);
   await sendIgnoredMessage(opts.client, sessionId, text);
 }
-async function sendFeatureAnnouncement(opts, version2, features, storageDir) {
+async function sendFeatureAnnouncement(opts, version2, features, footer, storageDir) {
   if (storageDir) {
     const versionFile = join17(storageDir, "last_announced_version");
     try {
       if (existsSync12(versionFile)) {
-        const lastVersion = readFileSync10(versionFile, "utf-8").trim();
+        const lastVersion = readFileSync11(versionFile, "utf-8").trim();
         if (lastVersion === version2)
           return;
       }
     } catch {}
   }
-  const featureText = features.map((f) => `\u2022 ${f}`).join(`
+  const hasFooter = typeof footer === "string" && footer.trim().length > 0;
+  const featureText = hasFooter ? [features.map((f) => `\u2022 ${f}`).join(`
+`), "", footer].join(`
+`) : features.map((f) => `\u2022 ${f}`).join(`
 `);
   const toastSent = await showTuiToast(opts.client, `AFT v${version2}`, featureText, "info", 12000);
   if (!toastSent) {
     const { sessionId } = readDesktopState(opts.directory);
     if (!sessionId)
       return;
-    const text = [`${FEATURE_MARKER} v${version2}:`, ...features.map((f) => `  \u2022 ${f}`)].join(`
+    const sections = [
+      `${FEATURE_MARKER} v${version2}:`,
+      ...features.map((f) => `  \u2022 ${f}`)
+    ];
+    if (hasFooter)
+      sections.push("", footer);
+    const text = sections.join(`
 `);
     sessionLog(sessionId, `[aft-plugin] sending feature announcement for v${version2}`);
     await sendIgnoredMessage(opts.client, sessionId, text);
@@ -27317,11 +27601,11 @@ import { createServer } from "http";
 import { dirname as dirname7 } from "path";
 
 // src/shared/rpc-utils.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import { join as join18 } from "path";
 function projectHash(directory) {
   const normalized = directory.replace(/\/+$/, "");
-  return createHash6("sha256").update(normalized).digest("hex").slice(0, 16);
+  return createHash7("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function rpcPortFilePath(storageDir, directory) {
   const hash2 = projectHash(directory);
@@ -27674,7 +27958,7 @@ function formatStatusMarkdown(status) {
 
 // src/shared/tui-config.ts
 var import_comment_json4 = __toESM(require_src2(), 1);
-import { existsSync as existsSync13, mkdirSync as mkdirSync12, readFileSync as readFileSync11, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync12, readFileSync as readFileSync12, writeFileSync as writeFileSync11 } from "fs";
 import { dirname as dirname8, join as join20 } from "path";
 
 // src/shared/opencode-config-dir.ts
@@ -27722,7 +28006,7 @@ function ensureTuiPluginEntry() {
     const configPath = resolveTuiConfigPath();
     let config2 = {};
     if (existsSync13(configPath)) {
-      config2 = import_comment_json4.parse(readFileSync11(configPath, "utf-8")) ?? {};
+      config2 = import_comment_json4.parse(readFileSync12(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"))) {
@@ -29327,6 +29611,9 @@ function createWriteTool(ctx, editToolName = "edit") {
       let output = data.created ? "Created new file." : "File updated.";
       if (data.formatted)
         output += " Auto-formatted.";
+      if (data.no_op === true) {
+        output += " No net change \u2014 the written content is byte-identical to what was already on disk.";
+      }
       const diags = data.lsp_diagnostics;
       if (diags && diags.length > 0) {
         const errors3 = diags.filter((d) => d.severity === "error");
@@ -29575,6 +29862,11 @@ function createEditTool(ctx, writeToolName = "write") {
         result += `
 
 ${globSkipNote}`;
+      if (data.no_op === true) {
+        result += `
+
+Note: no net file change \u2014 the match was found and applied, but the file content is byte-identical to before. Likely causes: oldString and newString are identical, or a formatter normalized the change away.`;
+      }
       const diags = data.lsp_diagnostics;
       if (diags && diags.length > 0) {
         const errors3 = diags.filter((d) => d.severity === "error");
@@ -30032,11 +30324,7 @@ function hoistedTools(ctx) {
     aft_delete: createDeleteTool(ctx),
     aft_move: createMoveTool(ctx)
   };
-  const bashRewrite = ctx.config.experimental?.bash?.rewrite === true;
-  const bashCompress = ctx.config.experimental?.bash?.compress === true;
-  const bashBackground = ctx.config.experimental?.bash?.background === true;
-  const anyBashExperimental = bashRewrite || bashCompress || bashBackground;
-  if (anyBashExperimental) {
+  if (resolveBashConfig(ctx.config).enabled) {
     tools.bash = createBashTool(ctx);
     tools.bash_status = createBashStatusTool(ctx);
     tools.bash_kill = createBashKillTool(ctx);
@@ -30090,11 +30378,7 @@ function aftPrefixedTools(ctx) {
     aft_delete: createDeleteTool(ctx),
     aft_move: createMoveTool(ctx)
   };
-  const bashRewrite = ctx.config.experimental?.bash?.rewrite === true;
-  const bashCompress = ctx.config.experimental?.bash?.compress === true;
-  const bashBackground = ctx.config.experimental?.bash?.background === true;
-  const anyBashExperimental = bashRewrite || bashCompress || bashBackground;
-  if (anyBashExperimental) {
+  if (resolveBashConfig(ctx.config).enabled) {
     tools.aft_bash = createBashTool(ctx);
     tools.bash_status = createBashStatusTool(ctx);
     tools.bash_kill = createBashKillTool(ctx);
@@ -31077,7 +31361,7 @@ function buildHintsFromConfig(config2, disabledTools) {
     toolSurface: config2.tool_surface ?? "recommended",
     hoistBuiltins: config2.hoist_builtin_tools !== false,
     semanticEnabled: config2.semantic_search === true,
-    bashBackgroundEnabled: config2.experimental?.bash?.background === true,
+    bashBackgroundEnabled: resolveBashConfig(config2).background,
     disabledTools
   });
 }
@@ -31158,45 +31442,23 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.18.0";
+var ANNOUNCEMENT_VERSION = "0.28.0";
 var ANNOUNCEMENT_FEATURES = [
-  `New experimental features \u2014 AFT now optionally hoists bash:
-    - Run bash scripts in the background.
-    - Initial output compression for git, cargo, npm, bun, pnpm, pytest, tsc (more in 0.19).
-    - Rewrite cat/grep/find/sed/ls into AFT counterparts for faster, formatted output.
-  Check GitHub for how to enable.`,
-  "Trigram grep/glob and semantic search (aft_search) graduated out of experimental.",
-  "Lots of bugfixes and new end-to-end test coverage."
+  "Bash hoisting is now default-on. Configure with top-level `bash: { rewrite, compress, background }` instead of `experimental.bash.*` \u2014 old config migrates automatically on first launch.",
+  "Vue, Astro, and Svelte language servers now auto-install when the framework appears in your package.json (fixes #48).",
+  "Native Windows ARM64 binary \u2014 ARM64 hosts no longer fall back to x64 under emulation."
 ];
+var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU";
 var plugin = async (input) => initializePluginForDirectory(input);
 async function initializePluginForDirectory(input) {
   const binaryPath = await findBinary(PLUGIN_VERSION);
   await ensureStorageMigrated({ harness: "opencode", binaryPath, logger: bridgeLogger });
   const aftConfig = loadAftConfig(input.directory);
   const autoUpdateAbort = new AbortController;
-  const configOverrides = {};
-  if (aftConfig.format_on_edit !== undefined)
-    configOverrides.format_on_edit = aftConfig.format_on_edit;
-  if (aftConfig.formatter_timeout_secs !== undefined)
-    configOverrides.formatter_timeout_secs = aftConfig.formatter_timeout_secs;
-  if (aftConfig.validate_on_edit !== undefined)
-    configOverrides.validate_on_edit = aftConfig.validate_on_edit;
-  if (aftConfig.formatter !== undefined)
-    configOverrides.formatter = aftConfig.formatter;
-  if (aftConfig.checker !== undefined)
-    configOverrides.checker = aftConfig.checker;
-  configOverrides.restrict_to_project_root = aftConfig.restrict_to_project_root ?? false;
-  configOverrides.bash_permissions = true;
-  if (aftConfig.search_index !== undefined)
-    configOverrides.search_index = aftConfig.search_index;
-  if (aftConfig.semantic_search !== undefined)
-    configOverrides.semantic_search = aftConfig.semantic_search;
-  Object.assign(configOverrides, resolveExperimentalConfigForConfigure(aftConfig));
-  Object.assign(configOverrides, resolveLspConfigForConfigure(aftConfig));
-  if (aftConfig.semantic !== undefined)
-    configOverrides.semantic = aftConfig.semantic;
-  if (aftConfig.max_callgraph_files !== undefined)
-    configOverrides.max_callgraph_files = aftConfig.max_callgraph_files;
+  const configOverrides = {
+    ...resolveProjectOverridesForConfigure(aftConfig),
+    bash_permissions: true
+  };
   const isFastembedSemanticBackend = (aftConfig.semantic?.backend ?? "fastembed") === "fastembed";
   configOverrides.storage_dir = resolveCortexKitStorageRoot();
   let onnxRuntimePromise = null;
@@ -31277,6 +31539,15 @@ ${lines}
   const poolOptions = {
     errorPrefix: "[aft-plugin]",
     minVersion: PLUGIN_VERSION,
+    projectConfigLoader: (projectRoot) => {
+      try {
+        const projectConfig = loadAftConfig(projectRoot);
+        return resolveProjectOverridesForConfigure(projectConfig);
+      } catch (err) {
+        warn2(`loadAftConfig(${projectRoot}) failed; falling back to plugin-init config: ${err instanceof Error ? err.message : String(err)}`);
+        return {};
+      }
+    },
     onVersionMismatch: async (binaryVersion, minVersion) => {
       const existing = versionUpgradePromises.get(minVersion);
       if (existing) {
@@ -31389,7 +31660,7 @@ ${lines}
       return {
         success: true,
         status: "not_initialized",
-        message: "Waiting for first tool call to populate"
+        message: "AFT bridge is now spawned lazily, information here will be populated after first tool call."
       };
     }
     const cached2 = bridge.getCachedStatus();
@@ -31413,13 +31684,18 @@ ${lines}
       const versionFile = join22(storageDir, "last_announced_version");
       try {
         if (existsSync15(versionFile)) {
-          const lastVersion = readFileSync12(versionFile, "utf-8").trim();
+          const lastVersion = readFileSync13(versionFile, "utf-8").trim();
           if (lastVersion === ANNOUNCEMENT_VERSION)
             return { show: false };
         }
       } catch {}
     }
-    return { show: true, version: ANNOUNCEMENT_VERSION, features: ANNOUNCEMENT_FEATURES };
+    return {
+      show: true,
+      version: ANNOUNCEMENT_VERSION,
+      features: ANNOUNCEMENT_FEATURES,
+      footer: ANNOUNCEMENT_FOOTER
+    };
   });
   rpcServer.handle("mark-announced", async () => {
     if (storageDir && ANNOUNCEMENT_VERSION) {
@@ -31453,7 +31729,7 @@ Install: ${getManualInstallHint()}`);
   };
   if (ANNOUNCEMENT_VERSION && ANNOUNCEMENT_FEATURES.length > 0) {
     setTimeout(() => {
-      sendFeatureAnnouncement(notifyOpts, ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, storageDir).catch(() => {});
+      sendFeatureAnnouncement(notifyOpts, ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER, storageDir).catch(() => {});
     }, 8000);
   }
   if (onnxRuntimePromise) {