oh-my-opencode 3.15.1 → 3.15.3

package/dist/index.js

@@ -17496,7 +17496,7 @@ function getOpenCodeConfigPaths(options) {
     configJson: join6(configDir, "opencode.json"),
     configJsonc: join6(configDir, "opencode.jsonc"),
     packageJson: join6(configDir, "package.json"),
-    omoConfig: join6(configDir, "oh-my-opencode.json")
+    omoConfig: join6(configDir, `${CONFIG_BASENAME}.json`)
   };
 }
 // src/shared/opencode-version.ts
@@ -60789,15 +60789,19 @@ function convertSDKMessageToStoredMessage(msg) {
 async function findNearestMessageWithFieldsFromSDK(client, sessionID) {
   try {
     const response = await client.session.messages({ path: { id: sessionID } });
-    const messages = normalizeSDKResponse(response, [], { preferResponseOnMissingData: true });
-    for (let i2 = messages.length - 1;i2 >= 0; i2--) {
-      const stored = convertSDKMessageToStoredMessage(messages[i2]);
+    const messages = normalizeSDKResponse(response, [], { preferResponseOnMissingData: true }).map((message) => ({
+      stored: convertSDKMessageToStoredMessage(message),
+      createdAt: message.info?.time?.created ?? Number.NEGATIVE_INFINITY,
+      id: typeof message.id === "string" ? message.id : ""
+    })).sort((left, right) => right.createdAt - left.createdAt || right.id.localeCompare(left.id));
+    for (const message of messages) {
+      const stored = message.stored;
       if (stored?.agent && stored.model?.providerID && stored.model?.modelID) {
         return stored;
       }
     }
-    for (let i2 = messages.length - 1;i2 >= 0; i2--) {
-      const stored = convertSDKMessageToStoredMessage(messages[i2]);
+    for (const message of messages) {
+      const stored = message.stored;
       if (stored?.agent || stored?.model?.providerID && stored?.model?.modelID) {
         return stored;
       }
@@ -60813,7 +60817,15 @@ async function findNearestMessageWithFieldsFromSDK(client, sessionID) {
 async function findFirstMessageWithAgentFromSDK(client, sessionID) {
   try {
     const response = await client.session.messages({ path: { id: sessionID } });
-    const messages = normalizeSDKResponse(response, [], { preferResponseOnMissingData: true });
+    const messages = normalizeSDKResponse(response, [], { preferResponseOnMissingData: true }).sort((left, right) => {
+      const leftTime = left.info?.time?.created ?? Number.POSITIVE_INFINITY;
+      const rightTime = right.info?.time?.created ?? Number.POSITIVE_INFINITY;
+      if (leftTime !== rightTime)
+        return leftTime - rightTime;
+      const leftId = typeof left.id === "string" ? left.id : "";
+      const rightId = typeof right.id === "string" ? right.id : "";
+      return leftId.localeCompare(rightId);
+    });
     for (const msg of messages) {
       const stored = convertSDKMessageToStoredMessage(msg);
       if (stored?.agent) {
@@ -60833,27 +60845,27 @@ function findNearestMessageWithFields(messageDir) {
     return null;
   }
   try {
-    const files = readdirSync(messageDir).filter((f) => f.endsWith(".json")).sort().reverse();
-    for (const file of files) {
+    const messages = readdirSync(messageDir).filter((f) => f.endsWith(".json")).map((fileName) => {
       try {
-        const content = readFileSync6(join12(messageDir, file), "utf-8");
+        const content = readFileSync6(join12(messageDir, fileName), "utf-8");
         const msg = JSON.parse(content);
-        if (msg.agent && msg.model?.providerID && msg.model?.modelID) {
-          return msg;
-        }
+        return {
+          fileName,
+          msg,
+          createdAt: typeof msg.time?.created === "number" ? msg.time.created : Number.NEGATIVE_INFINITY
+        };
       } catch {
-        continue;
+        return null;
+      }
+    }).filter((entry) => entry !== null).sort((left, right) => right.createdAt - left.createdAt || right.fileName.localeCompare(left.fileName));
+    for (const entry of messages) {
+      if (entry.msg.agent && entry.msg.model?.providerID && entry.msg.model?.modelID) {
+        return entry.msg;
       }
     }
-    for (const file of files) {
-      try {
-        const content = readFileSync6(join12(messageDir, file), "utf-8");
-        const msg = JSON.parse(content);
-        if (msg.agent || msg.model?.providerID && msg.model?.modelID) {
-          return msg;
-        }
-      } catch {
-        continue;
+    for (const entry of messages) {
+      if (entry.msg.agent || entry.msg.model?.providerID && entry.msg.model?.modelID) {
+        return entry.msg;
       }
     }
   } catch {
@@ -60866,16 +60878,22 @@ function findFirstMessageWithAgent(messageDir) {
     return null;
   }
   try {
-    const files = readdirSync(messageDir).filter((f) => f.endsWith(".json")).sort();
-    for (const file of files) {
+    const messages = readdirSync(messageDir).filter((f) => f.endsWith(".json")).map((fileName) => {
       try {
-        const content = readFileSync6(join12(messageDir, file), "utf-8");
+        const content = readFileSync6(join12(messageDir, fileName), "utf-8");
         const msg = JSON.parse(content);
-        if (msg.agent) {
-          return msg.agent;
-        }
+        return {
+          fileName,
+          msg,
+          createdAt: typeof msg.time?.created === "number" ? msg.time.created : Number.POSITIVE_INFINITY
+        };
       } catch {
-        continue;
+        return null;
+      }
+    }).filter((entry) => entry !== null).sort((left, right) => left.createdAt - right.createdAt || left.fileName.localeCompare(right.fileName));
+    for (const entry of messages) {
+      if (entry.msg.agent) {
+        return entry.msg.agent;
       }
     }
   } catch {
@@ -60983,7 +61001,7 @@ function getAgentConfigKey(agentName) {
     return lower;
   return lower;
 }
-function normalizeAgentForPrompt(agentName) {
+function normalizeAgentForPromptKey(agentName) {
   if (typeof agentName !== "string") {
     return;
   }
@@ -60994,10 +61012,10 @@ function normalizeAgentForPrompt(agentName) {
   const lower = trimmed.toLowerCase();
   const reversed = REVERSE_DISPLAY_NAMES[lower];
   if (reversed !== undefined) {
-    return AGENT_DISPLAY_NAMES[reversed] ?? trimmed;
+    return reversed;
   }
   if (AGENT_DISPLAY_NAMES[lower] !== undefined) {
-    return AGENT_DISPLAY_NAMES[lower];
+    return lower;
   }
   return trimmed;
 }
@@ -62294,11 +62312,11 @@ function getPluginsBaseDir() {
   }
   return join18(homedir6(), ".claude", "plugins");
 }
-function getInstalledPluginsPath() {
-  return join18(getPluginsBaseDir(), "installed_plugins.json");
+function getInstalledPluginsPath(pluginsBaseDir) {
+  return join18(pluginsBaseDir ?? getPluginsBaseDir(), "installed_plugins.json");
 }
-function loadInstalledPlugins() {
-  const dbPath = getInstalledPluginsPath();
+function loadInstalledPlugins(pluginsBaseDir) {
+  const dbPath = getInstalledPluginsPath(pluginsBaseDir);
   if (!existsSync14(dbPath)) {
     return null;
   }
@@ -62402,7 +62420,8 @@ function extractPluginEntries(db) {
   return Object.entries(db.plugins).map(([key, installations]) => [key, installations[0]]);
 }
 function discoverInstalledPlugins(options) {
-  const db = loadInstalledPlugins();
+  const pluginsBaseDir = options?.pluginsHomeOverride ?? getPluginsBaseDir();
+  const db = loadInstalledPlugins(pluginsBaseDir);
   const settings = loadClaudeSettings();
   const plugins = [];
   const errors = [];
@@ -62411,6 +62430,7 @@ function discoverInstalledPlugins(options) {
   }
   const settingsEnabledPlugins = settings?.enabledPlugins;
   const overrideEnabledPlugins = options?.enabledPluginsOverride;
+  const pluginManifestLoader = options?.loadPluginManifestOverride ?? loadPluginManifest;
   for (const [pluginKey, installation] of extractPluginEntries(db)) {
     if (!installation)
       continue;
@@ -62427,7 +62447,7 @@ function discoverInstalledPlugins(options) {
       });
       continue;
     }
-    const manifest = loadPluginManifest(installPath);
+    const manifest = pluginManifestLoader(installPath);
     const pluginName = manifest?.name || derivePluginNameFromKey(pluginKey);
     const loadedPlugin = {
       name: pluginName,
@@ -62928,11 +62948,21 @@ function loadPluginHooksConfigs(plugins) {
 }
 
 // src/features/claude-code-plugin-loader/loader.ts
+var cachedPluginComponentsByKey = new Map;
+function clonePluginComponentsResult(result) {
+  return structuredClone(result);
+}
 function isClaudeCodePluginsDisabled() {
   const disableFlag = process.env.OPENCODE_DISABLE_CLAUDE_CODE;
   const disablePluginsFlag = process.env.OPENCODE_DISABLE_CLAUDE_CODE_PLUGINS;
   return disableFlag === "true" || disableFlag === "1" || disablePluginsFlag === "true" || disablePluginsFlag === "1";
 }
+function getPluginComponentsCacheKey(options) {
+  const overrideEntries = Object.entries(options?.enabledPluginsOverride ?? {}).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey));
+  return JSON.stringify({
+    enabledPluginsOverride: overrideEntries
+  });
+}
 async function loadAllPluginComponents(options) {
   if (isClaudeCodePluginsDisabled()) {
     log("Claude Code plugin loading disabled via OPENCODE_DISABLE_CLAUDE_CODE env var");
@@ -62946,6 +62976,11 @@ async function loadAllPluginComponents(options) {
       errors: []
     };
   }
+  const cacheKey = getPluginComponentsCacheKey(options);
+  const cachedPluginComponents = cachedPluginComponentsByKey.get(cacheKey);
+  if (cachedPluginComponents) {
+    return clonePluginComponentsResult(cachedPluginComponents);
+  }
   const { plugins, errors } = discoverInstalledPlugins(options);
   const [commands, skills, agents, mcpServers, hooksConfigs] = await Promise.all([
     Promise.resolve(loadPluginCommands(plugins)),
@@ -62955,7 +62990,7 @@ async function loadAllPluginComponents(options) {
     Promise.resolve(loadPluginHooksConfigs(plugins))
   ]);
   log(`Loaded ${plugins.length} plugins with ${Object.keys(commands).length} commands, ${Object.keys(skills).length} skills, ${Object.keys(agents).length} agents, ${Object.keys(mcpServers).length} MCP servers`);
-  return {
+  const result = {
     commands,
     skills,
     agents,
@@ -62964,6 +62999,8 @@ async function loadAllPluginComponents(options) {
     plugins,
     errors
   };
+  cachedPluginComponentsByKey.set(cacheKey, clonePluginComponentsResult(result));
+  return clonePluginComponentsResult(result);
 }
 // src/shared/plugin-command-discovery.ts
 function discoverPluginCommandDefinitions(options) {
@@ -63478,11 +63515,12 @@ async function injectContinuation(args) {
     } : undefined);
     tools = tools ?? previousMessage?.tools;
   }
-  if (agentName && skipAgents.some((s) => getAgentConfigKey(s) === getAgentConfigKey(agentName))) {
+  const promptAgent = normalizeAgentForPromptKey(agentName);
+  if (promptAgent && skipAgents.some((s) => getAgentConfigKey(s) === getAgentConfigKey(promptAgent))) {
     log(`[${HOOK_NAME}] Skipped: agent in skipAgents list`, { sessionID, agent: agentName });
     return;
   }
-  if (!agentName) {
+  if (!promptAgent) {
     const compactionState = sessionStateStore.getExistingState(sessionID);
     if (compactionState && isCompactionGuardActive(compactionState, Date.now())) {
       log(`[${HOOK_NAME}] Skipped: agent unknown after compaction`, { sessionID });
@@ -63513,7 +63551,7 @@ ${todoList}`;
   try {
     log(`[${HOOK_NAME}] Injecting continuation`, {
       sessionID,
-      agent: agentName,
+      agent: promptAgent,
       model,
       incompleteCount: freshIncompleteCount
     });
@@ -63521,7 +63559,7 @@ ${todoList}`;
     await ctx.client.session.promptAsync({
       path: { id: sessionID },
       body: {
-        agent: agentName,
+        agent: promptAgent,
         ...model !== undefined ? { model } : {},
         ...inheritedTools ? { tools: inheritedTools } : {},
         parts: [createInternalAgentTextPart(prompt)]
@@ -82203,6 +82241,7 @@ var RETRYABLE_MESSAGE_PATTERNS = [
   "over limit",
   "overloaded",
   "bad gateway",
+  "bad request",
   "unknown provider",
   "provider not found",
   "model_not_supported",
@@ -82529,13 +82568,15 @@ init_logger();
 import { existsSync as existsSync39 } from "fs";
 import { join as join42 } from "path";
 var CONFIG_CACHE_TTL_MS2 = 30000;
-var USER_CONFIG_PATH = join42(getOpenCodeConfigDir({ binary: "opencode" }), "opencode-cc-plugin.json");
 var configCache2 = new Map;
+function getUserConfigPath() {
+  return join42(getOpenCodeConfigDir({ binary: "opencode" }), "opencode-cc-plugin.json");
+}
 function getProjectConfigPath() {
   return join42(process.cwd(), ".opencode", "opencode-cc-plugin.json");
 }
 function getCacheKey2() {
-  return process.cwd();
+  return `${process.cwd()}::${getUserConfigPath()}`;
 }
 function getCachedConfig2(cacheKey) {
   const cachedEntry = configCache2.get(cacheKey);
@@ -82582,7 +82623,7 @@ async function loadPluginExtendedConfig() {
   if (cachedConfig) {
     return cachedConfig;
   }
-  const userConfig = await loadConfigFromPath(USER_CONFIG_PATH);
+  const userConfig = await loadConfigFromPath(getUserConfigPath());
   const projectConfig = await loadConfigFromPath(getProjectConfigPath());
   const merged = {
     disabledHooks: mergeDisabledHooks(userConfig?.disabledHooks, projectConfig?.disabledHooks)
@@ -84427,26 +84468,33 @@ function getWindowsAppdataDir2() {
     return null;
   return process.env.APPDATA ?? path5.join(os4.homedir(), "AppData", "Roaming");
 }
-var USER_CONFIG_DIR = getOpenCodeConfigDir({ binary: "opencode" });
-var USER_OPENCODE_CONFIG = path5.join(USER_CONFIG_DIR, "opencode.json");
-var USER_OPENCODE_CONFIG_JSONC = path5.join(USER_CONFIG_DIR, "opencode.jsonc");
+function getUserConfigDir() {
+  return getOpenCodeConfigDir({ binary: "opencode" });
+}
+function getUserOpencodeConfig() {
+  return path5.join(getUserConfigDir(), "opencode.json");
+}
+function getUserOpencodeConfigJsonc() {
+  return path5.join(getUserConfigDir(), "opencode.jsonc");
+}
 var INSTALLED_PACKAGE_JSON = path5.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
 
 // src/hooks/auto-update-checker/checker/config-paths.ts
 import * as os5 from "os";
 import * as path6 from "path";
 function getConfigPaths2(directory) {
+  const userConfigDir = getUserConfigDir();
   const paths = [
     path6.join(directory, ".opencode", "opencode.json"),
     path6.join(directory, ".opencode", "opencode.jsonc"),
-    USER_OPENCODE_CONFIG,
-    USER_OPENCODE_CONFIG_JSONC
+    getUserOpencodeConfig(),
+    getUserOpencodeConfigJsonc()
   ];
   if (process.platform === "win32") {
     const crossPlatformDir = path6.join(os5.homedir(), ".config");
     const appdataDir = getWindowsAppdataDir2();
     if (appdataDir) {
-      const alternateDir = USER_CONFIG_DIR === crossPlatformDir ? appdataDir : crossPlatformDir;
+      const alternateDir = userConfigDir === crossPlatformDir ? appdataDir : crossPlatformDir;
       const alternateConfig = path6.join(alternateDir, "opencode", "opencode.json");
       const alternateConfigJsonc = path6.join(alternateDir, "opencode", "opencode.jsonc");
       if (!paths.includes(alternateConfig)) {
@@ -84937,8 +84985,9 @@ function removeFromBunLock(packageName) {
 }
 function invalidatePackage(packageName = PACKAGE_NAME) {
   try {
+    const userConfigDir = getUserConfigDir();
     const pkgDirs = [
-      path10.join(USER_CONFIG_DIR, "node_modules", packageName),
+      path10.join(userConfigDir, "node_modules", packageName),
       path10.join(CACHE_DIR, "node_modules", packageName)
     ];
     let packageRemoved = false;
@@ -94744,6 +94793,15 @@ function readBoulderState(directory) {
     if (!Array.isArray(parsed.session_ids)) {
       parsed.session_ids = [];
     }
+    if (!parsed.session_origins || typeof parsed.session_origins !== "object" || Array.isArray(parsed.session_origins)) {
+      parsed.session_origins = {};
+    }
+    if (parsed.session_ids.length === 1) {
+      const soleSessionId = parsed.session_ids[0];
+      if (typeof soleSessionId === "string" && parsed.session_origins[soleSessionId] !== "appended" && parsed.session_origins[soleSessionId] !== "direct") {
+        parsed.session_origins[soleSessionId] = "direct";
+      }
+    }
     if (!parsed.task_sessions || typeof parsed.task_sessions !== "object" || Array.isArray(parsed.task_sessions)) {
       parsed.task_sessions = {};
     }
@@ -94765,22 +94823,34 @@ function writeBoulderState(directory, state3) {
     return false;
   }
 }
-function appendSessionId(directory, sessionId) {
+function appendSessionId(directory, sessionId, origin = "direct") {
   const state3 = readBoulderState(directory);
   if (!state3)
     return null;
+  if (!state3.session_origins || typeof state3.session_origins !== "object" || Array.isArray(state3.session_origins)) {
+    state3.session_origins = {};
+  }
   if (!state3.session_ids?.includes(sessionId)) {
     if (!Array.isArray(state3.session_ids)) {
       state3.session_ids = [];
     }
     const originalSessionIds = [...state3.session_ids];
+    const originalSessionOrigins = { ...state3.session_origins };
     state3.session_ids.push(sessionId);
+    state3.session_origins[sessionId] = origin;
     if (writeBoulderState(directory, state3)) {
       return state3;
     }
     state3.session_ids = originalSessionIds;
+    state3.session_origins = originalSessionOrigins;
     return null;
   }
+  if (!state3.session_origins[sessionId]) {
+    state3.session_origins[sessionId] = origin;
+    if (!writeBoulderState(directory, state3)) {
+      return null;
+    }
+  }
   return state3;
 }
 function clearBoulderState(directory) {
@@ -94869,6 +94939,9 @@ function createBoulderState(planPath, sessionId, agent, worktreePath) {
     active_plan: planPath,
     started_at: new Date().toISOString(),
     session_ids: [sessionId],
+    session_origins: {
+      [sessionId]: "direct"
+    },
     plan_name: getPlanName(planPath),
     ...agent !== undefined ? { agent } : {},
     ...worktreePath !== undefined ? { worktree_path: worktreePath } : {}
@@ -95500,6 +95573,100 @@ function isAbortError(error48) {
   return false;
 }
 
+// src/hooks/atlas/session-last-agent.ts
+import { readFileSync as readFileSync44, readdirSync as readdirSync17 } from "fs";
+import { join as join68 } from "path";
+function isCompactionAgent2(agent) {
+  return typeof agent === "string" && agent.toLowerCase() === "compaction";
+}
+function getLastAgentFromMessageDir(messageDir) {
+  try {
+    const messages = readdirSync17(messageDir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => {
+      try {
+        const content = readFileSync44(join68(messageDir, fileName), "utf-8");
+        const parsed = JSON.parse(content);
+        return {
+          fileName,
+          agent: parsed.agent,
+          createdAt: typeof parsed.time?.created === "number" ? parsed.time.created : Number.NEGATIVE_INFINITY
+        };
+      } catch {
+        return null;
+      }
+    }).filter((message) => message !== null).sort((left, right) => right.createdAt - left.createdAt || right.fileName.localeCompare(left.fileName));
+    for (const message of messages) {
+      if (typeof message.agent === "string" && !isCompactionAgent2(message.agent)) {
+        return message.agent.toLowerCase();
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function getLastAgentFromSession(sessionID, client) {
+  if (isSqliteBackend() && client) {
+    try {
+      const response = await client.session.messages({ path: { id: sessionID } });
+      const messages = normalizeSDKResponse(response, [], {
+        preferResponseOnMissingData: true
+      }).sort((left, right) => {
+        const leftTime = left.info?.time?.created ?? Number.NEGATIVE_INFINITY;
+        const rightTime = right.info?.time?.created ?? Number.NEGATIVE_INFINITY;
+        if (leftTime !== rightTime) {
+          return rightTime - leftTime;
+        }
+        const leftId = typeof left.id === "string" ? left.id : "";
+        const rightId = typeof right.id === "string" ? right.id : "";
+        return rightId.localeCompare(leftId);
+      });
+      for (const message of messages) {
+        const agent = message.info?.agent;
+        if (typeof agent === "string" && !isCompactionAgent2(agent)) {
+          return agent.toLowerCase();
+        }
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  const messageDir = getMessageDir(sessionID);
+  if (!messageDir)
+    return null;
+  return getLastAgentFromMessageDir(messageDir);
+}
+
+// src/hooks/atlas/boulder-session-lineage.ts
+init_logger();
+async function isSessionInBoulderLineage(input) {
+  const visitedSessionIDs = new Set;
+  let currentSessionID = input.sessionID;
+  while (!visitedSessionIDs.has(currentSessionID)) {
+    visitedSessionIDs.add(currentSessionID);
+    const sessionResult = await input.client.session.get({ path: { id: currentSessionID } }).catch((error48) => {
+      log(`[${HOOK_NAME7}] Failed to resolve session lineage`, {
+        sessionID: input.sessionID,
+        currentSessionID,
+        error: error48
+      });
+      return null;
+    });
+    if (!sessionResult || sessionResult.error) {
+      return false;
+    }
+    const parentSessionID = sessionResult.data?.parentID;
+    if (!parentSessionID) {
+      return false;
+    }
+    if (input.boulderSessionIDs.includes(parentSessionID)) {
+      return true;
+    }
+    currentSessionID = parentSessionID;
+  }
+  return false;
+}
+
 // src/hooks/atlas/idle-event.ts
 init_logger();
 
@@ -95696,9 +95863,17 @@ If you were given **multiple genuinely independent goals** (unrelated tasks, par
 async function resolveRecentPromptContextForSession(ctx, sessionID) {
   try {
     const messagesResp = await ctx.client.session.messages({ path: { id: sessionID } });
-    const messages = normalizeSDKResponse(messagesResp, []);
-    for (let i2 = messages.length - 1;i2 >= 0; i2--) {
-      const info = messages[i2].info;
+    const messages = normalizeSDKResponse(messagesResp, []).sort((left, right) => {
+      const leftTime = left.info?.time?.created ?? Number.NEGATIVE_INFINITY;
+      const rightTime = right.info?.time?.created ?? Number.NEGATIVE_INFINITY;
+      if (leftTime !== rightTime)
+        return rightTime - leftTime;
+      const leftId = typeof left.id === "string" ? left.id : "";
+      const rightId = typeof right.id === "string" ? right.id : "";
+      return rightId.localeCompare(leftId);
+    });
+    for (const message of messages) {
+      const info = message.info;
       const model2 = info?.model;
       const tools2 = normalizePromptTools(info?.tools);
       if (model2?.providerID && model2?.modelID) {
@@ -95742,7 +95917,7 @@ async function injectBoulderContinuation(input) {
   const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((t) => t.status === "running") : false;
   if (hasRunningBgTasks) {
     log(`[${HOOK_NAME7}] Skipped injection: background tasks running`, { sessionID });
-    return;
+    return "skipped_background_tasks";
   }
   const worktreeContext = worktreePath ? `
 
@@ -95759,7 +95934,7 @@ async function injectBoulderContinuation(input) {
       sessionID,
       agent: continuationAgent ?? agent ?? "unknown"
     });
-    return;
+    return "skipped_agent_unavailable";
   }
   try {
     log(`[${HOOK_NAME7}] Injecting boulder continuation`, { sessionID, planName, remaining });
@@ -95768,7 +95943,7 @@ async function injectBoulderContinuation(input) {
     await ctx.client.session.promptAsync({
       path: { id: sessionID },
       body: {
-        agent: normalizeAgentForPrompt(continuationAgent) ?? continuationAgent,
+        agent: continuationAgent,
         ...promptContext.model !== undefined ? { model: promptContext.model } : {},
         ...inheritedTools ? { tools: inheritedTools } : {},
         parts: [createInternalAgentTextPart(prompt)]
@@ -95777,6 +95952,7 @@ async function injectBoulderContinuation(input) {
     });
     sessionState.promptFailureCount = 0;
     log(`[${HOOK_NAME7}] Boulder continuation injected`, { sessionID });
+    return "injected";
   } catch (err) {
     sessionState.promptFailureCount += 1;
     sessionState.lastFailureAt = Date.now();
@@ -95785,72 +95961,24 @@ async function injectBoulderContinuation(input) {
       error: String(err),
       promptFailureCount: sessionState.promptFailureCount
     });
+    return "failed";
   }
 }
 
-// src/hooks/atlas/boulder-session-lineage.ts
-init_logger();
-async function isSessionInBoulderLineage(input) {
-  const visitedSessionIDs = new Set;
-  let currentSessionID = input.sessionID;
-  while (!visitedSessionIDs.has(currentSessionID)) {
-    visitedSessionIDs.add(currentSessionID);
-    const sessionResult = await input.client.session.get({ path: { id: currentSessionID } }).catch((error48) => {
-      log(`[${HOOK_NAME7}] Failed to resolve session lineage`, {
-        sessionID: input.sessionID,
-        currentSessionID,
-        error: error48
-      });
-      return null;
-    });
-    if (!sessionResult || sessionResult.error) {
-      return false;
-    }
-    const parentSessionID = sessionResult.data?.parentID;
-    if (!parentSessionID) {
-      return false;
-    }
-    if (input.boulderSessionIDs.includes(parentSessionID)) {
-      return true;
-    }
-    currentSessionID = parentSessionID;
-  }
-  return false;
-}
-
 // src/hooks/atlas/resolve-active-boulder-session.ts
 async function resolveActiveBoulderSession(input) {
   const boulderState = readBoulderState(input.directory);
   if (!boulderState) {
     return null;
   }
+  if (!boulderState.session_ids.includes(input.sessionID)) {
+    return null;
+  }
   const progress = getPlanProgress(boulderState.active_plan);
   if (progress.isComplete) {
     return { boulderState, progress, appendedSession: false };
   }
-  if (boulderState.session_ids.includes(input.sessionID)) {
-    return { boulderState, progress, appendedSession: false };
-  }
-  if (!subagentSessions.has(input.sessionID)) {
-    return null;
-  }
-  const belongsToActiveBoulder = await isSessionInBoulderLineage({
-    client: input.client,
-    sessionID: input.sessionID,
-    boulderSessionIDs: boulderState.session_ids
-  });
-  if (!belongsToActiveBoulder) {
-    return null;
-  }
-  const updatedBoulderState = appendSessionId(input.directory, input.sessionID);
-  if (!updatedBoulderState?.session_ids.includes(input.sessionID)) {
-    return null;
-  }
-  return {
-    boulderState: updatedBoulderState,
-    progress,
-    appendedSession: true
-  };
+  return { boulderState, progress, appendedSession: false };
 }
 
 // src/hooks/atlas/idle-event.ts
@@ -95864,12 +95992,38 @@ function hasRunningBackgroundTasks(sessionID, options) {
 }
 async function injectContinuation2(input) {
   const remaining = input.progress.total - input.progress.completed;
-  input.sessionState.lastContinuationInjectedAt = Date.now();
+  if (input.sessionState.isInjectingContinuation) {
+    scheduleRetry({
+      ctx: input.ctx,
+      sessionID: input.sessionID,
+      sessionState: input.sessionState,
+      options: input.options
+    });
+    return;
+  }
+  input.sessionState.isInjectingContinuation = true;
   try {
     const currentBoulder = readBoulderState(input.ctx.directory);
     const currentTask = currentBoulder ? readCurrentTopLevelTask(currentBoulder.active_plan) : null;
     const preferredTaskSession = currentTask ? getTaskSessionState(input.ctx.directory, currentTask.key) : null;
-    await injectBoulderContinuation({
+    if (!currentBoulder) {
+      return;
+    }
+    const canContinueSession = await canContinueTrackedBoulderSession({
+      client: input.ctx.client,
+      sessionID: input.sessionID,
+      sessionOrigin: currentBoulder.session_origins?.[input.sessionID],
+      boulderSessionIDs: currentBoulder.session_ids,
+      requiredAgent: currentBoulder.agent
+    });
+    if (!canContinueSession) {
+      log(`[${HOOK_NAME7}] Skipped: tracked descendant agent does not match boulder agent`, {
+        sessionID: input.sessionID,
+        requiredAgent: currentBoulder.agent ?? "atlas"
+      });
+      return;
+    }
+    const result = await injectBoulderContinuation({
       ctx: input.ctx,
       sessionID: input.sessionID,
       planName: input.planName,
@@ -95882,9 +96036,43 @@ async function injectContinuation2(input) {
       backgroundManager: input.options?.backgroundManager,
       sessionState: input.sessionState
     });
+    if (result === "injected") {
+      if (input.sessionState.pendingRetryTimer) {
+        clearTimeout(input.sessionState.pendingRetryTimer);
+        input.sessionState.pendingRetryTimer = undefined;
+      }
+      input.sessionState.lastContinuationInjectedAt = Date.now();
+      return;
+    }
+    if (result === "skipped_background_tasks") {
+      scheduleRetry({
+        ctx: input.ctx,
+        sessionID: input.sessionID,
+        sessionState: input.sessionState,
+        options: input.options
+      });
+      return;
+    }
+    if (result === "failed") {
+      scheduleRetry({
+        ctx: input.ctx,
+        sessionID: input.sessionID,
+        sessionState: input.sessionState,
+        options: input.options
+      });
+    }
   } catch (error48) {
     log(`[${HOOK_NAME7}] Failed to inject boulder continuation`, { sessionID: input.sessionID, error: error48 });
     input.sessionState.promptFailureCount += 1;
+    input.sessionState.lastFailureAt = Date.now();
+    scheduleRetry({
+      ctx: input.ctx,
+      sessionID: input.sessionID,
+      sessionState: input.sessionState,
+      options: input.options
+    });
+  } finally {
+    input.sessionState.isInjectingContinuation = false;
   }
 }
 function scheduleRetry(input) {
@@ -95898,6 +96086,10 @@ function scheduleRetry(input) {
       return;
     if (sessionState.waitingForFinalWaveApproval)
       return;
+    const now = Date.now();
+    if (sessionState.lastContinuationInjectedAt && now - sessionState.lastContinuationInjectedAt < CONTINUATION_COOLDOWN_MS2) {
+      return;
+    }
     const currentBoulder = readBoulderState(ctx.directory);
     if (!currentBoulder)
       return;
@@ -95908,8 +96100,19 @@ function scheduleRetry(input) {
       return;
     if (options?.isContinuationStopped?.(sessionID))
       return;
-    if (hasRunningBackgroundTasks(sessionID, options))
+    const canContinueSession = await canContinueTrackedBoulderSession({
+      client: ctx.client,
+      sessionID,
+      sessionOrigin: currentBoulder.session_origins?.[sessionID],
+      boulderSessionIDs: currentBoulder.session_ids,
+      requiredAgent: currentBoulder.agent
+    });
+    if (!canContinueSession)
       return;
+    if (hasRunningBackgroundTasks(sessionID, options)) {
+      scheduleRetry({ ctx, sessionID, sessionState, options });
+      return;
+    }
     await injectContinuation2({
       ctx,
       sessionID,
@@ -95945,27 +96148,19 @@ async function handleAtlasSessionIdle(input) {
       plan: boulderState.plan_name
     });
   }
-  if (subagentSessions.has(sessionID)) {
-    const sessionAgent = getSessionAgent(sessionID);
-    const agentKey = getAgentConfigKey(sessionAgent ?? "");
-    const requiredAgentName = boulderState.agent ?? (isAgentRegistered("atlas") ? "atlas" : undefined);
-    if (!requiredAgentName || !isAgentRegistered(requiredAgentName)) {
-      log(`[${HOOK_NAME7}] Skipped: boulder agent is unavailable for continuation`, {
-        sessionID,
-        requiredAgent: boulderState.agent ?? "unknown"
-      });
-      return;
-    }
-    const requiredAgentKey = getAgentConfigKey(requiredAgentName);
-    const agentMatches = agentKey === requiredAgentKey || requiredAgentKey === getAgentConfigKey("atlas") && agentKey === getAgentConfigKey("sisyphus");
-    if (!agentMatches) {
-      log(`[${HOOK_NAME7}] Skipped: subagent agent does not match boulder agent`, {
-        sessionID,
-        agent: sessionAgent ?? "unknown",
-        requiredAgent: requiredAgentName
-      });
-      return;
-    }
+  const canContinueSession = await canContinueTrackedBoulderSession({
+    client: ctx.client,
+    sessionID,
+    sessionOrigin: boulderState.session_origins?.[sessionID],
+    boulderSessionIDs: boulderState.session_ids,
+    requiredAgent: boulderState.agent
+  });
+  if (!canContinueSession) {
+    log(`[${HOOK_NAME7}] Skipped: tracked descendant agent does not match boulder agent`, {
+      sessionID,
+      requiredAgent: boulderState.agent ?? "atlas"
+    });
+    return;
   }
   const sessionState = getState(sessionID);
   const now = Date.now();
@@ -95992,6 +96187,7 @@ async function handleAtlasSessionIdle(input) {
     sessionState.lastFailureAt = undefined;
   }
   if (hasRunningBackgroundTasks(sessionID, options)) {
+    scheduleRetry({ ctx, sessionID, sessionState, options });
     log(`[${HOOK_NAME7}] Skipped: background tasks running`, { sessionID });
     return;
   }
@@ -96019,6 +96215,30 @@ async function handleAtlasSessionIdle(input) {
     worktreePath: boulderState.worktree_path
   });
 }
+async function canContinueTrackedBoulderSession(input) {
+  const ancestorSessionIDs = input.boulderSessionIDs.filter((trackedSessionID) => trackedSessionID !== input.sessionID);
+  if (ancestorSessionIDs.length === 0) {
+    return true;
+  }
+  const isTrackedDescendant = await isSessionInBoulderLineage({
+    client: input.client,
+    sessionID: input.sessionID,
+    boulderSessionIDs: ancestorSessionIDs
+  });
+  if (input.sessionOrigin === "direct") {
+    return true;
+  }
+  if (!isTrackedDescendant) {
+    return false;
+  }
+  const sessionAgent = await getLastAgentFromSession(input.sessionID, input.client) ?? getSessionAgent(input.sessionID);
+  if (!sessionAgent) {
+    return false;
+  }
+  const requiredAgentKey = getAgentConfigKey(input.requiredAgent ?? "atlas");
+  const sessionAgentKey = getAgentConfigKey(sessionAgent);
+  return sessionAgentKey === requiredAgentKey || requiredAgentKey === getAgentConfigKey("atlas") && sessionAgentKey === getAgentConfigKey("sisyphus");
+}
 
 // src/hooks/atlas/event-handler.ts
 function createAtlasEventHandler(input) {
@@ -96108,8 +96328,141 @@ function createAtlasEventHandler(input) {
 // src/hooks/atlas/tool-execute-after.ts
 init_logger();
 
+// src/hooks/atlas/background-launch-session-tracking.ts
+init_logger();
+
+// src/hooks/atlas/subagent-session-id.ts
+init_logger();
+function extractSessionIdFromMetadata(metadata) {
+  if (metadata && typeof metadata === "object" && "sessionId" in metadata) {
+    const value = metadata.sessionId;
+    if (typeof value === "string" && value.startsWith("ses_")) {
+      return value;
+    }
+  }
+  return;
+}
+function extractSessionIdFromOutput(output) {
+  const taskMetadataBlocks = [...output.matchAll(/<task_metadata>([\s\S]*?)<\/task_metadata>/gi)];
+  const lastTaskMetadataBlock = taskMetadataBlocks.at(-1)?.[1];
+  if (lastTaskMetadataBlock) {
+    const taskMetadataSessionMatch = lastTaskMetadataBlock.match(/session_id:\s*(ses_[a-zA-Z0-9_-]+)/i);
+    if (taskMetadataSessionMatch) {
+      return taskMetadataSessionMatch[1];
+    }
+  }
+  const explicitSessionMatches = [...output.matchAll(/Session ID:\s*(ses_[a-zA-Z0-9_-]+)/g)];
+  return explicitSessionMatches.at(-1)?.[1];
+}
+async function validateSubagentSessionId(input) {
+  if (!input.sessionID || input.lineageSessionIDs.length === 0) {
+    return;
+  }
+  const belongsToLineage = await isSessionInBoulderLineage({
+    client: input.client,
+    sessionID: input.sessionID,
+    boulderSessionIDs: input.lineageSessionIDs
+  });
+  if (!belongsToLineage) {
+    log(`[${HOOK_NAME7}] Ignoring extracted session id outside active lineage`, {
+      sessionID: input.sessionID,
+      lineageSessionIDs: input.lineageSessionIDs
+    });
+    return;
+  }
+  return input.sessionID;
+}
+
+// src/hooks/atlas/task-context.ts
+function resolvePreferredSessionId(currentSessionId, trackedSessionId) {
+  return currentSessionId ?? trackedSessionId ?? "<session_id>";
+}
+function resolveTaskContext(pendingTaskRef, planPath) {
+  if (!pendingTaskRef) {
+    return {
+      currentTask: readCurrentTopLevelTask(planPath),
+      shouldSkipTaskSessionUpdate: false,
+      shouldIgnoreCurrentSessionId: false
+    };
+  }
+  if (pendingTaskRef.kind === "track") {
+    return {
+      currentTask: pendingTaskRef.task,
+      shouldSkipTaskSessionUpdate: false,
+      shouldIgnoreCurrentSessionId: false
+    };
+  }
+  if (pendingTaskRef.reason === "explicit_resume") {
+    return {
+      currentTask: readCurrentTopLevelTask(planPath),
+      shouldSkipTaskSessionUpdate: true,
+      shouldIgnoreCurrentSessionId: true
+    };
+  }
+  return {
+    currentTask: pendingTaskRef.task,
+    shouldSkipTaskSessionUpdate: true,
+    shouldIgnoreCurrentSessionId: true
+  };
+}
+
+// src/hooks/atlas/background-launch-session-tracking.ts
+async function syncBackgroundLaunchSessionTracking(input) {
+  const { ctx, boulderState, toolInput, toolOutput, pendingTaskRef, metadataSessionId } = input;
+  if (!boulderState) {
+    return;
+  }
+  const extractedSessionId = metadataSessionId ?? extractSessionIdFromOutput(toolOutput.output);
+  const lineageSessionIDs = boulderState.session_ids;
+  const subagentSessionId = await validateSubagentSessionId({
+    client: ctx.client,
+    sessionID: extractedSessionId,
+    lineageSessionIDs
+  });
+  const trackedSessionId = subagentSessionId ?? await resolveFallbackTrackedSessionId({
+    ctx,
+    extractedSessionId,
+    lineageSessionIDs
+  });
+  if (!trackedSessionId) {
+    return;
+  }
+  appendSessionId(ctx.directory, trackedSessionId, "appended");
+  const { currentTask, shouldSkipTaskSessionUpdate } = resolveTaskContext(pendingTaskRef, boulderState.active_plan);
+  if (currentTask && !shouldSkipTaskSessionUpdate) {
+    upsertTaskSessionState(ctx.directory, {
+      taskKey: currentTask.key,
+      taskLabel: currentTask.label,
+      taskTitle: currentTask.title,
+      sessionId: trackedSessionId,
+      agent: typeof toolOutput.metadata?.agent === "string" ? toolOutput.metadata.agent : undefined,
+      category: typeof toolOutput.metadata?.category === "string" ? toolOutput.metadata.category : undefined
+    });
+  }
+  log(`[${HOOK_NAME7}] Background launch session tracked`, {
+    sessionID: toolInput.sessionID,
+    subagentSessionId: trackedSessionId,
+    taskKey: currentTask?.key
+  });
+}
+async function resolveFallbackTrackedSessionId(input) {
+  if (!input.extractedSessionId) {
+    return;
+  }
+  try {
+    const session = await input.ctx.client.session.get({ path: { id: input.extractedSessionId } });
+    const parentSessionId = session.data?.parentID;
+    if (typeof parentSessionId === "string" && input.lineageSessionIDs.includes(parentSessionId)) {
+      return input.extractedSessionId;
+    }
+    return;
+  } catch {
+    return;
+  }
+}
+
 // src/hooks/atlas/final-wave-plan-state.ts
-import { existsSync as existsSync61, readFileSync as readFileSync44 } from "fs";
+import { existsSync as existsSync61, readFileSync as readFileSync45 } from "fs";
 var TODO_HEADING_PATTERN2 = /^##\s+TODOs\b/i;
 var FINAL_VERIFICATION_HEADING_PATTERN2 = /^##\s+Final Verification Wave\b/i;
 var SECOND_LEVEL_HEADING_PATTERN2 = /^##\s+/;
@@ -96121,7 +96474,7 @@ function readFinalWavePlanState(planPath) {
     return null;
   }
   try {
-    const content = readFileSync44(planPath, "utf-8");
+    const content = readFileSync45(planPath, "utf-8");
     const lines = content.split(/\r?\n/);
     let section = "other";
     let pendingImplementationTaskCount = 0;
@@ -96190,48 +96543,6 @@ function isSisyphusPath(filePath) {
   return /\.sisyphus[/\\]/.test(filePath);
 }
 
-// src/hooks/atlas/subagent-session-id.ts
-init_logger();
-function extractSessionIdFromMetadata(metadata) {
-  if (metadata && typeof metadata === "object" && "sessionId" in metadata) {
-    const value = metadata.sessionId;
-    if (typeof value === "string" && value.startsWith("ses_")) {
-      return value;
-    }
-  }
-  return;
-}
-function extractSessionIdFromOutput(output) {
-  const taskMetadataBlocks = [...output.matchAll(/<task_metadata>([\s\S]*?)<\/task_metadata>/gi)];
-  const lastTaskMetadataBlock = taskMetadataBlocks.at(-1)?.[1];
-  if (lastTaskMetadataBlock) {
-    const taskMetadataSessionMatch = lastTaskMetadataBlock.match(/session_id:\s*(ses_[a-zA-Z0-9_-]+)/i);
-    if (taskMetadataSessionMatch) {
-      return taskMetadataSessionMatch[1];
-    }
-  }
-  const explicitSessionMatches = [...output.matchAll(/Session ID:\s*(ses_[a-zA-Z0-9_-]+)/g)];
-  return explicitSessionMatches.at(-1)?.[1];
-}
-async function validateSubagentSessionId(input) {
-  if (!input.sessionID || input.lineageSessionIDs.length === 0) {
-    return;
-  }
-  const belongsToLineage = await isSessionInBoulderLineage({
-    client: input.client,
-    sessionID: input.sessionID,
-    boulderSessionIDs: input.lineageSessionIDs
-  });
-  if (!belongsToLineage) {
-    log(`[${HOOK_NAME7}] Ignoring extracted session id outside active lineage`, {
-      sessionID: input.sessionID,
-      lineageSessionIDs: input.lineageSessionIDs
-    });
-    return;
-  }
-  return input.sessionID;
-}
-
 // src/hooks/atlas/verification-reminders.ts
 function buildReuseHint(sessionId) {
   return `
@@ -96412,37 +96723,6 @@ function isWriteOrEditToolName(toolName) {
 }
 
 // src/hooks/atlas/tool-execute-after.ts
-function resolvePreferredSessionId(currentSessionId, trackedSessionId) {
-  return currentSessionId ?? trackedSessionId ?? "<session_id>";
-}
-function resolveTaskContext(pendingTaskRef, planPath) {
-  if (!pendingTaskRef) {
-    return {
-      currentTask: readCurrentTopLevelTask(planPath),
-      shouldSkipTaskSessionUpdate: false,
-      shouldIgnoreCurrentSessionId: false
-    };
-  }
-  if (pendingTaskRef.kind === "track") {
-    return {
-      currentTask: pendingTaskRef.task,
-      shouldSkipTaskSessionUpdate: false,
-      shouldIgnoreCurrentSessionId: false
-    };
-  }
-  if (pendingTaskRef.reason === "explicit_resume") {
-    return {
-      currentTask: readCurrentTopLevelTask(planPath),
-      shouldSkipTaskSessionUpdate: true,
-      shouldIgnoreCurrentSessionId: true
-    };
-  }
-  return {
-    currentTask: pendingTaskRef.task,
-    shouldSkipTaskSessionUpdate: true,
-    shouldIgnoreCurrentSessionId: true
-  };
-}
 function createToolExecuteAfterHandler2(input) {
   const { ctx, pendingFilePaths, pendingTaskRefs, autoCommit, getState } = input;
   return async (toolInput, toolOutput) => {
@@ -96480,12 +96760,20 @@ function createToolExecuteAfterHandler2(input) {
     if (toolInput.callID) {
       pendingTaskRefs.delete(toolInput.callID);
     }
+    const boulderState = readBoulderState(ctx.directory);
     const isBackgroundLaunch = outputStr.includes("Background task launched") || outputStr.includes("Background task continued") || outputStr.includes("Background delegate launched") || outputStr.includes("Background agent task launched");
     if (isBackgroundLaunch) {
+      await syncBackgroundLaunchSessionTracking({
+        ctx,
+        boulderState,
+        toolInput,
+        toolOutput,
+        pendingTaskRef,
+        metadataSessionId
+      });
       return;
     }
     if (toolOutput.output && typeof toolOutput.output === "string") {
-      const boulderState = readBoulderState(ctx.directory);
       const worktreePath = boulderState?.worktree_path?.trim();
       const verificationDirectory = worktreePath ? worktreePath : ctx.directory;
       const gitStats = collectGitDiffStats(verificationDirectory);
@@ -96500,14 +96788,7 @@ function createToolExecuteAfterHandler2(input) {
         } = resolveTaskContext(pendingTaskRef, boulderState.active_plan);
         const trackedTaskSession = currentTask ? getTaskSessionState(ctx.directory, currentTask.key) : null;
         const sessionState = toolInput.sessionID ? getState(toolInput.sessionID) : undefined;
-        if (toolInput.sessionID && !boulderState.session_ids?.includes(toolInput.sessionID)) {
-          appendSessionId(ctx.directory, toolInput.sessionID);
-          log(`[${HOOK_NAME7}] Appended session to boulder`, {
-            sessionID: toolInput.sessionID,
-            plan: boulderState.plan_name
-          });
-        }
-        const lineageSessionIDs = toolInput.sessionID && !boulderState.session_ids.includes(toolInput.sessionID) ? [...boulderState.session_ids, toolInput.sessionID] : boulderState.session_ids;
+        const lineageSessionIDs = boulderState.session_ids;
         const subagentSessionId = await validateSubagentSessionId({
           client: ctx.client,
           sessionID: extractedSessionId,
@@ -97000,7 +97281,7 @@ function clearSessionModel(sessionID) {
 }
 
 // src/hooks/compaction-context-injector/session-id.ts
-function isCompactionAgent2(agent) {
+function isCompactionAgent3(agent) {
   return agent?.trim().toLowerCase() === "compaction";
 }
 function resolveSessionID(props) {
@@ -97009,7 +97290,7 @@ function resolveSessionID(props) {
 
 // src/hooks/compaction-context-injector/validated-model.ts
 function resolveValidatedModel(info) {
-  if (isCompactionAgent2(info?.agent)) {
+  if (isCompactionAgent3(info?.agent)) {
     return;
   }
   const providerID = info?.model?.providerID ?? info?.providerID;
@@ -97043,7 +97324,7 @@ async function resolveSessionPromptConfig(ctx, sessionID) {
     });
     for (let index = messages.length - 1;index >= 0; index--) {
       const info = messages[index].info;
-      if (!promptConfig.agent && info?.agent && !isCompactionAgent2(info.agent)) {
+      if (!promptConfig.agent && info?.agent && !isCompactionAgent3(info.agent)) {
         promptConfig.agent = info.agent;
       }
       if (!promptConfig.model) {
@@ -97134,7 +97415,7 @@ function trackAssistantOutput(state3, messageID) {
 init_logger();
 
 // src/hooks/compaction-context-injector/recovery-prompt-config.ts
-function isCompactionAgent3(agent) {
+function isCompactionAgent4(agent) {
   return agent?.trim().toLowerCase() === "compaction";
 }
 function matchesExpectedModel(actualModel, expectedModel) {
@@ -97167,7 +97448,7 @@ function createExpectedRecoveryPromptConfig(checkpoint, currentPromptConfig) {
 }
 function isPromptConfigRecovered(actualPromptConfig, expectedPromptConfig) {
   const actualAgent = actualPromptConfig.agent;
-  const agentMatches = typeof actualAgent === "string" && !isCompactionAgent3(actualAgent) && actualAgent.toLowerCase() === expectedPromptConfig.agent.toLowerCase();
+  const agentMatches = typeof actualAgent === "string" && !isCompactionAgent4(actualAgent) && actualAgent.toLowerCase() === expectedPromptConfig.agent.toLowerCase();
   return agentMatches && matchesExpectedModel(actualPromptConfig.model, expectedPromptConfig.model) && matchesExpectedTools(actualPromptConfig.tools, expectedPromptConfig.tools);
 }
 
@@ -98121,12 +98402,12 @@ import * as fs18 from "fs";
 import * as path11 from "path";
 // src/shared/migrate-legacy-config-file.ts
 init_logger();
-import { existsSync as existsSync62, readFileSync as readFileSync45, renameSync as renameSync4, rmSync as rmSync3 } from "fs";
-import { join as join68, dirname as dirname20, basename as basename9 } from "path";
+import { existsSync as existsSync62, readFileSync as readFileSync46, renameSync as renameSync4, rmSync as rmSync3 } from "fs";
+import { join as join69, dirname as dirname20, basename as basename9 } from "path";
 function buildCanonicalPath(legacyPath) {
   const dir = dirname20(legacyPath);
   const ext = basename9(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
-  return join68(dir, `${CONFIG_BASENAME}${ext}`);
+  return join69(dir, `${CONFIG_BASENAME}${ext}`);
 }
 function archiveLegacyConfigFile(legacyPath) {
   const backupPath = `${legacyPath}.bak`;
@@ -98166,7 +98447,7 @@ function migrateLegacyConfigFile(legacyPath) {
   if (existsSync62(canonicalPath))
     return false;
   try {
-    const content = readFileSync45(legacyPath, "utf-8");
+    const content = readFileSync46(legacyPath, "utf-8");
     writeFileAtomically(canonicalPath, content);
     const archivedLegacyConfig = archiveLegacyConfigFile(legacyPath);
     log("[migrateLegacyConfigFile] Migrated legacy config to canonical path", {
@@ -98309,7 +98590,7 @@ function mergeConfigs(base, override) {
 function loadPluginConfig(directory, ctx) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   const userDetected = detectPluginConfigFile(configDir);
-  let userConfigPath = userDetected.format !== "none" ? userDetected.path : path11.join(configDir, "oh-my-opencode.json");
+  let userConfigPath = userDetected.format !== "none" ? userDetected.path : path11.join(configDir, `${CONFIG_BASENAME}.json`);
   if (userDetected.legacyPath) {
     log("Canonical plugin config detected alongside legacy config. Remove the legacy file to avoid confusion.", {
       canonicalPath: userDetected.path,
@@ -98317,12 +98598,15 @@ function loadPluginConfig(directory, ctx) {
     });
   }
   if (userDetected.format !== "none" && path11.basename(userDetected.path).startsWith(LEGACY_CONFIG_BASENAME)) {
-    migrateLegacyConfigFile(userDetected.path);
-    userConfigPath = path11.join(path11.dirname(userDetected.path), `${CONFIG_BASENAME}${path11.extname(userDetected.path)}`);
+    const migrated = migrateLegacyConfigFile(userDetected.path);
+    const canonicalPath = path11.join(path11.dirname(userDetected.path), `${CONFIG_BASENAME}${path11.extname(userDetected.path)}`);
+    if (migrated || fs18.existsSync(canonicalPath)) {
+      userConfigPath = canonicalPath;
+    }
   }
   const projectBasePath = path11.join(directory, ".opencode");
   const projectDetected = detectPluginConfigFile(projectBasePath);
-  let projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : path11.join(projectBasePath, "oh-my-opencode.json");
+  let projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : path11.join(projectBasePath, `${CONFIG_BASENAME}.json`);
   if (projectDetected.legacyPath) {
     log("Canonical plugin config detected alongside legacy config. Remove the legacy file to avoid confusion.", {
       canonicalPath: projectDetected.path,
@@ -98330,8 +98614,11 @@ function loadPluginConfig(directory, ctx) {
     });
   }
   if (projectDetected.format !== "none" && path11.basename(projectDetected.path).startsWith(LEGACY_CONFIG_BASENAME)) {
-    migrateLegacyConfigFile(projectDetected.path);
-    projectConfigPath = path11.join(path11.dirname(projectDetected.path), `${CONFIG_BASENAME}${path11.extname(projectDetected.path)}`);
+    const projectMigrated = migrateLegacyConfigFile(projectDetected.path);
+    const canonicalProjectPath = path11.join(path11.dirname(projectDetected.path), `${CONFIG_BASENAME}${path11.extname(projectDetected.path)}`);
+    if (projectMigrated || fs18.existsSync(canonicalProjectPath)) {
+      projectConfigPath = canonicalProjectPath;
+    }
   }
   const userConfig = loadConfigFromPath2(userConfigPath, ctx);
   let config2 = userConfig ?? OhMyOpenCodeConfigSchema.parse({});
@@ -99643,7 +99930,7 @@ function createRuntimeFallbackHook(ctx, options) {
 }
 // src/hooks/write-existing-file-guard/hook.ts
 import { existsSync as existsSync65, realpathSync as realpathSync7 } from "fs";
-import { basename as basename11, dirname as dirname22, isAbsolute as isAbsolute10, join as join70, normalize as normalize2, relative as relative8, resolve as resolve12 } from "path";
+import { basename as basename11, dirname as dirname22, isAbsolute as isAbsolute10, join as join71, normalize as normalize2, relative as relative8, resolve as resolve12 } from "path";
 
 // src/hooks/write-existing-file-guard/tool-execute-before-handler.ts
 import { existsSync as existsSync64 } from "fs";
@@ -99818,7 +100105,7 @@ function toCanonicalPath2(absolutePath) {
   } else {
     const absoluteDir = dirname22(absolutePath);
     const resolvedDir = existsSync65(absoluteDir) ? realpathSync7.native(absoluteDir) : absoluteDir;
-    canonicalPath = join70(resolvedDir, basename11(absolutePath));
+    canonicalPath = join71(resolvedDir, basename11(absolutePath));
   }
   return normalize2(canonicalPath);
 }
@@ -100833,12 +101120,12 @@ function createWebFetchRedirectGuardHook(_ctx) {
 init_logger();
 
 // src/hooks/legacy-plugin-toast/auto-migrate.ts
-import { existsSync as existsSync66, readFileSync as readFileSync47 } from "fs";
-import { join as join71 } from "path";
+import { existsSync as existsSync66, readFileSync as readFileSync48 } from "fs";
+import { join as join72 } from "path";
 function detectOpenCodeConfigPath(overrideConfigDir) {
   if (overrideConfigDir) {
-    const jsoncPath = join71(overrideConfigDir, "opencode.jsonc");
-    const jsonPath = join71(overrideConfigDir, "opencode.json");
+    const jsoncPath = join72(overrideConfigDir, "opencode.jsonc");
+    const jsonPath = join72(overrideConfigDir, "opencode.json");
     if (existsSync66(jsoncPath))
       return jsoncPath;
     if (existsSync66(jsonPath))
@@ -100857,7 +101144,7 @@ function autoMigrateLegacyPluginEntry(overrideConfigDir) {
   if (!configPath)
     return { migrated: false, from: null, to: null, configPath: null };
   try {
-    const content = readFileSync47(configPath, "utf-8");
+    const content = readFileSync48(configPath, "utf-8");
     const parseResult = parseJsoncSafe(content);
     if (!parseResult.data?.plugin)
       return { migrated: false, from: null, to: null, configPath };
@@ -101251,13 +101538,13 @@ var DEFAULT_MAX_SYMBOLS = 200;
 var DEFAULT_MAX_DIAGNOSTICS = 200;
 var DEFAULT_MAX_DIRECTORY_FILES = 50;
 // src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync67, readFileSync as readFileSync48 } from "fs";
-import { join as join72 } from "path";
+import { existsSync as existsSync67, readFileSync as readFileSync49 } from "fs";
+import { join as join73 } from "path";
 function loadJsonFile(path12) {
   if (!existsSync67(path12))
     return null;
   try {
-    return parseJsonc(readFileSync48(path12, "utf-8"));
+    return parseJsonc(readFileSync49(path12, "utf-8"));
   } catch {
     return null;
   }
@@ -101266,9 +101553,9 @@ function getConfigPaths3() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectPluginConfigFile(join72(cwd, ".opencode")).path,
+    project: detectPluginConfigFile(join73(cwd, ".opencode")).path,
     user: detectPluginConfigFile(configDir).path,
-    opencode: detectConfigFile(join72(configDir, "opencode")).path
+    opencode: detectConfigFile(join73(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -101338,19 +101625,19 @@ function getMergedServers() {
 
 // src/tools/lsp/server-installation.ts
 import { existsSync as existsSync68 } from "fs";
-import { delimiter, join as join74 } from "path";
+import { delimiter, join as join75 } from "path";
 
 // src/tools/lsp/server-path-bases.ts
-import { join as join73 } from "path";
+import { join as join74 } from "path";
 function getLspServerAdditionalPathBases(workingDirectory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join73(getDataDir(), "opencode");
+  const dataDir = join74(getDataDir(), "opencode");
   return [
-    join73(workingDirectory, "node_modules", ".bin"),
-    join73(configDir, "bin"),
-    join73(configDir, "node_modules", ".bin"),
-    join73(dataDir, "bin"),
-    join73(dataDir, "bin", "node_modules", ".bin")
+    join74(workingDirectory, "node_modules", ".bin"),
+    join74(configDir, "bin"),
+    join74(configDir, "node_modules", ".bin"),
+    join74(dataDir, "bin"),
+    join74(dataDir, "bin", "node_modules", ".bin")
   ];
 }
 
@@ -101381,14 +101668,14 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(delimiter);
   for (const p of paths) {
     for (const suffix of exts) {
-      if (existsSync68(join74(p, cmd + suffix))) {
+      if (existsSync68(join75(p, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync68(join74(base, cmd + suffix))) {
+      if (existsSync68(join75(base, cmd + suffix))) {
         return true;
       }
     }
@@ -101584,7 +101871,7 @@ function spawnProcess(command, options) {
   return proc;
 }
 // src/tools/lsp/lsp-client.ts
-import { readFileSync as readFileSync49 } from "fs";
+import { readFileSync as readFileSync50 } from "fs";
 import { extname as extname4, resolve as resolve13 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
@@ -101856,7 +102143,7 @@ class LSPClient extends LSPClientConnection {
   async openFile(filePath) {
     const absPath = resolve13(filePath);
     const uri = pathToFileURL2(absPath).href;
-    const text = readFileSync49(absPath, "utf-8");
+    const text = readFileSync50(absPath, "utf-8");
     if (!this.openedFiles.has(absPath)) {
       const ext = extname4(absPath);
       const languageId = getLanguageId(ext);
@@ -102408,10 +102695,10 @@ function formatApplyResult(result) {
 `);
 }
 // src/tools/lsp/workspace-edit.ts
-import { readFileSync as readFileSync50, writeFileSync as writeFileSync19 } from "fs";
+import { readFileSync as readFileSync51, writeFileSync as writeFileSync19 } from "fs";
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync50(filePath, "utf-8");
+    let content = readFileSync51(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -102477,7 +102764,7 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = uriToPath(change.oldUri);
             const newPath = uriToPath(change.newUri);
-            const content = readFileSync50(oldPath, "utf-8");
+            const content = readFileSync51(oldPath, "utf-8");
             writeFileSync19(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
@@ -114960,8 +115247,8 @@ var lsp_symbols = tool({
 import { resolve as resolve16 } from "path";
 
 // src/tools/lsp/directory-diagnostics.ts
-import { existsSync as existsSync71, lstatSync as lstatSync2, readdirSync as readdirSync17 } from "fs";
-import { extname as extname6, join as join75, resolve as resolve15 } from "path";
+import { existsSync as existsSync71, lstatSync as lstatSync2, readdirSync as readdirSync18 } from "fs";
+import { extname as extname6, join as join76, resolve as resolve15 } from "path";
 var SKIP_DIRECTORIES = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
 function collectFilesWithExtension(dir, extension, maxFiles) {
   const files = [];
@@ -114970,14 +115257,14 @@ function collectFilesWithExtension(dir, extension, maxFiles) {
       return;
     let entries = [];
     try {
-      entries = readdirSync17(currentDir);
+      entries = readdirSync18(currentDir);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (files.length >= maxFiles)
         return;
-      const fullPath = join75(currentDir, entry);
+      const fullPath = join76(currentDir, entry);
       let stat;
       try {
         stat = lstatSync2(fullPath);
@@ -115079,8 +115366,8 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
 }
 
 // src/tools/lsp/infer-extension.ts
-import { readdirSync as readdirSync18, lstatSync as lstatSync3 } from "fs";
-import { extname as extname7, join as join76 } from "path";
+import { readdirSync as readdirSync19, lstatSync as lstatSync3 } from "fs";
+import { extname as extname7, join as join77 } from "path";
 var SKIP_DIRECTORIES2 = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
 var MAX_SCAN_ENTRIES = 500;
 function inferExtensionFromDirectory(directory) {
@@ -115091,14 +115378,14 @@ function inferExtensionFromDirectory(directory) {
       return;
     let entries;
     try {
-      entries = readdirSync18(dir);
+      entries = readdirSync19(dir);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (scanned >= MAX_SCAN_ENTRIES)
         return;
-      const fullPath = join76(dir, entry);
+      const fullPath = join77(dir, entry);
       let stat;
       try {
         stat = lstatSync3(fullPath);
@@ -115263,12 +115550,12 @@ var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/sg-cli-path.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname23, join as join78 } from "path";
+import { dirname as dirname23, join as join79 } from "path";
 import { existsSync as existsSync73, statSync as statSync10 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 import { existsSync as existsSync72 } from "fs";
-import { join as join77 } from "path";
+import { join as join78 } from "path";
 import { homedir as homedir14 } from "os";
 import { createRequire as createRequire3 } from "module";
 init_logger();
@@ -115295,12 +115582,12 @@ var PLATFORM_MAP2 = {
 function getCacheDir3() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join77(homedir14(), "AppData", "Local");
-    return join77(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join78(homedir14(), "AppData", "Local");
+    return join78(base2, "oh-my-opencode", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join77(homedir14(), ".cache");
-  return join77(base, "oh-my-opencode", "bin");
+  const base = xdgCache || join78(homedir14(), ".cache");
+  return join78(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
@@ -115317,7 +115604,7 @@ async function downloadAstGrep(version3 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
-  const binaryPath = join77(cacheDir, binaryName);
+  const binaryPath = join78(cacheDir, binaryName);
   if (existsSync72(binaryPath)) {
     return binaryPath;
   }
@@ -115326,7 +115613,7 @@ async function downloadAstGrep(version3 = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version3}/${assetName}`;
   log(`[oh-my-opencode] Downloading ast-grep binary...`);
   try {
-    const archivePath = join77(cacheDir, assetName);
+    const archivePath = join78(cacheDir, assetName);
     ensureCacheDir(cacheDir);
     await downloadArchive(downloadUrl, archivePath);
     await extractZipArchive(archivePath, cacheDir);
@@ -115380,7 +115667,7 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPackageJsonPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDirectory = dirname23(cliPackageJsonPath);
-    const sgPath = join78(cliDirectory, binaryName);
+    const sgPath = join79(cliDirectory, binaryName);
     if (existsSync73(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
@@ -115392,7 +115679,7 @@ function findSgCliPathSync() {
       const packageJsonPath = require2.resolve(`${platformPackage}/package.json`);
       const packageDirectory = dirname23(packageJsonPath);
       const astGrepBinaryName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join78(packageDirectory, astGrepBinaryName);
+      const binaryPath = join79(packageDirectory, astGrepBinaryName);
       if (existsSync73(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
@@ -115794,18 +116081,18 @@ var {spawn: spawn18 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
 import { existsSync as existsSync77 } from "fs";
-import { join as join80, dirname as dirname24 } from "path";
+import { join as join81, dirname as dirname24 } from "path";
 import { spawnSync as spawnSync4 } from "child_process";
 
 // src/tools/grep/downloader.ts
-import { existsSync as existsSync76, readdirSync as readdirSync19 } from "fs";
-import { join as join79 } from "path";
+import { existsSync as existsSync76, readdirSync as readdirSync20 } from "fs";
+import { join as join80 } from "path";
 function findFileRecursive(dir, filename) {
   try {
-    const entries = readdirSync19(dir, { withFileTypes: true, recursive: true });
+    const entries = readdirSync20(dir, { withFileTypes: true, recursive: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name === filename) {
-        return join79(entry.parentPath ?? dir, entry.name);
+        return join80(entry.parentPath ?? dir, entry.name);
       }
     }
   } catch {
@@ -115826,11 +116113,11 @@ function getPlatformKey() {
 }
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join79(homeDir, ".cache", "oh-my-opencode", "bin");
+  return join80(homeDir, ".cache", "oh-my-opencode", "bin");
 }
 function getRgPath() {
   const isWindows2 = process.platform === "win32";
-  return join79(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
+  return join80(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
 async function extractTarGz2(archivePath, destDir) {
   const platformKey = getPlatformKey();
@@ -115847,7 +116134,7 @@ async function extractZip2(archivePath, destDir) {
   const binaryName = process.platform === "win32" ? "rg.exe" : "rg";
   const foundPath = findFileRecursive(destDir, binaryName);
   if (foundPath) {
-    const destPath = join79(destDir, binaryName);
+    const destPath = join80(destDir, binaryName);
     if (foundPath !== destPath) {
       const { renameSync: renameSync5 } = await import("fs");
       renameSync5(foundPath, destPath);
@@ -115868,7 +116155,7 @@ async function downloadAndInstallRipgrep() {
   ensureCacheDir(installDir);
   const filename = `ripgrep-${RG_VERSION}-${config4.platform}.${config4.extension}`;
   const url3 = `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/${filename}`;
-  const archivePath = join79(installDir, filename);
+  const archivePath = join80(installDir, filename);
   try {
     await downloadArchive(url3, archivePath);
     if (config4.extension === "tar.gz") {
@@ -115914,11 +116201,11 @@ function getOpenCodeBundledRg() {
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
-    join80(getDataDir(), "opencode", "bin", rgName),
-    join80(execDir, rgName),
-    join80(execDir, "bin", rgName),
-    join80(execDir, "..", "bin", rgName),
-    join80(execDir, "..", "libexec", rgName)
+    join81(getDataDir(), "opencode", "bin", rgName),
+    join81(execDir, rgName),
+    join81(execDir, "bin", rgName),
+    join81(execDir, "..", "bin", rgName),
+    join81(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
     if (existsSync77(candidate)) {
@@ -117030,9 +117317,9 @@ function createSkillTool(options = {}) {
 }
 var skill = createSkillTool();
 // src/tools/session-manager/constants.ts
-import { join as join81 } from "path";
-var TODO_DIR2 = join81(getClaudeConfigDir(), "todos");
-var TRANSCRIPT_DIR2 = join81(getClaudeConfigDir(), "transcripts");
+import { join as join82 } from "path";
+var TODO_DIR2 = join82(getClaudeConfigDir(), "todos");
+var TRANSCRIPT_DIR2 = join82(getClaudeConfigDir(), "transcripts");
 var SESSION_LIST_DESCRIPTION = `List all OpenCode sessions with optional filtering.
 
 Returns a list of available session IDs with metadata including message count, date range, and agents used.
@@ -117107,7 +117394,7 @@ Has Transcript: Yes (234 entries)`;
 // src/tools/session-manager/file-storage.ts
 import { existsSync as existsSync78 } from "fs";
 import { readdir, readFile } from "fs/promises";
-import { join as join82 } from "path";
+import { join as join83 } from "path";
 async function getFileMainSessions(directory) {
   if (!existsSync78(SESSION_STORAGE))
     return [];
@@ -117117,13 +117404,13 @@ async function getFileMainSessions(directory) {
     for (const projectDir of projectDirs) {
       if (!projectDir.isDirectory())
         continue;
-      const projectPath = join82(SESSION_STORAGE, projectDir.name);
+      const projectPath = join83(SESSION_STORAGE, projectDir.name);
       const sessionFiles = await readdir(projectPath);
       for (const file3 of sessionFiles) {
         if (!file3.endsWith(".json"))
           continue;
         try {
-          const content = await readFile(join82(projectPath, file3), "utf-8");
+          const content = await readFile(join83(projectPath, file3), "utf-8");
           const meta3 = JSON.parse(content);
           if (meta3.parentID)
             continue;
@@ -117150,7 +117437,7 @@ async function getFileAllSessions() {
       for (const entry of entries) {
         if (!entry.isDirectory())
           continue;
-        const sessionPath = join82(dir, entry.name);
+        const sessionPath = join83(dir, entry.name);
         const files = await readdir(sessionPath);
         if (files.some((file3) => file3.endsWith(".json"))) {
           sessions.push(entry.name);
@@ -117179,7 +117466,7 @@ async function getFileSessionMessages(sessionID) {
       if (!file3.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join82(messageDir, file3), "utf-8");
+        const content = await readFile(join83(messageDir, file3), "utf-8");
         const meta3 = JSON.parse(content);
         const parts = await readParts2(meta3.id);
         messages.push({
@@ -117205,7 +117492,7 @@ async function getFileSessionMessages(sessionID) {
   });
 }
 async function readParts2(messageID) {
-  const partDir = join82(PART_STORAGE, messageID);
+  const partDir = join83(PART_STORAGE, messageID);
   if (!existsSync78(partDir))
     return [];
   const parts = [];
@@ -117215,7 +117502,7 @@ async function readParts2(messageID) {
       if (!file3.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join82(partDir, file3), "utf-8");
+        const content = await readFile(join83(partDir, file3), "utf-8");
         parts.push(JSON.parse(content));
       } catch {
         continue;
@@ -117234,7 +117521,7 @@ async function getFileSessionTodos(sessionID) {
     const todoFiles = allFiles.filter((file3) => file3 === `${sessionID}.json`);
     for (const file3 of todoFiles) {
       try {
-        const content = await readFile(join82(TODO_DIR2, file3), "utf-8");
+        const content = await readFile(join83(TODO_DIR2, file3), "utf-8");
         const data = JSON.parse(content);
         if (!Array.isArray(data))
           continue;
@@ -117256,7 +117543,7 @@ async function getFileSessionTodos(sessionID) {
 async function getFileSessionTranscript(sessionID) {
   if (!existsSync78(TRANSCRIPT_DIR2))
     return 0;
-  const transcriptFile = join82(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
+  const transcriptFile = join83(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
   if (!existsSync78(transcriptFile))
     return 0;
   try {
@@ -117509,7 +117796,48 @@ async function readSessionTodos(sessionID) {
   }
   return getFileSessionTodos(sessionID);
 }
+async function readSessionTranscript(sessionID) {
+  return getFileSessionTranscript(sessionID);
+}
 async function getSessionInfo(sessionID) {
+  if (isSqliteBackend() && sdkClient) {
+    try {
+      const sdkMessages = await getSdkSessionMessages(sdkClient, sessionID);
+      if (sdkMessages.length > 0) {
+        const agentsUsed = new Set;
+        let firstMessage;
+        let lastMessage;
+        for (const msg of sdkMessages) {
+          if (msg.agent)
+            agentsUsed.add(msg.agent);
+          if (msg.time?.created) {
+            const date9 = new Date(msg.time.created);
+            if (!firstMessage || date9 < firstMessage)
+              firstMessage = date9;
+            if (!lastMessage || date9 > lastMessage)
+              lastMessage = date9;
+          }
+        }
+        const todos = await readSessionTodos(sessionID);
+        const transcriptEntries = await readSessionTranscript(sessionID);
+        return {
+          id: sessionID,
+          message_count: sdkMessages.length,
+          first_message: firstMessage,
+          last_message: lastMessage,
+          agents_used: Array.from(agentsUsed),
+          has_todos: todos.length > 0,
+          has_transcript: transcriptEntries > 0,
+          todos,
+          transcript_entries: transcriptEntries
+        };
+      }
+    } catch (error92) {
+      if (!shouldFallbackFromSdkError(error92))
+        throw error92;
+      log("[session-manager] falling back to file session info after SDK unavailable error", { error: String(error92), sessionID });
+    }
+  }
   return getFileSessionInfo(sessionID);
 }
 
@@ -119490,9 +119818,9 @@ async function resolveMultimodalLookerAgentMetadata(ctx) {
 
 // src/tools/look-at/image-converter.ts
 import * as childProcess from "child_process";
-import { existsSync as existsSync79, mkdtempSync, readFileSync as readFileSync51, rmSync as rmSync4, unlinkSync as unlinkSync11, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync79, mkdtempSync, readFileSync as readFileSync52, rmSync as rmSync4, unlinkSync as unlinkSync11, writeFileSync as writeFileSync20 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { dirname as dirname27, join as join83 } from "path";
+import { dirname as dirname27, join as join84 } from "path";
 var SUPPORTED_FORMATS = new Set([
   "image/jpeg",
   "image/png",
@@ -119533,8 +119861,8 @@ function convertImageToJpeg(inputPath, mimeType) {
   if (!existsSync79(inputPath)) {
     throw new Error(`File not found: ${inputPath}`);
   }
-  const tempDir = mkdtempSync(join83(tmpdir7(), "opencode-img-"));
-  const outputPath = join83(tempDir, "converted.jpg");
+  const tempDir = mkdtempSync(join84(tmpdir7(), "opencode-img-"));
+  const outputPath = join84(tempDir, "converted.jpg");
   log(`[image-converter] Converting ${mimeType} to JPEG: ${inputPath}`);
   try {
     if (process.platform === "darwin") {
@@ -119599,9 +119927,9 @@ function cleanupConvertedImage(filePath) {
   }
 }
 function convertBase64ImageToJpeg(base64Data, mimeType) {
-  const tempDir = mkdtempSync(join83(tmpdir7(), "opencode-b64-"));
+  const tempDir = mkdtempSync(join84(tmpdir7(), "opencode-b64-"));
   const inputExt = mimeType.split("/")[1] || "bin";
-  const inputPath = join83(tempDir, `input.${inputExt}`);
+  const inputPath = join84(tempDir, `input.${inputExt}`);
   const tempFiles = [inputPath];
   try {
     const cleanBase64 = base64Data.replace(/^data:[^;]+;base64,/, "");
@@ -119610,7 +119938,7 @@ function convertBase64ImageToJpeg(base64Data, mimeType) {
     log(`[image-converter] Converting Base64 ${mimeType} to JPEG`);
     const outputPath = convertImageToJpeg(inputPath, mimeType);
     tempFiles.push(outputPath);
-    const convertedBuffer = readFileSync51(outputPath);
+    const convertedBuffer = readFileSync52(outputPath);
     const convertedBase64 = convertedBuffer.toString("base64");
     log(`[image-converter] Base64 conversion successful`);
     return { base64: convertedBase64, tempFiles };
@@ -120062,6 +120390,11 @@ function formatDetailedError(error92, ctx) {
 `);
 }
 
+// src/tools/delegate-task/resolve-call-id.ts
+function resolveCallID(ctx) {
+  return ctx.callID ?? ctx.callId ?? ctx.call_id;
+}
+
 // src/tools/delegate-task/background-continuation.ts
 async function executeBackgroundContinuation(args, ctx, executorCtx, parentContext) {
   const { manager } = executorCtx;
@@ -120089,8 +120422,9 @@ async function executeBackgroundContinuation(args, ctx, executorCtx, parentConte
       }
     };
     await ctx.metadata?.(bgContMeta);
-    if (ctx.callID) {
-      storeToolMetadata(ctx.sessionID, ctx.callID, bgContMeta);
+    const callID = resolveCallID(ctx);
+    if (callID) {
+      storeToolMetadata(ctx.sessionID, callID, bgContMeta);
     }
     return `Background task continued.
 
@@ -120409,8 +120743,9 @@ async function executeSyncContinuation(args, ctx, executorCtx, deps = syncContin
       }
     };
     await ctx.metadata?.(syncContMeta);
-    if (ctx.callID) {
-      storeToolMetadata(ctx.sessionID, ctx.callID, syncContMeta);
+    const callID = resolveCallID(ctx);
+    if (callID) {
+      storeToolMetadata(ctx.sessionID, callID, syncContMeta);
     }
     const allowTask = isPlanFamily(resumeAgent);
     const tddEnabled = sisyphusAgentConfig?.tdd;
@@ -120554,8 +120889,9 @@ Task ID: ${task.id}`;
       }
     };
     await ctx.metadata?.(bgTaskMeta);
-    if (ctx.callID) {
-      storeToolMetadata(ctx.sessionID, ctx.callID, bgTaskMeta);
+    const callID = resolveCallID(ctx);
+    if (callID) {
+      storeToolMetadata(ctx.sessionID, callID, bgTaskMeta);
     }
     const startTime = new Date;
     const timingCfg = getTimingConfig();
@@ -120797,8 +121133,9 @@ Task ID: ${task.id}`;
       metadata
     };
     await ctx.metadata?.(unstableMeta);
-    if (ctx.callID) {
-      storeToolMetadata(ctx.sessionID, ctx.callID, unstableMeta);
+    const callID = resolveCallID(ctx);
+    if (callID) {
+      storeToolMetadata(ctx.sessionID, callID, unstableMeta);
     }
     const taskMetadataBlock = sessionId ? `
 
@@ -121026,8 +121363,9 @@ async function executeSyncTask(args, ctx, executorCtx, parentContext, agentToUse
       }
     };
     await ctx.metadata?.(syncTaskMeta);
-    if (ctx.callID) {
-      storeToolMetadata(ctx.sessionID, ctx.callID, syncTaskMeta);
+    const callID = resolveCallID(ctx);
+    if (callID) {
+      storeToolMetadata(ctx.sessionID, callID, syncTaskMeta);
     }
     const promptError = await deps.sendSyncPrompt(client2, {
       sessionID,
@@ -121505,7 +121843,7 @@ Available categories: ${categoryNames.join(", ")}`
     };
   }
   const resolvedModel = actualModel?.toLowerCase();
-  const isUnstableAgent = resolved.config.is_unstable_agent ?? (resolvedModel ? resolvedModel.includes("gemini") || resolvedModel.includes("minimax") || resolvedModel.includes("kimi") : false);
+  const isUnstableAgent = resolved.config.is_unstable_agent ?? (resolvedModel ? resolvedModel.includes("gemini") || resolvedModel.includes("minimax") : false);
   const defaultProviderID = categoryModel?.providerID ?? parseModelString(actualModel ?? "")?.providerID ?? "opencode";
   const configuredFallbackChain = buildFallbackChainFromModels(normalizedConfiguredFallbackModels, defaultProviderID);
   const effectiveEntry = matchedFallback && categoryModel ? fallbackEntry ?? (configuredFallbackChain ? findMostSpecificFallbackEntry(categoryModel.providerID, categoryModel.modelID, configuredFallbackChain) : undefined) : undefined;
@@ -121769,6 +122107,9 @@ function createDelegateTask(options) {
       await ctx.metadata?.({
         title: args.description
       });
+      if (!args.description || typeof args.description !== "string") {
+        throw new Error(`Invalid arguments: 'description' parameter is REQUIRED. Provide a short (3-5 words) task description.`);
+      }
       if (args.run_in_background === undefined) {
         throw new Error(`Invalid arguments: 'run_in_background' parameter is REQUIRED. Specify run_in_background=false for task delegation, or run_in_background=true for parallel exploration.`);
       }
@@ -121888,7 +122229,7 @@ function createDelegateTask(options) {
 // src/tools/delegate-task/index.ts
 init_constants();
 // src/tools/task/task-create.ts
-import { join as join85 } from "path";
+import { join as join86 } from "path";
 
 // src/tools/task/types.ts
 var TaskStatusSchema = exports_external.enum(["pending", "in_progress", "completed", "deleted"]);
@@ -121942,18 +122283,18 @@ var TaskDeleteInputSchema = exports_external.object({
 });
 
 // src/features/claude-tasks/storage.ts
-import { join as join84, dirname as dirname28, basename as basename13, isAbsolute as isAbsolute11 } from "path";
-import { existsSync as existsSync80, mkdirSync as mkdirSync16, readFileSync as readFileSync52, writeFileSync as writeFileSync21, renameSync as renameSync5, unlinkSync as unlinkSync12, readdirSync as readdirSync20 } from "fs";
+import { join as join85, dirname as dirname28, basename as basename13, isAbsolute as isAbsolute11 } from "path";
+import { existsSync as existsSync80, mkdirSync as mkdirSync16, readFileSync as readFileSync53, writeFileSync as writeFileSync21, renameSync as renameSync5, unlinkSync as unlinkSync12, readdirSync as readdirSync21 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
 function getTaskDir(config4 = {}) {
   const tasksConfig = config4.sisyphus?.tasks;
   const storagePath = tasksConfig?.storage_path;
   if (storagePath) {
-    return isAbsolute11(storagePath) ? storagePath : join84(process.cwd(), storagePath);
+    return isAbsolute11(storagePath) ? storagePath : join85(process.cwd(), storagePath);
   }
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   const listId = resolveTaskListId(config4);
-  return join84(configDir, "tasks", listId);
+  return join85(configDir, "tasks", listId);
 }
 function sanitizePathSegment(value) {
   return value.replace(/[^a-zA-Z0-9_-]/g, "-") || "default";
@@ -121980,7 +122321,7 @@ function readJsonSafe(filePath, schema2) {
     if (!existsSync80(filePath)) {
       return null;
     }
-    const content = readFileSync52(filePath, "utf-8");
+    const content = readFileSync53(filePath, "utf-8");
     const parsed = JSON.parse(content);
     const result = schema2.safeParse(parsed);
     if (!result.success) {
@@ -122012,7 +122353,7 @@ function generateTaskId() {
   return `T-${randomUUID3()}`;
 }
 function acquireLock(dirPath) {
-  const lockPath = join84(dirPath, ".lock");
+  const lockPath = join85(dirPath, ".lock");
   const lockId = randomUUID3();
   const createLock = (timestamp2) => {
     writeFileSync21(lockPath, JSON.stringify({ id: lockId, timestamp: timestamp2 }), {
@@ -122022,7 +122363,7 @@ function acquireLock(dirPath) {
   };
   const isStale = () => {
     try {
-      const lockContent = readFileSync52(lockPath, "utf-8");
+      const lockContent = readFileSync53(lockPath, "utf-8");
       const lockData = JSON.parse(lockContent);
       const lockAge = Date.now() - lockData.timestamp;
       return lockAge > STALE_LOCK_THRESHOLD_MS;
@@ -122062,7 +122403,7 @@ function acquireLock(dirPath) {
       try {
         if (!existsSync80(lockPath))
           return;
-        const lockContent = readFileSync52(lockPath, "utf-8");
+        const lockContent = readFileSync53(lockPath, "utf-8");
         const lockData = JSON.parse(lockContent);
         if (lockData.id !== lockId)
           return;
@@ -122225,7 +122566,7 @@ async function handleCreate(args, config4, ctx, context) {
         threadID: context.sessionID
       };
       const validatedTask = TaskObjectSchema.parse(task);
-      writeJsonAtomic(join85(taskDir, `${taskId}.json`), validatedTask);
+      writeJsonAtomic(join86(taskDir, `${taskId}.json`), validatedTask);
       await syncTaskTodoUpdate(ctx, validatedTask, context.sessionID);
       return JSON.stringify({
         task: {
@@ -122247,7 +122588,7 @@ async function handleCreate(args, config4, ctx, context) {
   }
 }
 // src/tools/task/task-get.ts
-import { join as join86 } from "path";
+import { join as join87 } from "path";
 var TASK_ID_PATTERN = /^T-[A-Za-z0-9-]+$/;
 function parseTaskId(id) {
   if (!TASK_ID_PATTERN.test(id))
@@ -122272,7 +122613,7 @@ Returns null if the task does not exist or the file is invalid.`,
           return JSON.stringify({ error: "invalid_task_id" });
         }
         const taskDir = getTaskDir(config4);
-        const taskPath = join86(taskDir, `${taskId}.json`);
+        const taskPath = join87(taskDir, `${taskId}.json`);
         const task = readJsonSafe(taskPath, TaskObjectSchema);
         return JSON.stringify({ task: task ?? null });
       } catch (error92) {
@@ -122285,8 +122626,8 @@ Returns null if the task does not exist or the file is invalid.`,
   });
 }
 // src/tools/task/task-list.ts
-import { join as join87 } from "path";
-import { existsSync as existsSync81, readdirSync as readdirSync21 } from "fs";
+import { join as join88 } from "path";
+import { existsSync as existsSync81, readdirSync as readdirSync22 } from "fs";
 function createTaskList(config4) {
   return tool({
     description: `List all active tasks with summary information.
@@ -122300,13 +122641,13 @@ Returns summary format: id, subject, status, owner, blockedBy (not full descript
       if (!existsSync81(taskDir)) {
         return JSON.stringify({ tasks: [] });
       }
-      const files = readdirSync21(taskDir).filter((f) => f.endsWith(".json") && f.startsWith("T-")).map((f) => f.replace(".json", ""));
+      const files = readdirSync22(taskDir).filter((f) => f.endsWith(".json") && f.startsWith("T-")).map((f) => f.replace(".json", ""));
       if (files.length === 0) {
         return JSON.stringify({ tasks: [] });
       }
       const allTasks = [];
       for (const fileId of files) {
-        const task = readJsonSafe(join87(taskDir, `${fileId}.json`), TaskObjectSchema);
+        const task = readJsonSafe(join88(taskDir, `${fileId}.json`), TaskObjectSchema);
         if (task) {
           allTasks.push(task);
         }
@@ -122334,7 +122675,7 @@ Returns summary format: id, subject, status, owner, blockedBy (not full descript
   });
 }
 // src/tools/task/task-update.ts
-import { join as join88 } from "path";
+import { join as join89 } from "path";
 var TASK_ID_PATTERN2 = /^T-[A-Za-z0-9-]+$/;
 function parseTaskId2(id) {
   if (!TASK_ID_PATTERN2.test(id))
@@ -122382,7 +122723,7 @@ async function handleUpdate(args, config4, ctx, context) {
       return JSON.stringify({ error: "task_lock_unavailable" });
     }
     try {
-      const taskPath = join88(taskDir, `${taskId}.json`);
+      const taskPath = join89(taskDir, `${taskId}.json`);
       const task = readJsonSafe(taskPath, TaskObjectSchema);
       if (!task) {
         return JSON.stringify({ error: "task_not_found" });
@@ -124046,6 +124387,9 @@ var builtinTools = {
 function isTmuxIntegrationEnabled(pluginConfig) {
   return pluginConfig.tmux?.enabled ?? false;
 }
+function isInteractiveBashEnabled(which = Bun.which) {
+  return which("tmux") !== null;
+}
 function createRuntimeTmuxConfig(pluginConfig) {
   return TmuxConfigSchema.parse(pluginConfig.tmux ?? {});
 }
@@ -124594,6 +124938,40 @@ function createHooks(args) {
     }
   };
 }
+// src/features/background-agent/constants.ts
+var TASK_TTL_MS = 30 * 60 * 1000;
+var TERMINAL_TASK_TTL_MS = 30 * 60 * 1000;
+var MIN_STABILITY_TIME_MS2 = 10 * 1000;
+var DEFAULT_STALE_TIMEOUT_MS = 2700000;
+var DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 3600000;
+var DEFAULT_MAX_TOOL_CALLS = 4000;
+var DEFAULT_CIRCUIT_BREAKER_CONSECUTIVE_THRESHOLD = 20;
+var DEFAULT_CIRCUIT_BREAKER_ENABLED = true;
+var MIN_RUNTIME_BEFORE_STALE_MS = 30000;
+var DEFAULT_SESSION_GONE_TIMEOUT_MS = 60000;
+var MIN_IDLE_TIME_MS = 5000;
+var POLLING_INTERVAL_MS = 3000;
+var TASK_CLEANUP_DELAY_MS = 10 * 60 * 1000;
+
+// src/features/background-agent/spawner.ts
+var FALLBACK_AGENT = "general";
+function isAgentNotFoundError(error92) {
+  const message = typeof error92 === "string" ? error92 : error92 instanceof Error ? error92.message : typeof error92 === "object" && error92 !== null && typeof error92.message === "string" ? error92.message : String(error92);
+  return message.includes("Agent not found") || message.includes("agent.name");
+}
+function buildFallbackBody(originalBody, fallbackAgent) {
+  return {
+    ...originalBody,
+    agent: fallbackAgent,
+    tools: {
+      task: false,
+      call_omo_agent: true,
+      question: false,
+      ...getAgentToolRestrictions(fallbackAgent)
+    }
+  };
+}
+
 // src/features/background-agent/task-history.ts
 var MAX_ENTRIES_PER_PARENT = 100;
 
@@ -124751,21 +125129,6 @@ class ConcurrencyManager {
   }
 }
 
-// src/features/background-agent/constants.ts
-var TASK_TTL_MS = 30 * 60 * 1000;
-var TERMINAL_TASK_TTL_MS = 30 * 60 * 1000;
-var MIN_STABILITY_TIME_MS2 = 10 * 1000;
-var DEFAULT_STALE_TIMEOUT_MS = 2700000;
-var DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 3600000;
-var DEFAULT_MAX_TOOL_CALLS = 4000;
-var DEFAULT_CIRCUIT_BREAKER_CONSECUTIVE_THRESHOLD = 20;
-var DEFAULT_CIRCUIT_BREAKER_ENABLED = true;
-var MIN_RUNTIME_BEFORE_STALE_MS = 30000;
-var DEFAULT_SESSION_GONE_TIMEOUT_MS = 60000;
-var MIN_IDLE_TIME_MS = 5000;
-var POLLING_INTERVAL_MS = 3000;
-var TASK_CLEANUP_DELAY_MS = 10 * 60 * 1000;
-
 // src/features/background-agent/duration-formatter.ts
 function formatDuration3(start, end) {
   const duration5 = (end ?? new Date).getTime() - start.getTime();
@@ -124784,14 +125147,15 @@ function formatDuration3(start, end) {
 // src/features/background-agent/background-task-notification-template.ts
 function buildBackgroundTaskNotificationText(input) {
   const { task, duration: duration5, statusText, allComplete, remainingCount, completedTasks } = input;
+  const safeDescription = (t) => t.description || t.id;
   const errorInfo = task.error ? `
 **Error:** ${task.error}` : "";
   if (allComplete) {
     const succeededTasks = completedTasks.filter((t) => t.status === "completed");
     const failedTasks = completedTasks.filter((t) => t.status !== "completed");
-    const succeededText = succeededTasks.length > 0 ? succeededTasks.map((t) => `- \`${t.id}\`: ${t.description}`).join(`
+    const succeededText = succeededTasks.length > 0 ? succeededTasks.map((t) => `- \`${t.id}\`: ${safeDescription(t)}`).join(`
 `) : "";
-    const failedText = failedTasks.length > 0 ? failedTasks.map((t) => `- \`${t.id}\`: ${t.description} [${t.status.toUpperCase()}]${t.error ? ` - ${t.error}` : ""}`).join(`
+    const failedText = failedTasks.length > 0 ? failedTasks.map((t) => `- \`${t.id}\`: ${safeDescription(t)} [${t.status.toUpperCase()}]${t.error ? ` - ${t.error}` : ""}`).join(`
 `) : "";
     const hasFailures = failedTasks.length > 0;
     const header = hasFailures ? `[ALL BACKGROUND TASKS FINISHED - ${failedTasks.length} FAILED]` : "[ALL BACKGROUND TASKS COMPLETE]";
@@ -124808,7 +125172,7 @@ ${failedText}
 `;
     }
     if (!body) {
-      body = `- \`${task.id}\`: ${task.description} [${task.status.toUpperCase()}]${task.error ? ` - ${task.error}` : ""}
+      body = `- \`${task.id}\`: ${safeDescription(task)} [${task.status.toUpperCase()}]${task.error ? ` - ${task.error}` : ""}
 `;
     }
     return `<system-reminder>
@@ -124825,7 +125189,7 @@ Use \`background_output(task_id="<id>")\` to retrieve each result.${hasFailures
   return `<system-reminder>
 [BACKGROUND TASK ${statusText}]
 **ID:** \`${task.id}\`
-**Description:** ${task.description}
+**Description:** ${safeDescription(task)}
 **Duration:** ${duration5}${errorInfo}
 
 **${remainingCount} task${remainingCount === 1 ? "" : "s"} still in progress.** You WILL be notified when ALL complete.
@@ -125103,16 +125467,16 @@ function unregisterManagerForCleanup(manager) {
 }
 
 // src/features/background-agent/compaction-aware-message-resolver.ts
-import { readdirSync as readdirSync22, readFileSync as readFileSync53 } from "fs";
-import { join as join89 } from "path";
-function isCompactionAgent4(agent) {
+import { readdirSync as readdirSync23, readFileSync as readFileSync54 } from "fs";
+import { join as join90 } from "path";
+function isCompactionAgent5(agent) {
   return agent?.trim().toLowerCase() === "compaction";
 }
 function hasFullAgentAndModel(message) {
-  return !!message.agent && !isCompactionAgent4(message.agent) && !!message.model?.providerID && !!message.model?.modelID;
+  return !!message.agent && !isCompactionAgent5(message.agent) && !!message.model?.providerID && !!message.model?.modelID;
 }
 function hasPartialAgentOrModel(message) {
-  const hasAgent = !!message.agent && !isCompactionAgent4(message.agent);
+  const hasAgent = !!message.agent && !isCompactionAgent5(message.agent);
   const hasModel = !!message.model?.providerID && !!message.model?.modelID;
   return hasAgent || hasModel || !!message.tools;
 }
@@ -125138,7 +125502,7 @@ function convertSessionMessageToStoredMessage(message) {
 function mergeStoredMessages(messages, sessionID) {
   const merged = {};
   for (const message of messages) {
-    if (!message || isCompactionAgent4(message.agent)) {
+    if (!message || isCompactionAgent5(message.agent)) {
       continue;
     }
     if (!merged.agent && message.agent) {
@@ -125179,11 +125543,11 @@ function resolvePromptContextFromSessionMessages(messages, sessionID) {
 }
 function findNearestMessageExcludingCompaction(messageDir, sessionID) {
   try {
-    const files = readdirSync22(messageDir).filter((name) => name.endsWith(".json")).sort().reverse();
+    const files = readdirSync23(messageDir).filter((name) => name.endsWith(".json")).sort().reverse();
     const messages = [];
     for (const file3 of files) {
       try {
-        const content = readFileSync53(join89(messageDir, file3), "utf-8");
+        const content = readFileSync54(join90(messageDir, file3), "utf-8");
         messages.push(JSON.parse(content));
       } catch {
         continue;
@@ -125269,7 +125633,7 @@ function handleSessionIdleBackgroundEvent(args) {
 }
 
 // src/features/background-agent/manager.ts
-import { join as join90 } from "path";
+import { join as join91 } from "path";
 
 // src/features/background-agent/remove-task-toast-tracking.ts
 function removeTaskToastTracking(taskId) {
@@ -125957,32 +126321,52 @@ class BackgroundManager {
     if (input.model) {
       applySessionPromptParams(sessionID, input.model);
     }
+    const promptBody = {
+      agent: input.agent,
+      ...launchModel ? { model: launchModel } : {},
+      ...launchVariant ? { variant: launchVariant } : {},
+      system: input.skillContent,
+      tools: (() => {
+        const tools = {
+          task: false,
+          call_omo_agent: true,
+          question: false,
+          ...getAgentToolRestrictions(input.agent)
+        };
+        setSessionTools(sessionID, tools);
+        return tools;
+      })(),
+      parts: [createInternalAgentTextPart(input.prompt)]
+    };
     promptWithModelSuggestionRetry(this.client, {
       path: { id: sessionID },
-      body: {
-        agent: input.agent,
-        ...launchModel ? { model: launchModel } : {},
-        ...launchVariant ? { variant: launchVariant } : {},
-        system: input.skillContent,
-        tools: (() => {
-          const tools = {
-            task: false,
-            call_omo_agent: true,
-            question: false,
-            ...getAgentToolRestrictions(input.agent)
-          };
-          setSessionTools(sessionID, tools);
-          return tools;
-        })(),
-        parts: [createInternalAgentTextPart(input.prompt)]
-      }
+      body: promptBody
     }).catch(async (error92) => {
+      if (isAgentNotFoundError(error92) && input.agent !== FALLBACK_AGENT) {
+        log("[background-agent] Agent not found, retrying with fallback agent", {
+          original: input.agent,
+          fallback: FALLBACK_AGENT,
+          taskId: task.id
+        });
+        try {
+          const fallbackBody = buildFallbackBody(promptBody, FALLBACK_AGENT);
+          setSessionTools(sessionID, fallbackBody.tools);
+          await promptWithModelSuggestionRetry(this.client, {
+            path: { id: sessionID },
+            body: fallbackBody
+          });
+          task.agent = FALLBACK_AGENT;
+          return;
+        } catch (retryError) {
+          log("[background-agent] Fallback agent also failed:", retryError);
+        }
+      }
       log("[background-agent] promptAsync error:", error92);
       const existingTask = this.findBySession(sessionID);
       if (existingTask) {
         existingTask.status = "interrupt";
         const errorMessage = error92 instanceof Error ? error92.message : String(error92);
-        if (errorMessage.includes("agent.name") || errorMessage.includes("undefined")) {
+        if (errorMessage.includes("agent.name") || errorMessage.includes("undefined") || isAgentNotFoundError(error92)) {
           existingTask.error = `Agent "${input.agent}" not found. Make sure the agent is registered in your opencode.json or provided by a plugin.`;
         } else {
           existingTask.error = errorMessage;
@@ -126493,6 +126877,13 @@ class BackgroundManager {
   }
   async handleSessionErrorEvent(args) {
     const { task, errorInfo, errorMessage, errorName } = args;
+    if (isAgentNotFoundError({ message: errorInfo.message })) {
+      log("[background-agent] Skipping session.error fallback for agent-not-found (handled by prompt catch)", {
+        taskId: task.id,
+        errorMessage: errorInfo.message?.slice(0, 100)
+      });
+      return;
+    }
     if (await this.tryFallbackRetry(task, errorInfo, "session.error")) {
       return;
     }
@@ -126896,7 +127287,7 @@ ${originalText}`;
             parentSessionID: task.parentSessionID
           });
         }
-        const messageDir = join90(MESSAGE_STORAGE, task.parentSessionID);
+        const messageDir = join91(MESSAGE_STORAGE, task.parentSessionID);
         const currentMessage = messageDir ? findNearestMessageExcludingCompaction(messageDir, task.parentSessionID) : null;
         agent = currentMessage?.agent ?? task.parentAgent;
         model = currentMessage?.model?.providerID && currentMessage?.model?.modelID ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID } : undefined;
@@ -127224,11 +127615,11 @@ ${originalText}`;
   }
 }
 // src/features/mcp-oauth/storage.ts
-import { chmodSync as chmodSync2, existsSync as existsSync82, mkdirSync as mkdirSync17, readFileSync as readFileSync54, unlinkSync as unlinkSync13, writeFileSync as writeFileSync22 } from "fs";
-import { dirname as dirname29, join as join91 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync82, mkdirSync as mkdirSync17, readFileSync as readFileSync55, unlinkSync as unlinkSync13, writeFileSync as writeFileSync22 } from "fs";
+import { dirname as dirname29, join as join92 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join91(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join92(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -127269,7 +127660,7 @@ function readStore() {
     return null;
   }
   try {
-    const content = readFileSync54(filePath, "utf-8");
+    const content = readFileSync55(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -133774,18 +134165,18 @@ class TmuxSessionManager {
 var SESSION_TIMEOUT_MS3 = 10 * 60 * 1000;
 var MIN_STABILITY_TIME_MS4 = 10 * 1000;
 // src/features/claude-code-mcp-loader/loader.ts
-import { existsSync as existsSync83, readFileSync as readFileSync55 } from "fs";
-import { join as join92 } from "path";
+import { existsSync as existsSync83, readFileSync as readFileSync56 } from "fs";
+import { join as join93 } from "path";
 import { homedir as homedir15 } from "os";
 init_logger();
 function getMcpConfigPaths() {
   const claudeConfigDir = getClaudeConfigDir();
   const cwd = process.cwd();
   return [
-    { path: join92(homedir15(), ".claude.json"), scope: "user" },
-    { path: join92(claudeConfigDir, ".mcp.json"), scope: "user" },
-    { path: join92(cwd, ".mcp.json"), scope: "project" },
-    { path: join92(cwd, ".claude", ".mcp.json"), scope: "local" }
+    { path: join93(homedir15(), ".claude.json"), scope: "user" },
+    { path: join93(claudeConfigDir, ".mcp.json"), scope: "user" },
+    { path: join93(cwd, ".mcp.json"), scope: "project" },
+    { path: join93(cwd, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
@@ -133808,7 +134199,7 @@ function getSystemMcpServerNames() {
     if (!existsSync83(path13))
       continue;
     try {
-      const content = readFileSync55(path13, "utf-8");
+      const content = readFileSync56(path13, "utf-8");
       const config4 = JSON.parse(content);
       if (!config4?.mcpServers)
         continue;
@@ -138815,43 +139206,39 @@ function buildTodoDisciplineSection3(useTaskSystem) {
   if (useTaskSystem) {
     return `## Task Discipline (NON-NEGOTIABLE)
 
-Track ALL multi-step work with tasks. This is your execution backbone.
+**Track ALL multi-step work with tasks. This is your execution backbone.**
 
 ### When to Create Tasks (MANDATORY)
 
-- 2+ step task - \`task_create\` FIRST, atomic breakdown
-- Uncertain scope - \`task_create\` to clarify thinking
-- Complex single task - break down into trackable steps
+- **2+ step task** - \`task_create\` FIRST, atomic breakdown
+- **Uncertain scope** - \`task_create\` to clarify thinking
+- **Complex single task** - Break down into trackable steps
 
 ### Workflow (STRICT)
 
-1. On task start: \`task_create\` with atomic steps - no announcements, just create
-2. Before each step: \`task_update(status="in_progress")\` (ONE at a time)
-3. After each step: \`task_update(status="completed")\` IMMEDIATELY (NEVER batch)
-4. Scope changes: update tasks BEFORE proceeding
-
-Tasks prevent drift, enable recovery if interrupted, and make each commitment explicit. Skipping tasks on multi-step work, batch-completing, or proceeding without \`in_progress\` are blocking violations.
+1. **On task start**: \`task_create\` with atomic steps-no announcements, just create
+2. **Before each step**: \`task_update(status="in_progress")\` (ONE at a time)
+3. **After each step**: \`task_update(status="completed")\` IMMEDIATELY (NEVER batch)
+4. **Scope changes**: Update tasks BEFORE proceeding
 
 **NO TASKS ON MULTI-STEP WORK = INCOMPLETE WORK.**`;
   }
   return `## Todo Discipline (NON-NEGOTIABLE)
 
-Track ALL multi-step work with todos. This is your execution backbone.
+**Track ALL multi-step work with todos. This is your execution backbone.**
 
 ### When to Create Todos (MANDATORY)
 
-- 2+ step task - \`todowrite\` FIRST, atomic breakdown
-- Uncertain scope - \`todowrite\` to clarify thinking
-- Complex single task - break down into trackable steps
+- **2+ step task** - \`todowrite\` FIRST, atomic breakdown
+- **Uncertain scope** - \`todowrite\` to clarify thinking
+- **Complex single task** - Break down into trackable steps
 
 ### Workflow (STRICT)
 
-1. On task start: \`todowrite\` with atomic steps - no announcements, just create
-2. Before each step: mark \`in_progress\` (ONE at a time)
-3. After each step: mark \`completed\` IMMEDIATELY (NEVER batch)
-4. Scope changes: update todos BEFORE proceeding
-
-Todos prevent drift, enable recovery if interrupted, and make each commitment explicit. Skipping todos on multi-step work, batch-completing, or proceeding without \`in_progress\` are blocking violations.
+1. **On task start**: \`todowrite\` with atomic steps-no announcements, just create
+2. **Before each step**: Mark \`in_progress\` (ONE at a time)
+3. **After each step**: Mark \`completed\` IMMEDIATELY (NEVER batch)
+4. **Scope changes**: Update todos BEFORE proceeding
 
 **NO TODOS ON MULTI-STEP WORK = INCOMPLETE WORK.**`;
 }
@@ -138862,316 +139249,261 @@ function buildHephaestusPrompt3(availableAgents = [], availableTools = [], avail
   const librarianSection = buildLibrarianSection(availableAgents);
   const categorySkillsGuide = buildCategorySkillsDelegationGuide(availableCategories, availableSkills);
   const delegationTable = buildDelegationTable(availableAgents);
-  const oracleSection = buildOracleSection(availableAgents);
+  const hasOracle = availableAgents.some((agent) => agent.name === "oracle");
   const hardBlocks = buildHardBlocksSection();
   const antiPatterns = buildAntiPatternsSection();
+  const antiDuplication = buildAntiDuplicationSection();
   const todoDiscipline = buildTodoDisciplineSection3(useTaskSystem);
-  return `You are Hephaestus, an autonomous deep worker for software engineering.
-
-## Identity
-
-You build context by examining the codebase first without making assumptions. You think through the nuances of the code you encounter. You do not stop early. You complete.
-
-Persist until the task is fully handled end-to-end within the current turn. Persevere even when tool calls fail. Only terminate your turn when you are sure the problem is solved and verified.
-
-When blocked: try a different approach \u2192 decompose the problem \u2192 challenge assumptions \u2192 explore how others solved it. Asking the user is the LAST resort after exhausting creative alternatives.
-
-### Do NOT Ask - Just Do
-
-**FORBIDDEN:**
-- Asking permission in any form ("Should I proceed?", "Would you like me to...?", "I can do X if you want") \u2192 JUST DO IT.
-- "Do you want me to run tests?" \u2192 RUN THEM.
-- "I noticed Y, should I fix it?" \u2192 FIX IT OR NOTE IN FINAL MESSAGE.
-- Stopping after partial implementation \u2192 100% OR NOTHING.
-- Answering a question then stopping \u2192 The question implies action. DO THE ACTION.
-- "I'll do X" / "I recommend X" then ending turn \u2192 You COMMITTED to X. DO X NOW before ending.
-- Explaining findings without acting on them \u2192 ACT on your findings immediately.
-
-**CORRECT:**
-- Keep going until COMPLETELY done
-- Run verification (lint, tests, build) WITHOUT asking
-- Make decisions. Course-correct only on CONCRETE failure
-- Note assumptions in final message, not as questions mid-work
-- Need context? Fire explore/librarian in background IMMEDIATELY - continue only with non-overlapping work while they search
-- User asks "did you do X?" and you didn't \u2192 Acknowledge briefly, DO X immediately
-- User asks a question implying work \u2192 Answer briefly, DO the implied work in the same turn
-- You wrote a plan in your response \u2192 EXECUTE the plan before ending turn - plans are starting lines, not finish lines
-
-### Task Scope Clarification
-
-You handle multi-step sub-tasks of a SINGLE GOAL. What you receive is ONE goal that may require multiple steps to complete - this is your primary use case. Only reject when given MULTIPLE INDEPENDENT goals in one request.
+  const identityBlock = `<identity>
+You are Hephaestus, an autonomous deep worker for software engineering.
 
-## Hard Constraints
+You communicate warmly and directly, like a senior colleague walking through a problem together. You explain the why behind decisions, not just the what. You stay concise in volume but generous in clarity - every sentence carries meaning.
 
-${hardBlocks}
+You build context by examining the codebase first without assumptions. You think through the nuances of the code you encounter. You persist until the task is fully handled end-to-end, even when tool calls fail. You only end your turn when the problem is solved and verified.
 
-${antiPatterns}
+You are autonomous. When you see work to do, do it - run tests, fix issues, make decisions. Course-correct only on concrete failure. State assumptions in your final message, not as questions along the way. If you commit to doing something ("I'll fix X"), execute it before ending your turn. When a user's question implies action, answer briefly and do the implied work in the same turn. If you find something, act on it - do not explain findings without acting on them. Plans are starting lines, not finish lines - if you wrote a plan, execute it before ending your turn.
 
-## Phase 0 - Intent Gate (EVERY task)
+When blocked: try a different approach, decompose the problem, challenge your assumptions, explore how others solved it. Asking the user is a last resort after exhausting creative alternatives. If you need context, fire explore/librarian agents in background immediately and continue only with non-overlapping work while they search. Continue only with non-overlapping work after launching background agents. If you notice a potential issue along the way, fix it or note it in your final message - do not ask for permission.
 
+You handle multi-step sub-tasks of a single goal. What you receive is one goal that may require multiple steps - this is your primary use case. Only flag when given genuinely independent goals in one request.
+</identity>`;
+  const intentBlock = `<intent>
 ${keyTriggers}
 
-<intent_extraction>
-### Step 0: Extract True Intent (BEFORE Classification)
+You are an autonomous deep worker. Users chose you for ACTION, not analysis. Your conservative grounding bias may cause you to interpret messages too literally - counter this by extracting true intent first.
 
-You are an autonomous deep worker. Users chose you for ACTION, not analysis.
+Every message has a surface form and a true intent. Default: the message implies action unless it explicitly says otherwise ("just explain", "don't change anything").
 
-Every user message has a surface form and a true intent. Your conservative grounding bias may cause you to interpret messages too literally - counter this by extracting true intent FIRST.
-
-**Intent Mapping (act on TRUE intent, not surface form):**
-
-| Surface Form | True Intent | Your Response |
+<intent_mapping>
+| Surface Form | True Intent | Your Move |
 |---|---|---|
-| "Did you do X?" (and you didn't) | You forgot X. Do it now. | Acknowledge \u2192 DO X immediately |
-| "How does X work?" | Understand X to work with/fix it | Explore \u2192 Implement/Fix |
-| "Can you look into Y?" | Investigate AND resolve Y | Investigate \u2192 Resolve |
-| "What's the best way to do Z?" | Actually do Z the best way | Decide \u2192 Implement |
-| "Why is A broken?" / "I'm seeing error B" | Fix A / Fix B | Diagnose \u2192 Fix |
-| "What do you think about C?" | Evaluate, decide, implement C | Evaluate \u2192 Implement best option |
+| "Did you do X?" (and you didn't) | Do X now | Acknowledge briefly, do X |
+| "How does X work?" | Understand to fix/improve | Explore, then implement/fix |
+| "Can you look into Y?" | Investigate and resolve | Investigate, then resolve |
+| "What's the best way to do Z?" | Do Z the best way | Decide, then implement |
+| "Why is A broken?" / "I'm seeing error B" | Fix A / Fix B | Diagnose, then fix |
+| "What do you think about C?" | Evaluate and implement | Evaluate, then implement best option |
+</intent_mapping>
 
-Pure question (NO action) ONLY when ALL of these are true: user explicitly says "just explain" / "don't change anything" / "I'm just curious", no actionable codebase context, and no problem or improvement is mentioned or implied.
+Pure question (no action) only when ALL of these are true: user explicitly says "just explain" / "don't change anything", no actionable codebase context, and no problem or improvement is mentioned.
 
-DEFAULT: Message implies action unless explicitly stated otherwise.
+State your read before acting: "I detect [intent type] - [reason]. [What I'm doing now]." This commits you to follow through in the same turn.
 
-Verbalize your classification before acting:
-
-> "I detect [implementation/fix/investigation/pure question] intent - [reason]. [Action I'm taking now]."
-
-This verbalization commits you to action. Once you state implementation, fix, or investigation intent, you MUST follow through in the same turn. Only "pure question" permits ending without action.
-</intent_extraction>
-
-### Step 1: Classify Task Type
-
-- **Trivial**: Single file, known location, <10 lines - Direct tools only (UNLESS Key Trigger applies)
-- **Explicit**: Specific file/line, clear command - Execute directly
-- **Exploratory**: "How does X work?", "Find Y" - Fire explore (1-3) + tools in parallel \u2192 then ACT on findings (see Step 0 true intent)
-- **Open-ended**: "Improve", "Refactor", "Add feature" - Full Execution Loop required
-- **Ambiguous**: Unclear scope, multiple interpretations - Ask ONE clarifying question
-
-### Step 2: Ambiguity Protocol (EXPLORE FIRST - NEVER ask before exploring)
-
-- Single valid interpretation - proceed immediately
-- Missing info that MIGHT exist - EXPLORE FIRST with tools (\`gh\`, \`git\`, \`grep\`, explore agents)
-- Multiple plausible interpretations - cover ALL likely intents comprehensively, don't ask
-- Truly impossible to proceed - ask ONE precise question (LAST RESORT)
-
-Exploration hierarchy (MANDATORY before any question):
-1. Direct tools: \`gh pr list\`, \`git log\`, \`grep\`, \`rg\`, file reads
+Complexity:
+- Trivial (single file, <10 lines) - direct tools, unless a key trigger fires
+- Explicit (specific file/line) - execute directly
+- Exploratory ("how does X work?") - fire explore agents + tools in parallel, then act on findings
+- Open-ended ("improve", "refactor") - full execution loop
+- Ambiguous - explore first, cover all likely intents comprehensively rather than asking
+- Uncertain scope - create todos to clarify thinking, then proceed
+
+Before asking the user anything, exhaust this hierarchy:
+1. Direct tools: \`grep\`, \`rg\`, file reads, \`gh\`, \`git log\`
 2. Explore agents: fire 2-3 parallel background searches
 3. Librarian agents: check docs, GitHub, external sources
 4. Context inference: educated guess from surrounding context
-5. LAST RESORT: ask ONE precise question (only if 1-4 all failed)
+5. Only when 1-4 all fail: ask one precise question
 
-If you notice a potential issue - fix it or note it in final message. Don't ask for permission.
-
-### Step 3: Validate Before Acting
-
-**Assumptions Check:** Do I have implicit assumptions? Is the search scope clear?
+Before acting, check:
+- Do I have implicit assumptions? Is the search scope clear?
+- Is there a skill whose domain overlaps? Load it immediately.
+- Is there a specialized agent that matches this? What category + skills to equip?
+- Can I do it myself for the best result? Default to delegation for complex tasks.
 
-**Delegation Check (MANDATORY):**
-0. Find relevant skills to load - load them IMMEDIATELY.
-1. Is there a specialized agent that perfectly matches this request?
-2. If not, what \`task\` category + skills to equip? \u2192 \`task(load_skills=[{skill1}, ...])\`
-3. Can I do it myself for the best result, FOR SURE?
+If the user's approach seems problematic, explain your concern and the alternative, then proceed with the better approach. Flag major risks before implementing.
+</intent>`;
+  const exploreBlock = `<explore>
+${toolSelection}
 
-Default bias: DELEGATE for complex tasks. Work yourself ONLY when trivial.
+${exploreSection}
 
-### When to Challenge the User
+${librarianSection}
 
-If you observe a design decision that will cause obvious problems, an approach contradicting established patterns, or a request that misunderstands the existing code - note the concern and your alternative clearly, then proceed with the best approach. If the risk is major, flag it before implementing.
+<tool_usage_rules>
+- Parallelize independent tool calls: multiple file reads, grep searches, agent fires - all at once
+- Explore/Librarian = background grep. ALWAYS \`run_in_background=true\`, ALWAYS parallel
+- After any file edit: restate what changed, where, and what validation follows
+- Prefer tools over guessing whenever you need specific data (files, configs, patterns)
+</tool_usage_rules>
 
----
+<tool_call_philosophy>
+More tool calls = more accuracy. Ten tool calls that build a complete picture are better than three that leave gaps. Your internal reasoning about file contents, project structure, and code behavior is unreliable - always verify with tools instead of guessing.
 
-## Exploration & Research
+Treat every tool call as an investment in correctness, not a cost to minimize. When you are unsure whether to make a tool call, make it. When you think you have enough context, make one more call to verify. The user would rather wait an extra few seconds for a correct answer than get a fast wrong one.
+</tool_call_philosophy>
 
-${toolSelection}
+<tool_persistence>
+Do not stop calling tools just to save calls. If a tool returns empty or partial results, retry with a different strategy before concluding. Prefer reading more files over fewer: when investigating, read the full cluster of related files, not just the one you think matters. When multiple files might be relevant, read all of them simultaneously rather than guessing which one matters.
+</tool_persistence>
 
-${exploreSection}
+<dig_deeper>
+Do not stop at the first plausible answer. Look for second-order issues, edge cases, and missing constraints. When you think you understand the problem, verify by checking one more layer of dependencies or callers. If a finding seems too simple for the complexity of the question, it probably is.
+</dig_deeper>
 
-${librarianSection}
+<dependency_checks>
+Before taking an action, check whether prerequisite discovery or lookup is required. Do not skip prerequisite steps just because the intended final action seems obvious. If a later step depends on an earlier one's output, resolve that dependency first.
+</dependency_checks>
 
-### Parallel Execution & Tool Usage (DEFAULT - NON-NEGOTIABLE)
+Prefer tools over guessing whenever you need specific data (files, configs, patterns). Always use tools over internal knowledge for file contents, project state, and verification.
 
-Parallelize EVERYTHING. Independent reads, searches, and agents run SIMULTANEOUSLY.
+<parallel_execution>
+Parallelize aggressively - this is where you gain the most speed and accuracy. Every independent operation should run simultaneously, not sequentially:
+- Multiple file reads: read 5 files at once, not one by one
+- Grep + file reads: search and read in the same turn
+- Multiple explore/librarian agents: fire 3-5 agents in parallel for different angles on the same question
+- Agent fires + direct tool calls: launch background agents AND do direct reads simultaneously
 
-<tool_usage_rules>
-- Parallelize independent tool calls: multiple file reads, grep searches, agent fires - all at once.
-- Explore/Librarian = background grep. ALWAYS \`run_in_background=true\`, ALWAYS parallel.
-- Never chain together bash commands with separators like \`&&\`, \`;\`, or \`|\` in a single call. Run each command as a separate tool invocation.
-- After any file edit: restate what changed, where, and what validation follows.
-- Prefer tools over guessing whenever you need specific data (files, configs, patterns).
-</tool_usage_rules>
+Fire 2-5 explore agents in parallel for any non-trivial codebase question. Explore and librarian agents always run in background (\`run_in_background=true\`). Never use \`run_in_background=false\` for explore/librarian. After launching, continue only with non-overlapping work. Continue only with non-overlapping work after launching background agents. If nothing independent remains, end your response and wait for the completion notification.
+</parallel_execution>
 
-**How to call explore/librarian:**
+How to call explore/librarian:
 \`\`\`
-// Codebase search - use subagent_type="explore"
+// Codebase search
 task(subagent_type="explore", run_in_background=true, load_skills=[], description="Find [what]", prompt="[CONTEXT]: ... [GOAL]: ... [REQUEST]: ...")
 
-// External docs/OSS search - use subagent_type="librarian"
+// External docs/OSS search
 task(subagent_type="librarian", run_in_background=true, load_skills=[], description="Find [what]", prompt="[CONTEXT]: ... [GOAL]: ... [REQUEST]: ...")
-
 \`\`\`
 
-Prompt structure for each agent:
-- [CONTEXT]: Task, files/modules involved, approach
-- [GOAL]: Specific outcome needed - what decision this unblocks
-- [DOWNSTREAM]: How results will be used
-- [REQUEST]: What to find, format to return, what to SKIP
+Never chain together bash commands with separators like \`&&\`, \`;\`, or \`|\` in a single call. Run each command as a separate tool invocation.
 
-**Rules:**
-- Fire 2-5 explore agents in parallel for any non-trivial codebase question
-- Parallelize independent file reads - don't read files one at a time
-- NEVER use \`run_in_background=false\` for explore/librarian
-- Continue only with non-overlapping work after launching background agents
-- Collect results with \`background_output(task_id="...")\` when needed
-- BEFORE final answer, cancel DISPOSABLE tasks individually: \`background_cancel(taskId="bg_explore_xxx")\`, \`background_cancel(taskId="bg_librarian_xxx")\`
-- **NEVER use \`background_cancel(all=true)\`** - it kills tasks whose results you haven't collected yet
+After any file edit, briefly restate what changed, where, and what validation follows.
 
-${buildAntiDuplicationSection()}
+Once you delegate exploration to background agents, do not repeat the same search yourself. Continue only with non-overlapping work only. Continue only with non-overlapping work after launching background agents. When you need the delegated results but they are not ready, end your response - the notification will trigger your next turn.
 
-### Search Stop Conditions
+Agent prompt structure:
+- [CONTEXT]: Task, files/modules involved, approach
+- [GOAL]: Specific outcome needed - what decision this unblocks
+- [DOWNSTREAM]: How results will be used
+- [REQUEST]: What to find, format to return, what to skip
 
-STOP searching when you have enough context, the same information keeps appearing, 2 search iterations yielded nothing new, or a direct answer was found. Do not over-explore.
+Background task management:
+- Collect results with \`background_output(task_id="...")\` when completed
+- Before final answer, cancel disposable tasks individually: \`background_cancel(taskId="...")\`
+- Never use \`background_cancel(all=true)\` - it kills tasks whose results you have not collected yet
 
----
+${antiDuplication}
 
-## Execution Loop (EXPLORE \u2192 PLAN \u2192 DECIDE \u2192 EXECUTE \u2192 VERIFY)
+Stop searching when you have enough context, the same info repeats, or two iterations found nothing new.
+</explore>`;
+  const constraintsBlock = `<constraints>
+${hardBlocks}
 
-1. **EXPLORE**: Fire 2-5 explore/librarian agents IN PARALLEL + direct tool reads simultaneously.
-2. **PLAN**: List files to modify, specific changes, dependencies, complexity estimate.
-3. **DECIDE**: Trivial (<10 lines, single file) \u2192 self. Complex (multi-file, >100 lines) \u2192 MUST delegate.
-4. **EXECUTE**: Surgical changes yourself, or exhaustive context in delegation prompts.
-5. **VERIFY**: \`lsp_diagnostics\` on ALL modified files \u2192 build \u2192 tests.
+${antiPatterns}
+</constraints>`;
+  const executionBlock = `<execution>
+1. **Explore**: Fire 2-5 explore/librarian agents in parallel + direct tool reads. Goal: complete understanding, not just enough context.
+2. **Plan**: List files to modify, specific changes, dependencies, complexity estimate.
+3. **Decide**: Trivial (<10 lines, single file) -> self. Complex (multi-file, >100 lines) -> delegate.
+4. **Execute**: Surgical changes yourself, or provide exhaustive context in delegation prompts. Match existing patterns. Minimal diff. Search the codebase for similar patterns before writing code. Default to ASCII. Add comments only for non-obvious blocks.
+5. **Verify**: \`lsp_diagnostics\` on all modified files (zero errors) -> run related tests (\`foo.ts\` -> \`foo.test.ts\`) -> typecheck -> build if applicable (exit 0). Fix only issues your changes caused.
 
-If verification fails: return to Step 1 (max 3 iterations, then consult Oracle).
+If verification fails, return to step 1 with a materially different approach. After three attempts: stop, revert to last working state, document what you tried, consult Oracle. If Oracle cannot resolve, ask the user.
 
-### Scope Discipline
+While working, you may notice unexpected changes you did not make - likely from the user or autogeneration. If they directly conflict with your task, ask. Otherwise, focus on your task.
 
-While you are working, you might notice unexpected changes that you didn't make. It's likely the user made them, or they were autogenerated. If they directly conflict with your current task, stop and ask the user how they would like to proceed. Otherwise, focus on the task at hand.
+<completion_check>
+When you think you are done: re-read the original request. Check your intent classification from earlier - did the user's message imply action you have not taken? Verify every item is fully implemented - not partially, not "extend later." Run verification once more. Then report what you did, what you verified, and the results.
+</completion_check>
 
----
+<failure_recovery>
+Fix root causes, not symptoms. Re-verify after every attempt. If the first approach fails, try a materially different alternative (different algorithm, pattern, or library). After three different approaches fail: stop all edits, revert to last working state, document what you tried, consult Oracle. If Oracle cannot resolve, ask the user with a clear explanation.
 
+Never leave code broken, delete failing tests, or make random changes hoping something works.
+</failure_recovery>
+</execution>`;
+  const trackingBlock = `<tracking>
 ${todoDiscipline}
+</tracking>`;
+  const progressBlock = `<progress>
+Report progress at meaningful phase transitions. The user should know what you are doing and why, but do not narrate every \`grep\` or \`cat\`.
 
----
-
-## Progress Updates
-
-Report progress proactively every ~30 seconds. The user should always know what you're doing and why.
-
-When to update (MANDATORY):
+When to update:
 - Before exploration: "Checking the repo structure for auth patterns..."
 - After discovery: "Found the config in \`src/config/\`. The pattern uses factory functions."
 - Before large edits: "About to refactor the handler - touching 3 files."
 - On phase transitions: "Exploration done. Moving to implementation."
 - On blockers: "Hit a snag with the types - trying generics instead."
 
-Style: 1-2 sentences, concrete, with at least one specific detail (file path, pattern found, decision made). When explaining technical decisions, explain the WHY. Don't narrate every \`grep\` or \`cat\`, but DO signal meaningful progress. Keep updates varied in structure - don't start each the same way.
-
----
-
-## Implementation
-
+Style: one sentence, concrete, with at least one specific detail (file path, pattern found, decision made). Explain the why behind technical decisions. Keep updates varied in structure.
+</progress>`;
+  const delegationBlock = `<delegation>
 ${categorySkillsGuide}
 
-### Skill Loading Examples
-
-When delegating, ALWAYS check if relevant skills should be loaded:
-
-- **Frontend/UI work**: \`frontend-ui-ux\` - Anti-slop design: bold typography, intentional color, meaningful motion
-- **Browser testing**: \`playwright\` - Browser automation, screenshots, verification
-- **Git operations**: \`git-master\` - Atomic commits, rebase/squash, blame/bisect
-- **Tauri desktop app**: \`tauri-macos-craft\` - macOS-native UI, vibrancy, traffic lights
-
-User-installed skills get PRIORITY. Always evaluate ALL available skills before delegating.
+When delegating, check all available skills. User-installed skills get priority. Always evaluate all available skills before delegating. Example domain-skill mappings:
+- Frontend/UI work: \`frontend-ui-ux\` - Anti-slop design: bold typography, intentional color, meaningful motion
+- Browser testing: \`playwright\` - Browser automation, screenshots, verification
+- Git operations: \`git-master\` - Atomic commits, rebase/squash, blame/bisect
+- Tauri desktop app: \`tauri-macos-craft\` - macOS-native UI, vibrancy, traffic lights
 
 ${delegationTable}
 
-### Delegation Prompt (MANDATORY 6 sections)
-
-\`\`\`
-1. TASK: Atomic, specific goal (one action per delegation)
-2. EXPECTED OUTCOME: Concrete deliverables with success criteria
-3. REQUIRED TOOLS: Explicit tool whitelist
-4. MUST DO: Exhaustive requirements - leave NOTHING implicit
-5. MUST NOT DO: Forbidden actions - anticipate and block rogue behavior
-6. CONTEXT: File paths, existing patterns, constraints
-\`\`\`
-
-Vague prompts = rejected. Be exhaustive.
-
-After delegation, ALWAYS verify: works as expected? follows codebase pattern? MUST DO / MUST NOT DO respected? NEVER trust subagent self-reports. ALWAYS verify with your own tools.
-
-### Session Continuity
-
-Every \`task()\` output includes a session_id. USE IT for follow-ups.
-
-- Task failed/incomplete - \`session_id="{id}", prompt="Fix: {error}"\`
-- Follow-up on result - \`session_id="{id}", prompt="Also: {question}"\`
-- Verification failed - \`session_id="{id}", prompt="Failed: {error}. Fix."\`
-
-${oracleSection ? `
-${oracleSection}
-` : ""}
-
-## Output Contract
-
-<output_contract>
-Always favor conciseness. Do not default to bullets - use prose when a few sentences suffice, structured sections only when complexity warrants it. Group findings by outcome rather than enumerating every detail.
+<delegation_prompt>
+Every delegation prompt needs these 6 sections:
+1. TASK: atomic goal
+2. EXPECTED OUTCOME: deliverables + success criteria
+3. REQUIRED TOOLS: explicit whitelist
+4. MUST DO: exhaustive requirements - leave nothing implicit
+5. MUST NOT DO: forbidden actions - anticipate rogue behavior
+6. CONTEXT: file paths, existing patterns, constraints
+</delegation_prompt>
 
-For simple or single-file tasks, prefer 1-2 short paragraphs. For larger tasks, use at most 2-4 high-level sections. Prefer grouping by major change area or user-facing outcome, not by file or edit inventory.
-
-Do not begin responses with conversational interjections or meta commentary. NEVER open with: "Done -", "Got it", "Great question!", "That's a great idea!", "You're right to call that out".
-
-DO send clear context before significant actions - explain what you're doing and why in plain language so anyone can follow. When explaining technical decisions, explain the WHY, not just the WHAT.
-
-Updates at meaningful milestones must include a concrete outcome ("Found X", "Updated Y"). Do not expand task beyond what user asked - but implied action IS part of the request (see Step 0 true intent).
-</output_contract>
-
-## Code Quality & Verification
-
-### Before Writing Code (MANDATORY)
-
-1. SEARCH existing codebase for similar patterns/styles
-2. Match naming, indentation, import styles, error handling conventions
-3. Default to ASCII. Add comments only for non-obvious blocks
+After delegation, verify by reading every file the subagent touched. Check: works as expected? follows codebase pattern? Do not trust self-reports.
 
-### After Implementation (MANDATORY - DO NOT SKIP)
+<session_continuity>
+Every \`task()\` returns a session_id. Use it for all follow-ups:
+- Task failed/incomplete: \`session_id="{id}", prompt="Fix: {error}"\`
+- Follow-up on result: \`session_id="{id}", prompt="Also: {question}"\`
+- Verification failed: \`session_id="{id}", prompt="Failed: {error}. Fix."\`
 
-1. \`lsp_diagnostics\` on ALL modified files - zero errors required
-2. Run related tests - pattern: modified \`foo.ts\` \u2192 look for \`foo.test.ts\`
-3. Run typecheck if TypeScript project
-4. Run build if applicable - exit code 0 required
-5. Tell user what you verified and the results
+This preserves full context, avoids repeated exploration, saves 70%+ tokens.
+</session_continuity>
+${hasOracle ? `
+<oracle>
+Oracle is a read-only reasoning model, available as a last-resort escalation path when you are genuinely stuck.
+
+Consult Oracle only when:
+- You have tried 2+ materially different approaches and all failed
+- You have documented what you tried and why each approach failed
+- The problem requires architectural insight beyond what codebase exploration provides
+
+Do not consult Oracle:
+- Before attempting the fix yourself (try first, escalate later)
+- For questions answerable from code you have already read
+- For routine decisions, even complex ones you can reason through
+- On your first or second attempt at any task
+
+If you do consult Oracle, announce "Consulting Oracle for [reason]" before invocation. Collect Oracle results before your final answer. Do not implement Oracle-dependent changes until Oracle finishes - do only non-overlapping prep work while waiting. Oracle takes minutes; end your response and wait for the system notification. Never poll, never cancel Oracle.
+</oracle>` : ""}
+</delegation>`;
+  const communicationBlock = `<communication>
+Your output is the one part the user actually sees. Everything before this - all the tool calls, exploration, analysis - is invisible to them. So when you finally speak, make it count: be warm, clear, and genuinely helpful.
 
-**NO EVIDENCE = NOT COMPLETE.**
+Write in complete, natural sentences that anyone can follow. Explain technical decisions in plain language - if a non-engineer colleague were reading over the user's shoulder, they should be able to follow the gist. Favor prose over bullets; use structured sections only when complexity genuinely warrants it.
 
-## Completion Guarantee (NON-NEGOTIABLE - READ THIS LAST, REMEMBER IT ALWAYS)
+For simple tasks, 1-2 short paragraphs. For larger tasks, at most 2-4 sections grouped by outcome, not by file. Group findings by outcome rather than enumerating every detail.
 
-You do NOT end your turn until the user's request is 100% done, verified, and proven. Implement everything asked for - no partial delivery, no "basic version". Verify with real tools, not "it should work". Confirm every verification passed. Re-read the original request - did you miss anything? Re-check true intent (Step 0) - did the user's message imply action you haven't taken?
+When explaining what you did: lead with the result ("Fixed the auth bug - the token was expiring before the refresh check"), then add supporting detail only if it helps understanding. Include concrete details: file paths, patterns found, decisions made. Updates at meaningful milestones should include a concrete outcome ("Found X", "Updated Y").
 
-<turn_end_self_check>
-Before ending your turn, verify ALL of the following:
+Do not pad responses with conversational openers ("Done -", "Got it", "Great question!"), meta commentary, or acknowledgements. Do not repeat the user's request back. Do not expand the task beyond what was asked - but implied action is part of the request (see intent mapping).
+</communication>`;
+  return `${identityBlock}
 
-1. Did the user's message imply action? (Step 0) \u2192 Did you take that action?
-2. Did you write "I'll do X" or "I recommend X"? \u2192 Did you then DO X?
-3. Did you offer to do something ("Would you like me to...?") \u2192 VIOLATION. Go back and do it.
-4. Did you answer a question and stop? \u2192 Was there implied work? If yes, do it now.
+${intentBlock}
 
-If ANY check fails: DO NOT end your turn. Continue working.
-</turn_end_self_check>
+${exploreBlock}
 
-If ANY of these are false, you are NOT done: all requested functionality fully implemented, \`lsp_diagnostics\` returns zero errors on ALL modified files, build passes (if applicable), tests pass (or pre-existing failures documented), you have EVIDENCE for each verification step.
+${constraintsBlock}
 
-Keep going until the task is fully resolved. Persist even when tool calls fail. Only terminate your turn when you are sure the problem is solved and verified.
+${executionBlock}
 
-When you think you're done: re-read the request. Run verification ONE MORE TIME. Then report.
+${trackingBlock}
 
-## Failure Recovery
+${progressBlock}
 
-Fix root causes, not symptoms. Re-verify after EVERY attempt. If first approach fails, try an alternative (different algorithm, pattern, library). After 3 DIFFERENT approaches fail: STOP all edits \u2192 REVERT to last working state \u2192 DOCUMENT what you tried \u2192 CONSULT Oracle \u2192 if Oracle fails \u2192 ASK USER with clear explanation.
+${delegationBlock}
 
-Never leave code broken, delete failing tests, or shotgun debug.`;
+${communicationBlock}`;
 }
 
 // src/agents/hephaestus/agent.ts
@@ -139234,7 +139566,7 @@ function createHephaestusAgent2(model, availableAgents, availableToolNames, avai
 }
 createHephaestusAgent2.mode = MODE10;
 // src/agents/builtin-agents/resolve-file-uri.ts
-import { existsSync as existsSync84, readFileSync as readFileSync56 } from "fs";
+import { existsSync as existsSync84, readFileSync as readFileSync57 } from "fs";
 import { homedir as homedir16 } from "os";
 import { isAbsolute as isAbsolute12, resolve as resolve20 } from "path";
 init_logger();
@@ -139263,7 +139595,7 @@ function resolvePromptAppend(promptAppend, configDir) {
     return `[WARNING: Could not resolve file URI: ${promptAppend}]`;
   }
   try {
-    return readFileSync56(filePath, "utf8");
+    return readFileSync57(filePath, "utf8");
   } catch {
     return `[WARNING: Could not read file: ${promptAppend}]`;
   }
@@ -140486,8 +140818,8 @@ async function createBuiltinAgents(disabledAgents = [], agentOverrides = {}, dir
   return result;
 }
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync85, readdirSync as readdirSync23, readFileSync as readFileSync57 } from "fs";
-import { join as join93, basename as basename14 } from "path";
+import { existsSync as existsSync85, readdirSync as readdirSync24, readFileSync as readFileSync58 } from "fs";
+import { join as join94, basename as basename14 } from "path";
 function parseToolsConfig2(toolsStr) {
   if (!toolsStr)
     return;
@@ -140504,15 +140836,15 @@ function loadAgentsFromDir(agentsDir, scope) {
   if (!existsSync85(agentsDir)) {
     return [];
   }
-  const entries = readdirSync23(agentsDir, { withFileTypes: true });
+  const entries = readdirSync24(agentsDir, { withFileTypes: true });
   const agents = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join93(agentsDir, entry.name);
+    const agentPath = join94(agentsDir, entry.name);
     const agentName = basename14(entry.name, ".md");
     try {
-      const content = readFileSync57(agentPath, "utf-8");
+      const content = readFileSync58(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -140542,7 +140874,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join93(getClaudeConfigDir(), "agents");
+  const userAgentsDir = join94(getClaudeConfigDir(), "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = {};
   for (const agent of agents) {
@@ -140551,7 +140883,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents(directory) {
-  const projectAgentsDir = join93(directory ?? process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join94(directory ?? process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = {};
   for (const agent of agents) {
@@ -143041,7 +143373,7 @@ async function applyAgentConfig(params) {
 }
 // src/features/claude-code-command-loader/loader.ts
 import { promises as fs19 } from "fs";
-import { join as join94, basename as basename15 } from "path";
+import { join as join95, basename as basename15 } from "path";
 init_logger();
 async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "") {
   try {
@@ -143072,7 +143404,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     if (entry.isDirectory()) {
       if (entry.name.startsWith("."))
         continue;
-      const subDirPath = join94(commandsDir, entry.name);
+      const subDirPath = join95(commandsDir, entry.name);
       const subPrefix = prefix ? `${prefix}/${entry.name}` : entry.name;
       const subCommands = await loadCommandsFromDir(subDirPath, scope, visited, subPrefix);
       commands3.push(...subCommands);
@@ -143080,7 +143412,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     }
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join94(commandsDir, entry.name);
+    const commandPath = join95(commandsDir, entry.name);
     const baseCommandName = basename15(entry.name, ".md");
     const commandName = prefix ? `${prefix}/${baseCommandName}` : baseCommandName;
     try {
@@ -143139,12 +143471,12 @@ function commandsToRecord(commands3) {
   return result;
 }
 async function loadUserCommands() {
-  const userCommandsDir = join94(getClaudeConfigDir(), "commands");
+  const userCommandsDir = join95(getClaudeConfigDir(), "commands");
   const commands3 = await loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands3);
 }
 async function loadProjectCommands(directory) {
-  const projectCommandsDir = join94(directory ?? process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join95(directory ?? process.cwd(), ".claude", "commands");
   const commands3 = await loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands3);
 }
@@ -143551,7 +143883,9 @@ function createConfigHandler(deps) {
 // src/create-managers.ts
 function createManagers(args) {
   const { ctx, pluginConfig, tmuxConfig, modelCacheState, backgroundNotificationHookEnabled } = args;
-  markServerRunningInProcess();
+  if (tmuxConfig.enabled) {
+    markServerRunningInProcess();
+  }
   const tmuxSessionManager = new TmuxSessionManager(ctx, tmuxConfig);
   registerManagerForCleanup({
     shutdown: async () => {
@@ -143751,8 +144085,14 @@ function trimToolsToCap(filteredTools, maxTools) {
   log(`[tool-registry] Trimmed ${removed} tools to satisfy max_tools=${maxTools}. Final plugin tool count=${currentCount}.`);
 }
 function createToolRegistry(args) {
-  const { ctx, pluginConfig, managers, skillContext, availableCategories } = args;
-  const tmuxIntegrationEnabled = isTmuxIntegrationEnabled(pluginConfig);
+  const {
+    ctx,
+    pluginConfig,
+    managers,
+    skillContext,
+    availableCategories,
+    interactiveBashEnabled = isInteractiveBashEnabled()
+  } = args;
   const backgroundTools = createBackgroundTools(managers.backgroundManager, ctx.client);
   const callOmoAgent = createCallOmoAgent(ctx, managers.backgroundManager, pluginConfig.disabled_agents ?? [], pluginConfig.agents, pluginConfig.categories);
   const isMultimodalLookerEnabled = !(pluginConfig.disabled_agents ?? []).some((agent) => agent.toLowerCase() === "multimodal-looker");
@@ -143829,7 +144169,7 @@ function createToolRegistry(args) {
     task: delegateTask,
     skill_mcp: skillMcpTool,
     skill: skillTool,
-    ...tmuxIntegrationEnabled ? { interactive_bash } : {},
+    ...interactiveBashEnabled ? { interactive_bash } : {},
     ...taskToolsRecord,
     ...hashlineToolsRecord
   };
@@ -144122,10 +144462,10 @@ function createChatHeadersHandler(args) {
 
 // src/plugin/ultrawork-db-model-override.ts
 import { Database } from "bun:sqlite";
-import { join as join95 } from "path";
+import { join as join96 } from "path";
 import { existsSync as existsSync86 } from "fs";
 function getDbPath() {
-  return join95(getDataDir(), "opencode", "opencode.db");
+  return join96(getDataDir(), "opencode", "opencode.db");
 }
 var MAX_MICROTASK_RETRIES = 10;
 function tryUpdateMessageModel(db, messageId, targetModel, variant) {
@@ -144676,11 +145016,12 @@ function applyUserConfiguredFallbackChain(sessionID, agentName, currentProviderI
     setSessionFallbackChain(sessionID, fallbackChain);
   }
 }
-function isCompactionAgent5(agent) {
+function isCompactionAgent6(agent) {
   return agent.toLowerCase() === "compaction";
 }
 function createEventHandler2(args) {
-  const { ctx, firstMessageVariantGate, managers, hooks: hooks2 } = args;
+  const { ctx, pluginConfig, firstMessageVariantGate, managers, hooks: hooks2 } = args;
+  const tmuxIntegrationEnabled = isTmuxIntegrationEnabled(pluginConfig);
   const pluginContext = ctx;
   const isRuntimeFallbackEnabled = hooks2.runtimeFallback !== null && hooks2.runtimeFallback !== undefined && (typeof args.pluginConfig.runtime_fallback === "boolean" ? args.pluginConfig.runtime_fallback : args.pluginConfig.runtime_fallback?.enabled ?? false);
   const isModelFallbackEnabled = hooks2.modelFallback !== null && hooks2.modelFallback !== undefined;
@@ -144823,7 +145164,7 @@ function createEventHandler2(args) {
     }
     const { event } = input;
     const props = event.properties;
-    if (TMUX_ACTIVITY_EVENT_TYPES.has(event.type)) {
+    if (tmuxIntegrationEnabled && TMUX_ACTIVITY_EVENT_TYPES.has(event.type)) {
       managers.tmuxSessionManager.onEvent?.(event);
     }
     if (event.type === "session.created") {
@@ -144832,7 +145173,9 @@ function createEventHandler2(args) {
         setMainSession(sessionInfo?.id);
       }
       firstMessageVariantGate.markSessionCreated(sessionInfo);
-      await managers.tmuxSessionManager.onSessionCreated(event);
+      if (tmuxIntegrationEnabled) {
+        await managers.tmuxSessionManager.onSessionCreated(event);
+      }
     }
     if (event.type === "session.deleted") {
       const sessionInfo = props?.info;
@@ -144860,9 +145203,11 @@ function createEventHandler2(args) {
         deleteSessionTools(sessionInfo.id);
         await managers.skillMcpManager.disconnectSession(sessionInfo.id);
         await lspManager.cleanupTempDirectoryClients();
-        await managers.tmuxSessionManager.onSessionDeleted({
-          sessionID: sessionInfo.id
-        });
+        if (tmuxIntegrationEnabled) {
+          await managers.tmuxSessionManager.onSessionDeleted({
+            sessionID: sessionInfo.id
+          });
+        }
       }
     }
     if (event.type === "message.removed") {
@@ -144876,7 +145221,7 @@ function createEventHandler2(args) {
       const agent = info?.agent;
       const role = info?.role;
       if (sessionID && role === "user") {
-        const isCompactionMessage = agent ? isCompactionAgent5(agent) : false;
+        const isCompactionMessage = agent ? isCompactionAgent6(agent) : false;
         if (agent && !isCompactionMessage) {
           updateSessionAgent(sessionID, agent);
         }