@cortexkit/aft-opencode 0.18.2 → 0.18.4

package/dist/index.js

@@ -7813,7 +7813,8 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 var TAG = "[aft-plugin]";
-var logFile = path.join(os.tmpdir(), "aft-plugin.log");
+var isTestEnv = process.env.BUN_TEST === "1" || false;
+var logFile = path.join(os.tmpdir(), isTestEnv ? "aft-plugin-test.log" : "aft-plugin.log");
 var useStderr = process.env.AFT_LOG_STDERR === "1";
 var buffer = [];
 var flushTimer = null;
@@ -7871,6 +7872,9 @@ function warn(message, data) {
 function error(message, data) {
   write("ERROR", message, data);
 }
+function sessionLog(sessionId, message, data) {
+  write("INFO", message, data, sessionId);
+}
 function sessionWarn(sessionId, message, data) {
   write("WARN", message, data, sessionId);
 }
@@ -7878,15 +7882,90 @@ function getLogFilePath() {
   return logFile;
 }
 
+// src/shared/last-user-model.ts
+var CACHE_TTL_MS = 5000;
+var CACHE_MAX_ENTRIES = 100;
+var cache = new Map;
+async function getLastUserModel(client, sessionId) {
+  const now = Date.now();
+  const cached = cache.get(sessionId);
+  if (cached && cached.expiresAt > now) {
+    cache.delete(sessionId);
+    cache.set(sessionId, cached);
+    return cached.model;
+  }
+  if (cached)
+    cache.delete(sessionId);
+  const c = client;
+  const fetcher = c?.session?.messages;
+  if (typeof fetcher !== "function") {
+    return null;
+  }
+  let messages;
+  try {
+    const result = await fetcher({ path: { id: sessionId } });
+    messages = result?.data ?? [];
+  } catch {
+    return null;
+  }
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const info = messages[i]?.info;
+    if (info?.role !== "user")
+      continue;
+    if (isSyntheticIgnoredMessage(messages[i]))
+      continue;
+    const model = info.model;
+    if (!model?.providerID || !model?.modelID)
+      continue;
+    const resolved = {
+      providerID: model.providerID,
+      modelID: model.modelID,
+      ...model.variant ? { variant: model.variant } : {}
+    };
+    setCache(sessionId, resolved);
+    return resolved;
+  }
+  return null;
+}
+function setCache(sessionId, model) {
+  if (cache.has(sessionId))
+    cache.delete(sessionId);
+  cache.set(sessionId, { expiresAt: Date.now() + CACHE_TTL_MS, model });
+  while (cache.size > CACHE_MAX_ENTRIES) {
+    const oldest = cache.keys().next().value;
+    if (typeof oldest !== "string")
+      break;
+    cache.delete(oldest);
+  }
+}
+function isSyntheticIgnoredMessage(message) {
+  const parts = message?.info?.parts ?? message?.parts;
+  return Array.isArray(parts) && parts.length > 0 && parts.every((part) => part?.ignored === true);
+}
+
 // src/bg-notifications.ts
 var sessionBgStates = new Map;
 var SESSION_BG_STATE_IDLE_TTL_MS = 60 * 60 * 1000;
 var DEBOUNCE_STEP_MS = 200;
 var DEBOUNCE_CAP_MS = 1000;
+var UNKNOWN_COMPLETION_TTL_MS = 5000;
+var UNKNOWN_COMPLETION_CAP = 32;
 var DEFAULT_SESSION_ID = "__default__";
 var LOG_PREFIX = "[aft-plugin] bg-notifications:";
 function trackBgTask(sessionID, taskId) {
-  stateFor(sessionID).outstandingTaskIds.add(taskId);
+  const state = stateFor(sessionID);
+  pruneUnknownCompletions(state, Date.now());
+  const buffered = state.unknownCompletions.filter((entry) => entry.completion.task_id === taskId);
+  state.unknownCompletions = state.unknownCompletions.filter((entry) => entry.completion.task_id !== taskId);
+  if (buffered.length > 0) {
+    for (const entry of buffered) {
+      if (!state.pendingCompletions.some((pending) => pending.task_id === taskId)) {
+        state.pendingCompletions.push(entry.completion);
+      }
+    }
+    return;
+  }
+  state.outstandingTaskIds.add(taskId);
 }
 function ingestBgCompletions(sessionID, completions) {
   if (!Array.isArray(completions) || completions.length === 0)
@@ -7896,8 +7975,10 @@ function ingestBgCompletions(sessionID, completions) {
   for (const completion of completions) {
     if (!isBgCompletion(completion))
       continue;
-    if (!state.outstandingTaskIds.has(completion.task_id))
+    if (!state.outstandingTaskIds.has(completion.task_id)) {
+      bufferUnknownCompletion(state, completion);
       continue;
+    }
     state.outstandingTaskIds.delete(completion.task_id);
     if (!state.pendingCompletions.some((pending) => pending.task_id === completion.task_id) && !accepted.some((pending) => pending.task_id === completion.task_id)) {
       accepted.push(completion);
@@ -7906,6 +7987,10 @@ function ingestBgCompletions(sessionID, completions) {
   state.pendingCompletions.push(...accepted);
   return accepted;
 }
+async function handlePushedBgCompletion(drainContext, completion) {
+  ingestBgCompletions(drainContext.sessionID, [completion]);
+  await triggerWakeIfPending(drainContext, true);
+}
 async function appendInTurnBgCompletions(drainContext, output) {
   if (!output)
     return;
@@ -7922,43 +8007,55 @@ async function appendInTurnBgCompletions(drainContext, output) {
   state.pendingCompletions = [];
 }
 async function handleIdleBgCompletions(drainContext) {
+  await triggerWakeIfPending(drainContext, false);
+}
+async function triggerWakeIfPending(drainContext, skipDrain) {
   const state = stateFor(drainContext.sessionID);
   if (state.wakeFiredThisIdle)
     return;
-  if (state.outstandingTaskIds.size > 0) {
+  if (drainContext.isActive?.())
+    return;
+  if (!skipDrain && state.outstandingTaskIds.size > 0) {
     await drainCompletions(drainContext);
   }
   if (state.pendingCompletions.length === 0)
     return;
   scheduleWake(state, async (reminder) => {
-    try {
-      const client = drainContext.client;
-      if (typeof client.session?.promptAsync !== "function") {
-        throw new Error("client.session.promptAsync is unavailable");
-      }
-      await client.session.promptAsync({
-        path: { id: drainContext.sessionID },
-        body: {
-          noReply: false,
-          parts: [{ type: "text", text: reminder }]
-        }
-      });
-    } catch (err) {
-      warn(`${LOG_PREFIX} wake send failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
+    const client = drainContext.client;
+    if (typeof client.session?.promptAsync !== "function") {
+      throw new Error("client.session.promptAsync is unavailable");
+    }
+    const lastModel = await getLastUserModel(client, drainContext.sessionID);
+    const body = {
+      noReply: false,
+      parts: [{ type: "text", text: reminder }]
+    };
+    if (lastModel) {
+      body.model = { providerID: lastModel.providerID, modelID: lastModel.modelID };
+      if (lastModel.variant)
+        body.variant = lastModel.variant;
+    }
+    await client.session.promptAsync({
+      path: { id: drainContext.sessionID },
+      body
+    });
+  }, (err) => {
+    sessionWarn(drainContext.sessionID, `${LOG_PREFIX} wake send failed: ${err instanceof Error ? err.message : String(err)}`);
   });
 }
 function resetBgWake(sessionID) {
   stateFor(sessionID).wakeFiredThisIdle = false;
 }
 function formatSystemReminder(completions) {
-  const bullets = completions.map((completion) => `- ${formatCompletion(completion)}`).join(`
+  const bullets = completions.map((completion) => formatCompletion(completion)).join(`
 `);
+  const anyTruncated = completions.some((c) => c.output_truncated === true);
+  const tail = anyTruncated ? `
+
+For truncated tasks, use bash_status({ taskId: "..." }) to retrieve full output.` : "";
   return `<system-reminder>
 [BACKGROUND BASH COMPLETED]
-${bullets}
-
-Use bash_status({ task_id: "..." }) to retrieve full output.
+${bullets}${tail}
 </system-reminder>`;
 }
 function extractSessionID(value) {
@@ -7984,15 +8081,15 @@ async function drainCompletions({ ctx, directory, sessionID }) {
     const bridge = ctx.pool.getAnyActiveBridge(directory) ?? ctx.pool.getBridge(directory);
     const response = await bridge.send("bash_drain_completions", { session_id: sessionID });
     if (response.success === false) {
-      warn(`${LOG_PREFIX} drain failed: ${String(response.message ?? "unknown error")}`);
+      sessionWarn(sessionID, `${LOG_PREFIX} drain failed: ${String(response.message ?? "unknown error")}`);
       return;
     }
     ingestBgCompletions(sessionID, response.bg_completions);
   } catch (err) {
-    warn(`${LOG_PREFIX} drain failed: ${err instanceof Error ? err.message : String(err)}`);
+    sessionWarn(sessionID, `${LOG_PREFIX} drain failed: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-function scheduleWake(state, sendWake) {
+function scheduleWake(state, sendWake, onSendFailure) {
   const now = Date.now();
   if (state.debounceTimer && state.pendingCompletions.length <= state.scheduledCompletionCount) {
     return;
@@ -8007,16 +8104,24 @@ function scheduleWake(state, sendWake) {
   state.scheduledCompletionCount = state.pendingCompletions.length;
   if (state.debounceTimer)
     clearTimeout(state.debounceTimer);
-  const delay = Math.max(0, (state.scheduledFireAt ?? now) - now);
+  const delay = state.retryDelayMs ?? Math.max(0, (state.scheduledFireAt ?? now) - now);
   state.debounceTimer = setTimeout(() => {
-    const reminder = formatSystemReminder(state.pendingCompletions);
+    const pending = state.pendingCompletions;
+    const reminder = formatSystemReminder(pending);
     state.pendingCompletions = [];
     state.debounceTimer = null;
-    state.wakeFiredThisIdle = true;
     state.firstCompletionAt = null;
     state.scheduledFireAt = null;
     state.scheduledCompletionCount = 0;
-    sendWake(reminder);
+    sendWake(reminder).then(() => {
+      state.retryDelayMs = null;
+      state.wakeFiredThisIdle = true;
+    }).catch((err) => {
+      state.pendingCompletions = [...pending, ...state.pendingCompletions];
+      state.retryDelayMs = Math.min((delay || DEBOUNCE_STEP_MS) * 2, DEBOUNCE_CAP_MS);
+      onSendFailure(err);
+      scheduleWake(state, sendWake, onSendFailure);
+    });
   }, delay);
   state.debounceTimer.unref?.();
 }
@@ -8034,6 +8139,8 @@ function stateFor(sessionID) {
       firstCompletionAt: null,
       scheduledFireAt: null,
       scheduledCompletionCount: 0,
+      retryDelayMs: null,
+      unknownCompletions: [],
       lastSeenAt: now
     };
     sessionBgStates.set(key, state);
@@ -8054,6 +8161,18 @@ function cleanupIdleSessionStates(now) {
     sessionBgStates.delete(sessionID);
   }
 }
+function bufferUnknownCompletion(state, completion) {
+  const now = Date.now();
+  pruneUnknownCompletions(state, now);
+  state.unknownCompletions = state.unknownCompletions.filter((entry) => entry.completion.task_id !== completion.task_id);
+  state.unknownCompletions.push({ completion, receivedAt: now });
+  if (state.unknownCompletions.length > UNKNOWN_COMPLETION_CAP) {
+    state.unknownCompletions.splice(0, state.unknownCompletions.length - UNKNOWN_COMPLETION_CAP);
+  }
+}
+function pruneUnknownCompletions(state, now) {
+  state.unknownCompletions = state.unknownCompletions.filter((entry) => now - entry.receivedAt <= UNKNOWN_COMPLETION_TTL_MS);
+}
 function isBgCompletion(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return false;
@@ -8068,10 +8187,26 @@ ${reminder}` : reminder;
 function formatCompletion(completion) {
   const status = formatStatus(completion);
   const duration = formatDuration(completion);
-  return `task ${completion.task_id} (${status}${duration ? `, ${duration}` : ""}): ${completion.command}`;
+  const header = `- task ${completion.task_id} (${status}${duration ? `, ${duration}` : ""})`;
+  const previewBlock = formatOutputPreview(completion);
+  return previewBlock ? `${header}
+${previewBlock}` : header;
+}
+function formatOutputPreview(completion) {
+  const ansiRegex = /\x1b\[[0-9;]*[a-zA-Z]/g;
+  const raw = (completion.output_preview ?? "").replace(ansiRegex, "");
+  if (!raw.trim())
+    return "";
+  const trimmed = raw.replace(/\n+$/, "");
+  const ellipsis = completion.output_truncated ? "\u2026" : "";
+  const indented = trimmed.split(`
+`).map((line) => `    ${line}`).join(`
+`);
+  return ellipsis ? `    ${ellipsis}
+${indented}` : indented;
 }
 function formatStatus(completion) {
-  if (completion.status === "timeout")
+  if (completion.status === "timed_out" || completion.status === "timeout")
     return "timed out";
   if (completion.status === "killed")
     return "killed";
@@ -21693,6 +21828,7 @@ var ExperimentalConfigSchema = exports_external.object({
 });
 var AftConfigSchema = exports_external.object({
   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(),
   formatter: exports_external.record(exports_external.string(), FormatterEnum).optional(),
   checker: exports_external.record(exports_external.string(), CheckerEnum).optional(),
@@ -24332,13 +24468,17 @@ async function getSessionMessages(client, sessionId) {
 async function sendIgnoredMessage(client, sessionId, text) {
   try {
     const c = client;
-    const promptInput = {
-      path: { id: sessionId },
-      body: {
-        noReply: true,
-        parts: [{ type: "text", text, ignored: true }]
-      }
+    const lastModel = await getLastUserModel(client, sessionId);
+    const body = {
+      noReply: true,
+      parts: [{ type: "text", text, ignored: true }]
     };
+    if (lastModel) {
+      body.model = { providerID: lastModel.providerID, modelID: lastModel.modelID };
+      if (lastModel.variant)
+        body.variant = lastModel.variant;
+    }
+    const promptInput = { path: { id: sessionId }, body };
     if (typeof c.session?.prompt === "function") {
       await Promise.resolve(c.session.prompt(promptInput));
       return true;
@@ -24348,7 +24488,7 @@ async function sendIgnoredMessage(client, sessionId, text) {
       return true;
     }
   } catch (err) {
-    log(`[aft-plugin] notification send failed: ${err instanceof Error ? err.message : String(err)}`);
+    sessionLog(sessionId, `[aft-plugin] notification send failed: ${err instanceof Error ? err.message : String(err)}`);
   }
   return false;
 }
@@ -24374,7 +24514,7 @@ async function sendWarning(opts, message) {
   if (!sessionId)
     return;
   const text = `${WARNING_MARKER} ${message}`;
-  log(`[aft-plugin] sending warning to session ${sessionId}`);
+  sessionLog(sessionId, `[aft-plugin] sending warning to session ${sessionId}`);
   await sendIgnoredMessage(opts.client, sessionId, text);
 }
 async function sendFeatureAnnouncement(opts, version2, features, storageDir) {
@@ -24397,7 +24537,7 @@ async function sendFeatureAnnouncement(opts, version2, features, storageDir) {
       return;
     const text = [`${FEATURE_MARKER} v${version2}:`, ...features.map((f) => `  \u2022 ${f}`)].join(`
 `);
-    log(`[aft-plugin] sending feature announcement for v${version2}`);
+    sessionLog(sessionId, `[aft-plugin] sending feature announcement for v${version2}`);
     await sendIgnoredMessage(opts.client, sessionId, text);
   }
   if (storageDir) {
@@ -24515,7 +24655,7 @@ async function cleanupWarnings(opts) {
   }
   if (warningIds.length === 0)
     return;
-  log(`[aft-plugin] cleaning up ${warningIds.length} stale warning(s)`);
+  sessionLog(sessionId, `[aft-plugin] cleaning up ${warningIds.length} stale warning(s)`);
   for (const id of warningIds) {
     await deleteMessage(effectiveServerUrl, sessionId, id);
   }
@@ -24968,6 +25108,9 @@ function isProcessAlive2(pid) {
   }
 }
 
+// src/pool.ts
+import { realpathSync as realpathSync3 } from "fs";
+
 // src/bridge.ts
 import { spawn as spawn3 } from "child_process";
 import { homedir as homedir7 } from "os";
@@ -25060,6 +25203,7 @@ class BinaryBridge {
   minVersion;
   onVersionMismatch;
   onConfigureWarnings;
+  onBashCompletion;
   restartResetTimer = null;
   constructor(binaryPath, cwd, options, configOverrides) {
     this.binaryPath = binaryPath;
@@ -25070,6 +25214,7 @@ class BinaryBridge {
     this.minVersion = options?.minVersion;
     this.onVersionMismatch = options?.onVersionMismatch;
     this.onConfigureWarnings = options?.onConfigureWarnings;
+    this.onBashCompletion = options?.onBashCompletion;
   }
   get restartCount() {
     return this._restartCount;
@@ -25077,6 +25222,9 @@ class BinaryBridge {
   isAlive() {
     return this.process !== null && this.process.exitCode === null && !this.process.killed;
   }
+  hasPendingRequests() {
+    return this.pending.size > 0;
+  }
   async send(command, params = {}, options) {
     if (this._shuttingDown) {
       throw new Error(`[aft-plugin] Bridge is shutting down, cannot send "${command}"`);
@@ -25130,17 +25278,21 @@ class BinaryBridge {
 `;
     const effectiveTimeoutMs = options?.transportTimeoutMs ?? options?.timeoutMs ?? this.timeoutMs;
     const requestSessionId = typeof params.session_id === "string" && params.session_id.length > 0 ? params.session_id : undefined;
+    const keepBridgeOnTimeout = options?.keepBridgeOnTimeout === true;
     return new Promise((resolve4, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
-        const timeoutMsg = `Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms \u2014 restarting bridge`;
+        const restartSuffix = keepBridgeOnTimeout ? "" : " \u2014 restarting bridge";
+        const timeoutMsg = `Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms${restartSuffix}`;
         if (requestSessionId) {
           sessionWarn(requestSessionId, timeoutMsg);
         } else {
           warn(timeoutMsg);
         }
         reject(new Error(`[aft-plugin] Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
-        this.handleTimeout();
+        if (!keepBridgeOnTimeout) {
+          this.handleTimeout();
+        }
       }, effectiveTimeoutMs);
       this.pending.set(id, { resolve: resolve4, reject, timer, onProgress: options?.onProgress });
       if (!this.process?.stdin?.writable) {
@@ -25345,6 +25497,10 @@ class BinaryBridge {
           }
           continue;
         }
+        if (response.type === "bash_completed") {
+          this.onBashCompletion?.(response, this);
+          continue;
+        }
         const id = response.id;
         if (id && this.pending.has(id)) {
           const entry = this.pending.get(id);
@@ -25354,6 +25510,8 @@ class BinaryBridge {
           clearTimeout(entry.timer);
           this.scheduleRestartCountReset();
           entry.resolve(response);
+        } else if (typeof response.type === "string") {
+          log(`Ignoring unknown stdout push frame type: ${response.type}`);
         }
       } catch (_err) {
         warn(`Failed to parse stdout line: ${line}`);
@@ -25451,7 +25609,8 @@ class BridgePool {
       maxRestarts: options.maxRestarts,
       minVersion: options.minVersion,
       onVersionMismatch: options.onVersionMismatch,
-      onConfigureWarnings: options.onConfigureWarnings
+      onConfigureWarnings: options.onConfigureWarnings,
+      onBashCompletion: options.onBashCompletion
     };
     this.configOverrides = configOverrides;
     if (Number.isFinite(this.idleTimeoutMs)) {
@@ -25474,6 +25633,14 @@ class BridgePool {
     }
     return null;
   }
+  getActiveBridgeForRoot(projectRoot) {
+    const key = normalizeKey(projectRoot);
+    const entry = this.bridges.get(key);
+    if (!entry?.bridge.isAlive())
+      return null;
+    entry.lastUsed = Date.now();
+    return entry.bridge;
+  }
   getBridge(projectRoot) {
     const key = normalizeKey(projectRoot);
     const existing = this.bridges.get(key);
@@ -25533,7 +25700,12 @@ class BridgePool {
   }
 }
 function normalizeKey(projectRoot) {
-  return projectRoot.replace(/[/\\]+$/, "");
+  const stripped = projectRoot.replace(/[/\\]+$/, "");
+  try {
+    return realpathSync3(stripped);
+  } catch {
+    return stripped;
+  }
 }
 
 // src/resolver.ts
@@ -25771,9 +25943,7 @@ class AftRpcServer {
         return;
       }
       const { token: _token, ...handlerParams } = params;
-      log(`RPC call: ${method} params=${JSON.stringify(handlerParams).slice(0, 200)}`);
       handler(handlerParams).then((result) => {
-        log(`RPC result: ${method} => ${JSON.stringify(result).slice(0, 200)}`);
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify(result));
       }).catch((err) => {
@@ -26025,8 +26195,9 @@ import {
 } from "fs";
 import { isIP } from "net";
 import { join as join17 } from "path";
+import { Agent, fetch as undiciFetch } from "undici";
 var MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
-var CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+var CACHE_TTL_MS2 = 24 * 60 * 60 * 1000;
 var FETCH_TIMEOUT_MS = 30000;
 var MAX_REDIRECTS = 5;
 function cacheDir(storageDir) {
@@ -26116,7 +26287,7 @@ function isPrivateIp(address) {
   }
   return true;
 }
-async function assertPublicUrl(url2, allowPrivate) {
+async function assertPublicUrl(url2, allowPrivate, dnsLookup = lookup) {
   if (url2.protocol !== "http:" && url2.protocol !== "https:") {
     throw new Error(`Only http:// and https:// URLs are supported, got: ${url2.protocol}`);
   }
@@ -26127,14 +26298,27 @@ async function assertPublicUrl(url2, allowPrivate) {
     if (isPrivateIp(hostname3)) {
       throw new Error(`Blocked private URL host ${url2.hostname} (${hostname3})`);
     }
-    return;
+    return hostname3;
   }
-  const addresses = await lookup(hostname3, { all: true, verbatim: true });
+  const addresses = await dnsLookup(hostname3, { all: true, verbatim: true });
   for (const { address } of addresses) {
     if (isPrivateIp(address)) {
       throw new Error(`Blocked private URL host ${url2.hostname} (${address})`);
     }
   }
+  if (addresses.length === 0) {
+    throw new Error(`Failed to resolve URL host ${url2.hostname}`);
+  }
+  return addresses[0].address;
+}
+function createPinnedDispatcher(validatedIp) {
+  return new Agent({
+    connect: {
+      lookup: (_hostname, _opts, callback) => {
+        callback(null, validatedIp, validatedIp.includes(":") ? 6 : 4);
+      }
+    }
+  });
 }
 function resolveRedirectUrl(currentUrl, location) {
   if (!location) {
@@ -26142,17 +26326,21 @@ function resolveRedirectUrl(currentUrl, location) {
   }
   return new URL(location, currentUrl);
 }
-async function fetchWithRedirects(startUrl, allowPrivate) {
+async function fetchWithRedirects(startUrl, allowPrivate, deps = {}) {
   let currentUrl = startUrl;
+  const fetchImpl = deps.fetchImpl ?? undiciFetch;
+  const dnsLookup = deps.lookup ?? lookup;
   for (let redirectCount = 0;redirectCount <= MAX_REDIRECTS; redirectCount++) {
-    await assertPublicUrl(currentUrl, allowPrivate);
+    const validatedIp = await assertPublicUrl(currentUrl, allowPrivate, dnsLookup);
+    const dispatcher = validatedIp ? (deps.dispatcherFactory ?? createPinnedDispatcher)(validatedIp) : undefined;
     const controller = new AbortController;
     const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
     let response;
     try {
-      response = await fetch(currentUrl.href, {
+      response = await fetchImpl(currentUrl.href, {
         signal: controller.signal,
         redirect: "manual",
+        dispatcher,
         headers: {
           "user-agent": "aft-opencode-plugin",
           accept: "application/vnd.github.raw, text/markdown, text/x-markdown, text/html;q=0.9, text/plain;q=0.5"
@@ -26206,14 +26394,14 @@ async function fetchUrlToTempFile(url2, storageDir, options = {}) {
       const meta4 = JSON.parse(readFileSync8(metaFile, "utf8"));
       const age = Date.now() - meta4.fetchedAt;
       const cached2 = contentPath(storageDir, hash2, meta4.extension);
-      if (age < CACHE_TTL_MS && existsSync11(cached2)) {
+      if (age < CACHE_TTL_MS2 && existsSync11(cached2)) {
         log(`URL cache hit: ${url2} (${Math.round(age / 1000)}s old)`);
         return cached2;
       }
     } catch {}
   }
   log(`Fetching URL: ${url2}`);
-  const response = await fetchWithRedirects(parsed, allowPrivate);
+  const response = await fetchWithRedirects(parsed, allowPrivate, options);
   if (!response.ok) {
     throw new Error(`HTTP ${response.status} ${response.statusText} fetching ${url2}`);
   }
@@ -26279,7 +26467,7 @@ function cleanupUrlCache(storageDir) {
       try {
         const meta3 = JSON.parse(readFileSync8(metaFile, "utf8"));
         const age = Date.now() - meta3.fetchedAt;
-        if (age > CACHE_TTL_MS) {
+        if (age > CACHE_TTL_MS2) {
           const hash2 = entry.slice(0, -".meta.json".length);
           const content = contentPath(storageDir, hash2, meta3.extension);
           if (existsSync11(content))
@@ -27079,6 +27267,7 @@ function createBashTool(ctx) {
         permissions_requested: true
       }, callBridge, {
         transportTimeoutMs: bashTransportTimeoutMs(args.timeout),
+        keepBridgeOnTimeout: true,
         onProgress: ({ text }) => {
           accumulatedOutput = preview(accumulatedOutput + text);
           metadata?.({ output: accumulatedOutput, description });
@@ -27140,6 +27329,49 @@ function createBashTool(ctx) {
     }
   };
 }
+function createBashStatusTool(ctx) {
+  return {
+    description: "Check the status and captured output of a background bash task spawned with bash({ background: true }). Returns status (running | completed | failed | killed | timed_out), exit code, duration, and a preview of captured output.",
+    args: {
+      taskId: z3.string().describe("Background task ID returned by bash({ background: true }), e.g. bgb-6b454047.")
+    },
+    execute: async (args, context) => {
+      const data = await callBridge(ctx, context, "bash_status", {
+        task_id: args.taskId
+      });
+      if (data.success === false) {
+        throw new Error(data.message ?? "bash_status failed");
+      }
+      const status = data.status;
+      const exit = typeof data.exit_code === "number" ? ` (exit ${data.exit_code})` : "";
+      const dur = typeof data.duration_ms === "number" ? ` ${Math.round(data.duration_ms / 1000)}s` : "";
+      let text = `Task ${args.taskId}: ${status}${exit}${dur}`;
+      const preview = data.output_preview;
+      if (preview && status !== "running") {
+        text += `
+${preview.slice(0, 2000)}`;
+      }
+      return text;
+    }
+  };
+}
+function createBashKillTool(ctx) {
+  return {
+    description: "Terminate a running background bash task spawned with bash({ background: true }). Returns confirmation of kill or an error if the task already finished.",
+    args: {
+      taskId: z3.string().describe("Background task ID returned by bash({ background: true }), e.g. bgb-6b454047.")
+    },
+    execute: async (args, context) => {
+      const data = await callBridge(ctx, context, "bash_kill", {
+        task_id: args.taskId
+      });
+      if (data.success === false) {
+        throw new Error(data.message ?? "bash_kill failed");
+      }
+      return `Task ${args.taskId}: ${String(data.status ?? "killed")}`;
+    }
+  };
+}
 function bashTransportTimeoutMs(timeout) {
   const bashTimeout = timeout ?? DEFAULT_BASH_TIMEOUT_MS;
   return Math.max(30000, bashTimeout + BASH_TRANSPORT_TIMEOUT_OVERHEAD_MS);
@@ -27770,6 +28002,11 @@ function createEditTool(ctx, writeToolName = "write") {
         }
       }
       let result = JSON.stringify(data);
+      const globSkipNote = formatGlobSkipReasonsNote(data.format_skip_reasons);
+      if (globSkipNote)
+        result += `
+
+${globSkipNote}`;
       if (!args.dryRun) {
         const diags = data.lsp_diagnostics;
         if (diags && diags.length > 0) {
@@ -27800,6 +28037,14 @@ Note: LSP server(s) exited during this edit: ${exitedServers.join(", ")}. Their
     }
   };
 }
+function formatGlobSkipReasonsNote(reasons) {
+  if (!Array.isArray(reasons))
+    return;
+  const actionable = reasons.filter((reason) => typeof reason === "string").filter((reason) => ["formatter_not_installed", "formatter_excluded_path", "timeout", "error"].includes(reason));
+  if (actionable.length === 0)
+    return;
+  return `Note: formatter skipped some glob edit result file(s): ${[...new Set(actionable)].sort().join(", ")}. See per-file format_skipped_reason values for details.`;
+}
 var APPLY_PATCH_DESCRIPTION = `Use the \`apply_patch\` tool to edit files. Your patch language is a stripped\u2011down, file\u2011oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high\u2011level envelope:
 
 *** Begin Patch
@@ -28051,8 +28296,8 @@ ${diagLines}`);
         const summary = partial2 ? `Patch partially applied \u2014 ${hunks.length - failures.length} of ${hunks.length} hunk(s) succeeded. Failed: ${failures.join(", ")}. Successful changes are kept; use \`aft_safety\` to revert if you want to abort.` : `Patch failed \u2014 none of the ${hunks.length} hunk(s) applied: ${failures.join(", ")}.`;
         results.push(summary);
         if (!partial2) {
-          return results.join(`
-`);
+          throw new Error(results.join(`
+`));
         }
       }
       const callID = getCallID2(context);
@@ -28158,6 +28403,8 @@ function createMoveTool(ctx) {
 function hoistedTools(ctx) {
   return {
     bash: createBashTool(ctx),
+    bash_status: createBashStatusTool(ctx),
+    bash_kill: createBashKillTool(ctx),
     read: createReadTool(ctx),
     write: createWriteTool(ctx, "edit"),
     edit: createEditTool(ctx, "write"),
@@ -28529,9 +28776,12 @@ Provide exactly ONE of 'filePath' or 'url'. Pass either 'symbol' for a single lo
             const params2 = { file: file2, symbol: sym };
             if (args.contextLines !== undefined)
               params2.context_lines = args.contextLines;
-            return callBridge(ctx, context, "zoom", params2);
+            return callBridge(ctx, context, "zoom", params2).catch((err) => ({
+              success: false,
+              message: err instanceof Error ? err.message : String(err)
+            }));
           }));
-          return JSON.stringify(results);
+          return JSON.stringify(formatZoomBatchResult(args.symbols, results), null, 2);
         }
         const params = { file: file2 };
         if (typeof args.symbol === "string")
@@ -28547,6 +28797,40 @@ Provide exactly ONE of 'filePath' or 'url'. Pass either 'symbol' for a single lo
     }
   };
 }
+function formatZoomBatchResult(symbols, responses) {
+  const entries = symbols.map((name, index) => {
+    const response = responses[index] ?? { success: false, message: "missing zoom response" };
+    if (response.success === false) {
+      const message = typeof response.message === "string" && response.message.length > 0 ? response.message : "zoom failed";
+      return { name, success: false, error: message };
+    }
+    return { name, success: true, content: zoomResponseContent(response) };
+  });
+  const complete = entries.every((entry) => entry.success);
+  const lines = [];
+  if (!complete) {
+    lines.push("Incomplete zoom results: one or more symbols failed.");
+  }
+  for (const entry of entries) {
+    if (entry.success) {
+      lines.push(`Symbol "${entry.name}":
+${entry.content ?? ""}`.trimEnd());
+    } else {
+      lines.push(`Symbol "${entry.name}" not found: ${entry.error ?? "zoom failed"}`);
+    }
+  }
+  return { complete, symbols: entries, text: lines.join(`
+
+`) };
+}
+function zoomResponseContent(response) {
+  if (typeof response.content === "string")
+    return response.content;
+  if (typeof response.text === "string")
+    return response.text;
+  const { success: _success2, ...rest } = response;
+  return JSON.stringify(rest, null, 2);
+}
 var SKIP_DIRS = new Set([
   "node_modules",
   ".git",
@@ -28622,7 +28906,7 @@ var LSP_SYMBOL_KIND_MAP = {
   12: "function",
   23: "struct"
 };
-async function queryLspHints(client, symbolName, directory) {
+async function queryLspHints(client, symbolName, directory, sessionId) {
   try {
     const statusResult = await client.lsp.status();
     const servers = statusResult.data;
@@ -28664,7 +28948,7 @@ async function queryLspHints(client, symbolName, directory) {
     }
     return { symbols: hints };
   } catch (err) {
-    warn(`LSP query failed for "${symbolName}": ${err.message}`);
+    sessionWarn(sessionId, `LSP query failed for "${symbolName}": ${err.message}`);
     return;
   }
 }
@@ -28753,7 +29037,7 @@ function refactoringTools(ctx) {
             params.call_site_line = Number(args.callSiteLine);
             break;
         }
-        const hints = await queryLspHints(ctx.client, args.symbol ?? args.name);
+        const hints = await queryLspHints(ctx.client, args.symbol ?? args.name, undefined, context.sessionID);
         if (hints)
           params.lsp_hints = hints;
         const response = await callBridge(ctx, context, commandMap[op], params);
@@ -29109,6 +29393,58 @@ function structureTools(ctx) {
   };
 }
 
+// src/workflow-hints.ts
+var HEADING = "## Prefer AFT tools for token efficiency";
+function buildWorkflowHints(opts) {
+  const sections = [];
+  const grepName = opts.hoistBuiltins ? "grep" : "aft_grep";
+  const bashName = opts.hoistBuiltins ? "bash" : "aft_bash";
+  const bashStatusName = "bash_status";
+  const hasOutline = !opts.disabledTools.has("aft_outline");
+  const hasZoom = !opts.disabledTools.has("aft_zoom");
+  const hasGrep = opts.toolSurface !== "minimal" && !opts.disabledTools.has(grepName);
+  const hasSearch = opts.toolSurface !== "minimal" && opts.semanticEnabled && !opts.disabledTools.has("aft_search");
+  const hasNavigate = opts.toolSurface === "all" && !opts.disabledTools.has("aft_navigate");
+  const hasBgBash = opts.bashBackgroundEnabled && !opts.disabledTools.has(bashName) && !opts.disabledTools.has(bashStatusName);
+  if (hasOutline && hasZoom) {
+    sections.push(`**Web/URL access**: \`aft_outline({ url })\` first for structure, then \`aft_zoom({ url, symbol: "<heading>" })\` for the specific section.`);
+  }
+  if (hasOutline && hasZoom && (hasGrep || hasSearch)) {
+    const locator = hasGrep && hasSearch ? `\`${grepName}\` or \`aft_search\`` : hasGrep ? `\`${grepName}\`` : "`aft_search`";
+    sections.push(`**Code exploration**: ${locator} to locate \u2192 \`aft_outline\` for structure \u2192 \`aft_zoom\` for symbol(s).`);
+  }
+  if (hasNavigate) {
+    sections.push([
+      "Use `aft_navigate` instead of grep + read chains for relationship questions:",
+      "- `callers` \u2014 find all call sites before changing a function signature",
+      "- `impact` \u2014 blast radius (which functions/files will need updates)",
+      "- `trace_to` \u2014 how execution reaches this code from entry points (routes, exports, main)",
+      "- `trace_data` \u2014 follow a value through assignments and parameters across files"
+    ].join(`
+`));
+  }
+  if (hasBgBash) {
+    sections.push(`**Long-running commands** (builds, installs, full test suites): \`${bashName}({ background: true })\` returns immediately with a \`taskId\`. Check progress with \`${bashStatusName}({ taskId })\`.`);
+  }
+  if (sections.length === 0) {
+    return null;
+  }
+  return `${HEADING}
+
+${sections.join(`
+
+`)}`;
+}
+function buildHintsFromConfig(config2, disabledTools) {
+  return buildWorkflowHints({
+    toolSurface: config2.tool_surface ?? "recommended",
+    hoistBuiltins: config2.hoist_builtin_tools !== false,
+    semanticEnabled: config2.semantic_search === true,
+    bashBackgroundEnabled: config2.experimental?.bash?.background === true,
+    disabledTools
+  });
+}
+
 // src/index.ts
 var STATUS_COMMAND = "aft-status";
 var SENTINEL_PREFIX = "__AFT_STATUS_";
@@ -29129,13 +29465,17 @@ function coerceConfigureWarnings(warnings) {
 }
 async function sendIgnoredMessage2(client, sessionID, text) {
   const typedClient = client;
-  const promptInput = {
-    path: { id: sessionID },
-    body: {
-      noReply: true,
-      parts: [{ type: "text", text, ignored: true }]
-    }
+  const lastModel = await getLastUserModel(client, sessionID);
+  const body = {
+    noReply: true,
+    parts: [{ type: "text", text, ignored: true }]
   };
+  if (lastModel) {
+    body.model = { providerID: lastModel.providerID, modelID: lastModel.modelID };
+    if (lastModel.variant)
+      body.variant = lastModel.variant;
+  }
+  const promptInput = { path: { id: sessionID }, body };
   if (typeof typedClient.session?.prompt === "function") {
     await Promise.resolve(typedClient.session.prompt(promptInput));
     return;
@@ -29171,6 +29511,8 @@ var plugin = async (input) => {
   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)
@@ -29306,6 +29648,15 @@ ${lines}
         pluginVersion: PLUGIN_VERSION,
         projectRoot
       }, validWarnings);
+    },
+    onBashCompletion: (completion, bridge) => {
+      handlePushedBgCompletion({
+        ctx,
+        directory: input.directory,
+        sessionID: completion.session_id,
+        client: input.client,
+        isActive: () => bridge.hasPendingRequests()
+      }, completion);
     }
   }, configOverrides);
   const ctx = {
@@ -29326,7 +29677,7 @@ ${lines}
   });
   rpcServer.handle("status", async (params) => {
     const sessionID = params.sessionID || "rpc";
-    const bridge = pool.getAnyActiveBridge(input.directory) ?? pool.getBridge(input.directory);
+    const bridge = pool.getActiveBridgeForRoot(input.directory) ?? pool.getBridge(input.directory);
     return await bridge.send("status", { session_id: sessionID });
   });
   const storageDir = configOverrides.storage_dir;
@@ -29436,8 +29787,34 @@ Install: ${getManualInstallHint()}`).catch(() => {});
     autoUpdate: aftConfig.auto_update ?? true,
     signal: autoUpdateAbort.signal
   });
+  const HINTS_TOOL_NAMES = [
+    "aft_outline",
+    "aft_zoom",
+    "aft_search",
+    "aft_navigate",
+    "grep",
+    "aft_grep",
+    "bash",
+    "aft_bash",
+    "bash_status"
+  ];
+  const registeredTools = new Set(Object.keys(allTools));
+  const hintsAbsentTools = new Set;
+  for (const name of HINTS_TOOL_NAMES) {
+    if (!registeredTools.has(name))
+      hintsAbsentTools.add(name);
+  }
+  const hintsBlock = buildHintsFromConfig(aftConfig, hintsAbsentTools);
+  if (hintsBlock) {
+    log(`Workflow hints injected (${hintsBlock.length} chars)`);
+  }
   return {
     tool: allTools,
+    "experimental.chat.system.transform": async (_input, output) => {
+      if (hintsBlock) {
+        output.system.push(hintsBlock);
+      }
+    },
     event: async (eventInput) => {
       await autoUpdateEventHook(eventInput);
       if (eventInput.event.type !== "session.idle")
@@ -29459,7 +29836,7 @@ Install: ${getManualInstallHint()}`).catch(() => {});
       if (isTuiMode2() || commandInput.command !== STATUS_COMMAND) {
         return;
       }
-      const bridge = ctx.pool.getAnyActiveBridge(input.directory) ?? ctx.pool.getBridge(input.directory);
+      const bridge = ctx.pool.getActiveBridgeForRoot(input.directory) ?? ctx.pool.getBridge(input.directory);
       const response = await bridge.send("status", { session_id: commandInput.sessionID });
       if (response.success === false) {
         throw new Error(response.message || "status failed");