oh-my-opencode 3.0.0-beta.7 → 3.0.0-beta.8

package/dist/index.js

@@ -4245,7 +4245,8 @@ var init_migration = __esm(() => {
     explore: "explore",
     "frontend-ui-ux-engineer": "frontend-ui-ux-engineer",
     "document-writer": "document-writer",
-    "multimodal-looker": "multimodal-looker"
+    "multimodal-looker": "multimodal-looker",
+    "orchestrator-sisyphus": "orchestrator-sisyphus"
   };
   BUILTIN_AGENT_NAMES = new Set([
     "Sisyphus",
@@ -4629,6 +4630,115 @@ function applyAgentVariant(config, agentName, message) {
   }
 }
 
+// src/shared/session-cursor.ts
+function buildMessageKey(message, index) {
+  const id = message.info?.id;
+  if (id)
+    return `id:${id}`;
+  const time = message.info?.time;
+  if (typeof time === "number" || typeof time === "string") {
+    return `t:${time}:${index}`;
+  }
+  const created = time?.created;
+  if (typeof created === "number") {
+    return `t:${created}:${index}`;
+  }
+  if (typeof created === "string") {
+    return `t:${created}:${index}`;
+  }
+  return `i:${index}`;
+}
+function consumeNewMessages(sessionID, messages) {
+  if (!sessionID)
+    return messages;
+  const keys = messages.map((message, index) => buildMessageKey(message, index));
+  const cursor = sessionCursors.get(sessionID);
+  let startIndex = 0;
+  if (cursor) {
+    if (cursor.lastCount > messages.length) {
+      startIndex = 0;
+    } else if (cursor.lastKey) {
+      const lastIndex = keys.lastIndexOf(cursor.lastKey);
+      if (lastIndex >= 0) {
+        startIndex = lastIndex + 1;
+      } else {
+        startIndex = 0;
+      }
+    }
+  }
+  if (messages.length === 0) {
+    sessionCursors.delete(sessionID);
+  } else {
+    sessionCursors.set(sessionID, {
+      lastKey: keys[keys.length - 1],
+      lastCount: messages.length
+    });
+  }
+  return messages.slice(startIndex);
+}
+function resetMessageCursor(sessionID) {
+  if (sessionID) {
+    sessionCursors.delete(sessionID);
+    return;
+  }
+  sessionCursors.clear();
+}
+var sessionCursors;
+var init_session_cursor = __esm(() => {
+  sessionCursors = new Map;
+});
+
+// src/shared/shell-env.ts
+function detectShellType() {
+  if (process.env.PSModulePath) {
+    return "powershell";
+  }
+  if (process.env.SHELL) {
+    return "unix";
+  }
+  return process.platform === "win32" ? "cmd" : "unix";
+}
+function shellEscape(value, shellType) {
+  if (value === "") {
+    return shellType === "cmd" ? '""' : "''";
+  }
+  switch (shellType) {
+    case "unix":
+      if (/[^a-zA-Z0-9_\-.:\/]/.test(value)) {
+        return `'${value.replace(/'/g, "'\\''")}'`;
+      }
+      return value;
+    case "powershell":
+      return `'${value.replace(/'/g, "''")}'`;
+    case "cmd":
+      return `"${value.replace(/%/g, "%%").replace(/"/g, '""')}"`;
+    default:
+      return value;
+  }
+}
+function buildEnvPrefix(env, shellType) {
+  const entries = Object.entries(env);
+  if (entries.length === 0) {
+    return "";
+  }
+  switch (shellType) {
+    case "unix": {
+      const assignments = entries.map(([key, value]) => `${key}=${shellEscape(value, shellType)}`).join(" ");
+      return `export ${assignments};`;
+    }
+    case "powershell": {
+      const assignments = entries.map(([key, value]) => `$env:${key}=${shellEscape(value, shellType)}`).join("; ");
+      return `${assignments};`;
+    }
+    case "cmd": {
+      const assignments = entries.map(([key, value]) => `set ${key}=${shellEscape(value, shellType)}`).join(" && ");
+      return `${assignments} &&`;
+    }
+    default:
+      return "";
+  }
+}
+
 // src/shared/index.ts
 var init_shared = __esm(() => {
   init_frontmatter();
@@ -4651,6 +4761,7 @@ var init_shared = __esm(() => {
   init_permission_compat();
   init_external_plugin_detector();
   init_zip_extractor();
+  init_session_cursor();
 });
 
 // node_modules/picomatch/lib/constants.js
@@ -14097,7 +14208,7 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
       }
     }).catch(() => {});
   }
-  async function injectContinuation(sessionID, incompleteCount, total) {
+  async function injectContinuation(sessionID, incompleteCount, total, resolvedInfo) {
     const state2 = sessions.get(sessionID);
     if (state2?.isRecovering) {
       log(`[${HOOK_NAME}] Skipped injection: in recovery`, { sessionID });
@@ -14121,29 +14232,37 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
       log(`[${HOOK_NAME}] Skipped injection: no incomplete todos`, { sessionID });
       return;
     }
-    const messageDir = getMessageDir(sessionID);
-    const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
-    const agentName = prevMessage?.agent;
+    let agentName = resolvedInfo?.agent;
+    let model = resolvedInfo?.model;
+    let tools = resolvedInfo?.tools;
+    if (!agentName || !model) {
+      const messageDir = getMessageDir(sessionID);
+      const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
+      agentName = agentName ?? prevMessage?.agent;
+      model = model ?? (prevMessage?.model?.providerID && prevMessage?.model?.modelID ? { providerID: prevMessage.model.providerID, modelID: prevMessage.model.modelID } : undefined);
+      tools = tools ?? prevMessage?.tools;
+    }
     if (agentName && skipAgents.includes(agentName)) {
       log(`[${HOOK_NAME}] Skipped: agent in skipAgents list`, { sessionID, agent: agentName });
       return;
     }
-    const editPermission = prevMessage?.tools?.edit;
-    const writePermission = prevMessage?.tools?.write;
-    const hasWritePermission = !prevMessage?.tools || editPermission !== false && editPermission !== "deny" && (writePermission !== false && writePermission !== "deny");
+    const editPermission = tools?.edit;
+    const writePermission = tools?.write;
+    const hasWritePermission = !tools || editPermission !== false && editPermission !== "deny" && (writePermission !== false && writePermission !== "deny");
     if (!hasWritePermission) {
-      log(`[${HOOK_NAME}] Skipped: agent lacks write permission`, { sessionID, agent: prevMessage?.agent });
+      log(`[${HOOK_NAME}] Skipped: agent lacks write permission`, { sessionID, agent: agentName });
       return;
     }
     const prompt = `${CONTINUATION_PROMPT}
 
 [Status: ${todos.length - freshIncompleteCount}/${todos.length} completed, ${freshIncompleteCount} remaining]`;
     try {
-      log(`[${HOOK_NAME}] Injecting continuation`, { sessionID, agent: prevMessage?.agent, incompleteCount: freshIncompleteCount });
+      log(`[${HOOK_NAME}] Injecting continuation`, { sessionID, agent: agentName, model, incompleteCount: freshIncompleteCount });
       await ctx.client.session.prompt({
         path: { id: sessionID },
         body: {
-          agent: prevMessage?.agent,
+          agent: agentName,
+          ...model !== undefined ? { model } : {},
           parts: [{ type: "text", text: prompt }]
         },
         query: { directory: ctx.directory }
@@ -14153,7 +14272,7 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
       log(`[${HOOK_NAME}] Injection failed`, { sessionID, error: String(err) });
     }
   }
-  function startCountdown(sessionID, incompleteCount, total) {
+  function startCountdown(sessionID, incompleteCount, total, resolvedInfo) {
     const state2 = getState(sessionID);
     cancelCountdown(sessionID);
     let secondsRemaining = COUNTDOWN_SECONDS;
@@ -14167,7 +14286,7 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
     }, 1000);
     state2.countdownTimer = setTimeout(() => {
       cancelCountdown(sessionID);
-      injectContinuation(sessionID, incompleteCount, total);
+      injectContinuation(sessionID, incompleteCount, total, resolvedInfo);
     }, COUNTDOWN_SECONDS * 1000);
     log(`[${HOOK_NAME}] Countdown started`, { sessionID, seconds: COUNTDOWN_SECONDS, incompleteCount });
   }
@@ -14249,27 +14368,32 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
         log(`[${HOOK_NAME}] All todos complete`, { sessionID, total: todos.length });
         return;
       }
-      let agentName;
+      let resolvedInfo;
       try {
         const messagesResp = await ctx.client.session.messages({
           path: { id: sessionID }
         });
         const messages = messagesResp.data ?? [];
         for (let i = messages.length - 1;i >= 0; i--) {
-          if (messages[i].info?.agent) {
-            agentName = messages[i].info?.agent;
+          const info = messages[i].info;
+          if (info?.agent || info?.model) {
+            resolvedInfo = {
+              agent: info.agent,
+              model: info.model,
+              tools: info.tools
+            };
             break;
           }
         }
       } catch (err) {
         log(`[${HOOK_NAME}] Failed to fetch messages for agent check`, { sessionID, error: String(err) });
       }
-      log(`[${HOOK_NAME}] Agent check`, { sessionID, agentName, skipAgents });
-      if (agentName && skipAgents.includes(agentName)) {
-        log(`[${HOOK_NAME}] Skipped: agent in skipAgents list`, { sessionID, agent: agentName });
+      log(`[${HOOK_NAME}] Agent check`, { sessionID, agentName: resolvedInfo?.agent, skipAgents });
+      if (resolvedInfo?.agent && skipAgents.includes(resolvedInfo.agent)) {
+        log(`[${HOOK_NAME}] Skipped: agent in skipAgents list`, { sessionID, agent: resolvedInfo.agent });
         return;
       }
-      startCountdown(sessionID, incompleteCount, todos.length);
+      startCountdown(sessionID, incompleteCount, todos.length, resolvedInfo);
       return;
     }
     if (event.type === "message.updated") {
@@ -15510,6 +15634,9 @@ async function getCommentCheckerPath() {
   })();
   return initPromise;
 }
+function getCommentCheckerPathSync() {
+  return resolvedCliPath ?? findCommentCheckerPathSync();
+}
 function startBackgroundInit() {
   if (!initPromise) {
     initPromise = getCommentCheckerPath();
@@ -15520,9 +15647,8 @@ function startBackgroundInit() {
     });
   }
 }
-var COMMENT_CHECKER_CLI_PATH = findCommentCheckerPathSync();
 async function runCommentChecker(input, cliPath, customPrompt) {
-  const binaryPath = cliPath ?? resolvedCliPath ?? COMMENT_CHECKER_CLI_PATH;
+  const binaryPath = cliPath ?? resolvedCliPath ?? getCommentCheckerPathSync();
   if (!binaryPath) {
     debugLog2("comment-checker binary not found");
     return { hasComments: false, message: "" };
@@ -15698,8 +15824,6 @@ var TRUNCATABLE_TOOLS = [
   "glob",
   "Glob",
   "safe_glob",
-  "lsp_find_references",
-  "lsp_symbols",
   "lsp_diagnostics",
   "ast_grep_search",
   "interactive_bash",
@@ -19901,7 +20025,7 @@ THE USER ASKED FOR X. DELIVER EXACTLY X. NOT A SUBSET. NOT A DEMO. NOT A STARTIN
 }
 var KEYWORD_DETECTORS = [
   {
-    pattern: /(ultrawork|ulw)/i,
+    pattern: /\b(ultrawork|ulw)\b/i,
     message: getUltraworkMessage
   },
   {
@@ -20067,6 +20191,23 @@ EOF`,
   }
 };
 
+// src/hooks/non-interactive-env/detector.ts
+function isNonInteractive() {
+  if (process.env.CI === "true" || process.env.CI === "1") {
+    return true;
+  }
+  if (process.env.OPENCODE_RUN === "true" || process.env.OPENCODE_NON_INTERACTIVE === "true") {
+    return true;
+  }
+  if (process.env.GITHUB_ACTIONS === "true") {
+    return true;
+  }
+  if (process.stdout.isTTY !== true) {
+    return true;
+  }
+  return false;
+}
+
 // src/hooks/non-interactive-env/index.ts
 init_shared();
 var BANNED_COMMAND_PATTERNS = SHELL_COMMAND_PATTERNS.banned.filter((cmd) => !cmd.includes("(")).map((cmd) => new RegExp(`\\b${cmd}\\b`));
@@ -20078,18 +20219,6 @@ function detectBannedCommand(command) {
   }
   return;
 }
-function shellEscape(value) {
-  if (value === "")
-    return "''";
-  if (/[^a-zA-Z0-9_\-.:\/]/.test(value)) {
-    return `'${value.replace(/'/g, "'\\''")}'`;
-  }
-  return value;
-}
-function buildEnvPrefix(env) {
-  const exports = Object.entries(env).map(([key, value]) => `${key}=${shellEscape(value)}`).join(" ");
-  return `export ${exports};`;
-}
 function createNonInteractiveEnvHook(_ctx) {
   return {
     "tool.execute.before": async (input, output) => {
@@ -20108,7 +20237,11 @@ function createNonInteractiveEnvHook(_ctx) {
       if (!isGitCommand) {
         return;
       }
-      const envPrefix = buildEnvPrefix(NON_INTERACTIVE_ENV);
+      if (!isNonInteractive()) {
+        return;
+      }
+      const shellType = detectShellType();
+      const envPrefix = buildEnvPrefix(NON_INTERACTIVE_ENV, shellType);
       output.args.command = `${envPrefix} ${command}`;
       log(`[${HOOK_NAME2}] Prepended non-interactive env vars to git command`, {
         sessionID: input.sessionID,
@@ -20819,10 +20952,25 @@ function createRalphLoopHook(ctx, options) {
         }
       }).catch(() => {});
       try {
-        const messageDir = getMessageDir9(sessionID);
-        const currentMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
-        const agent = currentMessage?.agent;
-        const model = currentMessage?.model?.providerID && currentMessage?.model?.modelID ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID } : undefined;
+        let agent;
+        let model;
+        try {
+          const messagesResp = await ctx.client.session.messages({ path: { id: sessionID } });
+          const messages = messagesResp.data ?? [];
+          for (let i2 = messages.length - 1;i2 >= 0; i2--) {
+            const info = messages[i2].info;
+            if (info?.agent || info?.model) {
+              agent = info.agent;
+              model = info.model;
+              break;
+            }
+          }
+        } catch {
+          const messageDir = getMessageDir9(sessionID);
+          const currentMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
+          agent = currentMessage?.agent;
+          model = currentMessage?.model?.providerID && currentMessage?.model?.modelID ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID } : undefined;
+        }
         await ctx.client.session.prompt({
           path: { id: sessionID },
           body: {
@@ -20935,7 +21083,7 @@ function extractPromptText3(parts) {
 // src/hooks/auto-slash-command/executor.ts
 init_shared();
 init_file_utils();
-import { existsSync as existsSync36, readdirSync as readdirSync12, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync36, readdirSync as readdirSync12, readFileSync as readFileSync25 } from "fs";
 import { join as join45, basename as basename2, dirname as dirname8 } from "path";
 import { homedir as homedir14 } from "os";
 // src/features/opencode-skill-loader/loader.ts
@@ -22573,6 +22721,46 @@ function createBuiltinSkills() {
 }
 
 // src/features/opencode-skill-loader/skill-content.ts
+init_frontmatter();
+import { readFileSync as readFileSync24 } from "fs";
+var cachedSkills = null;
+async function getAllSkills() {
+  if (cachedSkills)
+    return cachedSkills;
+  const [discoveredSkills, builtinSkillDefs] = await Promise.all([
+    discoverSkills({ includeClaudeCodePaths: true }),
+    Promise.resolve(createBuiltinSkills())
+  ]);
+  const builtinSkillsAsLoaded = builtinSkillDefs.map((skill) => ({
+    name: skill.name,
+    definition: {
+      name: skill.name,
+      description: skill.description,
+      template: skill.template,
+      model: skill.model,
+      agent: skill.agent,
+      subtask: skill.subtask
+    },
+    scope: "builtin",
+    license: skill.license,
+    compatibility: skill.compatibility,
+    metadata: skill.metadata,
+    allowedTools: skill.allowedTools,
+    mcpConfig: skill.mcpConfig
+  }));
+  const discoveredNames = new Set(discoveredSkills.map((s) => s.name));
+  const uniqueBuiltins = builtinSkillsAsLoaded.filter((s) => !discoveredNames.has(s.name));
+  cachedSkills = [...discoveredSkills, ...uniqueBuiltins];
+  return cachedSkills;
+}
+async function extractSkillTemplate(skill) {
+  if (skill.path) {
+    const content = readFileSync24(skill.path, "utf-8");
+    const { body } = parseFrontmatter(content);
+    return body.trim();
+  }
+  return skill.definition.template || "";
+}
 function injectGitMasterConfig(template, config) {
   if (!config)
     return template;
@@ -22608,6 +22796,29 @@ function resolveMultipleSkills(skillNames, options) {
   }
   return { resolved, notFound };
 }
+async function resolveMultipleSkillsAsync(skillNames, options) {
+  const allSkills = await getAllSkills();
+  const skillMap = new Map;
+  for (const skill of allSkills) {
+    skillMap.set(skill.name, skill);
+  }
+  const resolved = new Map;
+  const notFound = [];
+  for (const name of skillNames) {
+    const skill = skillMap.get(name);
+    if (skill) {
+      const template = await extractSkillTemplate(skill);
+      if (name === "git-master" && options?.gitMasterConfig) {
+        resolved.set(name, injectGitMasterConfig(template, options.gitMasterConfig));
+      } else {
+        resolved.set(name, template);
+      }
+    } else {
+      notFound.push(name);
+    }
+  }
+  return { resolved, notFound };
+}
 // src/hooks/auto-slash-command/executor.ts
 function discoverCommandsFromDir(commandsDir, scope) {
   if (!existsSync36(commandsDir)) {
@@ -22621,7 +22832,7 @@ function discoverCommandsFromDir(commandsDir, scope) {
     const commandPath = join45(commandsDir, entry.name);
     const commandName = basename2(entry.name, ".md");
     try {
-      const content = readFileSync24(commandPath, "utf-8");
+      const content = readFileSync25(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -23001,7 +23212,7 @@ var NOTEPAD_DIR = "notepads";
 var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
 var PROMETHEUS_PLANS_DIR = ".sisyphus/plans";
 // src/features/boulder-state/storage.ts
-import { existsSync as existsSync38, readFileSync as readFileSync25, writeFileSync as writeFileSync15, mkdirSync as mkdirSync11, readdirSync as readdirSync14 } from "fs";
+import { existsSync as existsSync38, readFileSync as readFileSync26, writeFileSync as writeFileSync15, mkdirSync as mkdirSync11, readdirSync as readdirSync14 } from "fs";
 import { dirname as dirname9, join as join47, basename as basename3 } from "path";
 function getBoulderFilePath(directory) {
   return join47(directory, BOULDER_DIR, BOULDER_FILE);
@@ -23012,7 +23223,7 @@ function readBoulderState(directory) {
     return null;
   }
   try {
-    const content = readFileSync25(filePath, "utf-8");
+    const content = readFileSync26(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -23043,6 +23254,18 @@ function appendSessionId(directory, sessionId) {
   }
   return state2;
 }
+function clearBoulderState(directory) {
+  const filePath = getBoulderFilePath(directory);
+  try {
+    if (existsSync38(filePath)) {
+      const { unlinkSync: unlinkSync10 } = __require("fs");
+      unlinkSync10(filePath);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
 function findPrometheusPlans(directory) {
   const plansDir = join47(directory, PROMETHEUS_PLANS_DIR);
   if (!existsSync38(plansDir)) {
@@ -23064,7 +23287,7 @@ function getPlanProgress(planPath) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
-    const content = readFileSync25(planPath, "utf-8");
+    const content = readFileSync26(planPath, "utf-8");
     const uncheckedMatches = content.match(/^[-*]\s*\[\s*\]/gm) || [];
     const checkedMatches = content.match(/^[-*]\s*\[[xX]\]/gm) || [];
     const total = uncheckedMatches.length + checkedMatches.length;
@@ -23092,6 +23315,25 @@ function createBoulderState(planPath, sessionId) {
 // src/hooks/start-work/index.ts
 init_logger();
 var HOOK_NAME5 = "start-work";
+var KEYWORD_PATTERN = /\b(ultrawork|ulw)\b/gi;
+function extractUserRequestPlanName(promptText) {
+  const userRequestMatch = promptText.match(/<user-request>\s*([\s\S]*?)\s*<\/user-request>/i);
+  if (!userRequestMatch)
+    return null;
+  const rawArg = userRequestMatch[1].trim();
+  if (!rawArg)
+    return null;
+  const cleanedArg = rawArg.replace(KEYWORD_PATTERN, "").trim();
+  return cleanedArg || null;
+}
+function findPlanByName(plans, requestedName) {
+  const lowerName = requestedName.toLowerCase();
+  const exactMatch = plans.find((p) => getPlanName(p).toLowerCase() === lowerName);
+  if (exactMatch)
+    return exactMatch;
+  const partialMatch = plans.find((p) => getPlanName(p).toLowerCase().includes(lowerName));
+  return partialMatch || null;
+}
 function createStartWorkHook(ctx) {
   return {
     "chat.message": async (input, output) => {
@@ -23109,7 +23351,64 @@ function createStartWorkHook(ctx) {
       const sessionId = input.sessionID;
       const timestamp2 = new Date().toISOString();
       let contextInfo = "";
-      if (existingState) {
+      const explicitPlanName = extractUserRequestPlanName(promptText);
+      if (explicitPlanName) {
+        log(`[${HOOK_NAME5}] Explicit plan name requested: ${explicitPlanName}`, {
+          sessionID: input.sessionID
+        });
+        const allPlans = findPrometheusPlans(ctx.directory);
+        const matchedPlan = findPlanByName(allPlans, explicitPlanName);
+        if (matchedPlan) {
+          const progress = getPlanProgress(matchedPlan);
+          if (progress.isComplete) {
+            contextInfo = `
+## Plan Already Complete
+
+The requested plan "${getPlanName(matchedPlan)}" has been completed.
+All ${progress.total} tasks are done. Create a new plan with: /plan "your task"`;
+          } else {
+            if (existingState) {
+              clearBoulderState(ctx.directory);
+            }
+            const newState = createBoulderState(matchedPlan, sessionId);
+            writeBoulderState(ctx.directory, newState);
+            contextInfo = `
+## Auto-Selected Plan
+
+**Plan**: ${getPlanName(matchedPlan)}
+**Path**: ${matchedPlan}
+**Progress**: ${progress.completed}/${progress.total} tasks
+**Session ID**: ${sessionId}
+**Started**: ${timestamp2}
+
+boulder.json has been created. Read the plan and begin execution.`;
+          }
+        } else {
+          const incompletePlans = allPlans.filter((p) => !getPlanProgress(p).isComplete);
+          if (incompletePlans.length > 0) {
+            const planList = incompletePlans.map((p, i2) => {
+              const prog = getPlanProgress(p);
+              return `${i2 + 1}. [${getPlanName(p)}] - Progress: ${prog.completed}/${prog.total}`;
+            }).join(`
+`);
+            contextInfo = `
+## Plan Not Found
+
+Could not find a plan matching "${explicitPlanName}".
+
+Available incomplete plans:
+${planList}
+
+Ask the user which plan to work on.`;
+          } else {
+            contextInfo = `
+## Plan Not Found
+
+Could not find a plan matching "${explicitPlanName}".
+No incomplete plans available. Create a new plan with: /plan "your task"`;
+          }
+        }
+      } else if (existingState) {
         const progress = getPlanProgress(existingState.active_plan);
         if (!progress.isComplete) {
           appendSessionId(ctx.directory, sessionId);
@@ -23133,7 +23432,7 @@ The previous plan (${existingState.plan_name}) has been completed.
 Looking for new plans...`;
         }
       }
-      if (!existingState || getPlanProgress(existingState.active_plan).isComplete) {
+      if (!existingState && !explicitPlanName || existingState && !explicitPlanName && getPlanProgress(existingState.active_plan).isComplete) {
         const plans = findPrometheusPlans(ctx.directory);
         const incompletePlans = plans.filter((p) => !getPlanProgress(p).isComplete);
         if (plans.length === 0) {
@@ -23249,34 +23548,45 @@ RULES:
 - Use the notepad at .sisyphus/notepads/{PLAN_NAME}/ to record learnings
 - Do not stop until all tasks are complete
 - If blocked, document the blocker and move to the next task`;
-var VERIFICATION_REMINDER = `**MANDATORY VERIFICATION - SUBAGENTS LIE**
+var VERIFICATION_REMINDER = `**MANDATORY: WHAT YOU MUST DO RIGHT NOW**
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
 
-Subagents FREQUENTLY claim completion when:
-- Tests are actually FAILING
-- Code has type/lint ERRORS
-- Implementation is INCOMPLETE
-- Patterns were NOT followed
+\u26A0\uFE0F CRITICAL: Subagents FREQUENTLY LIE about completion.
+Tests FAILING, code has ERRORS, implementation INCOMPLETE - but they say "done".
 
-**YOU MUST VERIFY EVERYTHING YOURSELF:**
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
 
-1. Run \`lsp_diagnostics\` on changed files - Must be CLEAN
-2. Run tests yourself - Must PASS (not "agent said it passed")
-3. Read the actual code - Must match requirements
-4. Check build/typecheck - Must succeed
+**STEP 1: VERIFY WITH YOUR OWN TOOL CALLS (DO THIS NOW)**
 
-DO NOT TRUST THE AGENT'S SELF-REPORT.
-VERIFY EACH CLAIM WITH YOUR OWN TOOL CALLS.
+Run these commands YOURSELF - do NOT trust agent's claims:
+1. \`lsp_diagnostics\` on changed files \u2192 Must be CLEAN
+2. \`bash\` to run tests \u2192 Must PASS
+3. \`bash\` to run build/typecheck \u2192 Must succeed
+4. \`Read\` the actual code \u2192 Must match requirements
 
-**HANDS-ON QA REQUIRED (after ALL tasks complete):**
+**STEP 2: DETERMINE IF HANDS-ON QA IS NEEDED**
 
-| Deliverable Type | Verification Tool | Action |
-|------------------|-------------------|--------|
-| **Frontend/UI** | \`/playwright\` skill | Navigate, interact, screenshot evidence |
-| **TUI/CLI** | \`interactive_bash\` (tmux) | Run interactively, verify output |
-| **API/Backend** | \`bash\` with curl | Send requests, verify responses |
+| Deliverable Type | QA Method | Tool |
+|------------------|-----------|------|
+| **Frontend/UI** | Browser interaction | \`/playwright\` skill |
+| **TUI/CLI** | Run interactively | \`interactive_bash\` (tmux) |
+| **API/Backend** | Send real requests | \`bash\` with curl |
 
-Static analysis CANNOT catch: visual bugs, animation issues, user flow breakages, integration problems.
-**FAILURE TO DO HANDS-ON QA = INCOMPLETE WORK.**`;
+Static analysis CANNOT catch: visual bugs, animation issues, user flow breakages.
+
+**STEP 3: IF QA IS NEEDED - ADD TO TODO IMMEDIATELY**
+
+\`\`\`
+todowrite([
+  { id: "qa-X", content: "HANDS-ON QA: [specific verification action]", status: "pending", priority: "high" }
+])
+\`\`\`
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+**BLOCKING: DO NOT proceed to next task until Steps 1-3 are complete.**
+**FAILURE TO DO QA = INCOMPLETE WORK = USER WILL REJECT.**`;
 var ORCHESTRATOR_DELEGATION_REQUIRED = `
 
 ---
@@ -23365,19 +23675,37 @@ function buildOrchestratorReminder(planName, progress, sessionId) {
   return `
 ---
 
-**State:** Plan: ${planName} | ${progress.completed}/${progress.total} done, ${remaining} left
+**BOULDER STATE:** Plan: \`${planName}\` | \u2705 ${progress.completed}/${progress.total} done | \u23F3 ${remaining} remaining
 
 ---
 
 ${buildVerificationReminder(sessionId)}
 
-ALL pass? \u2192 commit atomic unit, mark \`[x]\`, next task.`;
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+**AFTER VERIFICATION PASSES - YOUR NEXT ACTIONS (IN ORDER):**
+
+1. **COMMIT** atomic unit (only verified changes)
+2. **MARK** \`[x]\` in plan file for completed task
+3. **PROCEED** to next task immediately
+
+**DO NOT STOP. ${remaining} tasks remain. Keep bouldering.**`;
 }
 function buildStandaloneVerificationReminder(sessionId) {
   return `
 ---
 
-${buildVerificationReminder(sessionId)}`;
+${buildVerificationReminder(sessionId)}
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+**AFTER VERIFICATION - CHECK YOUR TODO LIST:**
+
+1. Run \`todoread\` to see remaining tasks
+2. If QA tasks exist \u2192 execute them BEFORE marking complete
+3. Mark completed tasks \u2192 proceed to next pending task
+
+**NO TODO = NO TRACKING = INCOMPLETE WORK. Use todowrite aggressively.**`;
 }
 function extractSessionIdFromOutput(output) {
   const match = output.match(/Session ID:\s*(ses_[a-zA-Z0-9]+)/);
@@ -23539,9 +23867,22 @@ function createSisyphusOrchestratorHook(ctx, options) {
 [Status: ${total - remaining}/${total} completed, ${remaining} remaining]`;
     try {
       log(`[${HOOK_NAME6}] Injecting boulder continuation`, { sessionID, planName, remaining });
-      const messageDir = getMessageDir11(sessionID);
-      const currentMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
-      const model = currentMessage?.model?.providerID && currentMessage?.model?.modelID ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID } : undefined;
+      let model;
+      try {
+        const messagesResp = await ctx.client.session.messages({ path: { id: sessionID } });
+        const messages = messagesResp.data ?? [];
+        for (let i2 = messages.length - 1;i2 >= 0; i2--) {
+          const msgModel = messages[i2].info?.model;
+          if (msgModel?.providerID && msgModel?.modelID) {
+            model = { providerID: msgModel.providerID, modelID: msgModel.modelID };
+            break;
+          }
+        }
+      } catch {
+        const messageDir = getMessageDir11(sessionID);
+        const currentMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
+        model = currentMessage?.model?.providerID && currentMessage?.model?.modelID ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID } : undefined;
+      }
       await ctx.client.session.prompt({
         path: { id: sessionID },
         body: {
@@ -23762,6 +24103,118 @@ ${buildStandaloneVerificationReminder(subagentSessionId)}
     }
   };
 }
+// src/hooks/sisyphus-task-retry/index.ts
+var SISYPHUS_TASK_ERROR_PATTERNS = [
+  {
+    pattern: "run_in_background",
+    errorType: "missing_run_in_background",
+    fixHint: "Add run_in_background=false (for delegation) or run_in_background=true (for parallel exploration)"
+  },
+  {
+    pattern: "skills",
+    errorType: "missing_skills",
+    fixHint: "Add skills=[] parameter (empty array if no skills needed)"
+  },
+  {
+    pattern: "category OR subagent_type",
+    errorType: "mutual_exclusion",
+    fixHint: "Provide ONLY one of: category (e.g., 'general', 'quick') OR subagent_type (e.g., 'oracle', 'explore')"
+  },
+  {
+    pattern: "Must provide either category or subagent_type",
+    errorType: "missing_category_or_agent",
+    fixHint: "Add either category='general' OR subagent_type='explore'"
+  },
+  {
+    pattern: "Unknown category",
+    errorType: "unknown_category",
+    fixHint: "Use a valid category from the Available list in the error message"
+  },
+  {
+    pattern: "Agent name cannot be empty",
+    errorType: "empty_agent",
+    fixHint: "Provide a non-empty subagent_type value"
+  },
+  {
+    pattern: "Unknown agent",
+    errorType: "unknown_agent",
+    fixHint: "Use a valid agent from the Available agents list in the error message"
+  },
+  {
+    pattern: "Cannot call primary agent",
+    errorType: "primary_agent",
+    fixHint: "Primary agents cannot be called via sisyphus_task. Use a subagent like 'explore', 'oracle', or 'librarian'"
+  },
+  {
+    pattern: "Skills not found",
+    errorType: "unknown_skills",
+    fixHint: "Use valid skill names from the Available list in the error message"
+  }
+];
+function detectSisyphusTaskError(output) {
+  if (!output.includes("\u274C"))
+    return null;
+  for (const errorPattern of SISYPHUS_TASK_ERROR_PATTERNS) {
+    if (output.includes(errorPattern.pattern)) {
+      return {
+        errorType: errorPattern.errorType,
+        originalOutput: output
+      };
+    }
+  }
+  return null;
+}
+function extractAvailableList(output) {
+  const availableMatch = output.match(/Available[^:]*:\s*(.+)$/m);
+  return availableMatch ? availableMatch[1].trim() : null;
+}
+function buildRetryGuidance(errorInfo) {
+  const pattern = SISYPHUS_TASK_ERROR_PATTERNS.find((p) => p.errorType === errorInfo.errorType);
+  if (!pattern) {
+    return `[sisyphus_task ERROR] Fix the error and retry with correct parameters.`;
+  }
+  let guidance = `
+[sisyphus_task CALL FAILED - IMMEDIATE RETRY REQUIRED]
+
+**Error Type**: ${errorInfo.errorType}
+**Fix**: ${pattern.fixHint}
+`;
+  const availableList = extractAvailableList(errorInfo.originalOutput);
+  if (availableList) {
+    guidance += `
+**Available Options**: ${availableList}
+`;
+  }
+  guidance += `
+**Action**: Retry sisyphus_task NOW with corrected parameters.
+
+Example of CORRECT call:
+\`\`\`
+sisyphus_task(
+  description="Task description",
+  prompt="Detailed prompt...",
+  category="general",  // OR subagent_type="explore"
+  run_in_background=false,
+  skills=[]
+)
+\`\`\`
+`;
+  return guidance;
+}
+function createSisyphusTaskRetryHook(_ctx) {
+  return {
+    "tool.execute.after": async (input, output) => {
+      if (input.tool.toLowerCase() !== "sisyphus_task")
+        return;
+      const errorInfo = detectSisyphusTaskError(output.output);
+      if (errorInfo) {
+        const guidance = buildRetryGuidance(errorInfo);
+        output.output += `
+${guidance}`;
+      }
+    }
+  };
+}
 // src/features/context-injector/collector.ts
 var PRIORITY_ORDER = {
   critical: 0,
@@ -23962,7 +24415,7 @@ function createFirstMessageVariantGate() {
 }
 // src/features/claude-code-mcp-loader/loader.ts
 init_shared();
-import { existsSync as existsSync40, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync40, readFileSync as readFileSync27 } from "fs";
 import { join as join49 } from "path";
 
 // src/features/claude-code-mcp-loader/env-expander.ts
@@ -24057,7 +24510,7 @@ function getSystemMcpServerNames() {
     if (!existsSync40(path8))
       continue;
     try {
-      const content = readFileSync26(path8, "utf-8");
+      const content = readFileSync27(path8, "utf-8");
       const config = JSON.parse(content);
       if (!config?.mcpServers)
         continue;
@@ -24102,42 +24555,12 @@ async function loadMcpConfigs() {
   return { servers, loadedServers };
 }
 // src/tools/lsp/constants.ts
-var SYMBOL_KIND_MAP = {
-  1: "File",
-  2: "Module",
-  3: "Namespace",
-  4: "Package",
-  5: "Class",
-  6: "Method",
-  7: "Property",
-  8: "Field",
-  9: "Constructor",
-  10: "Enum",
-  11: "Interface",
-  12: "Function",
-  13: "Variable",
-  14: "Constant",
-  15: "String",
-  16: "Number",
-  17: "Boolean",
-  18: "Array",
-  19: "Object",
-  20: "Key",
-  21: "Null",
-  22: "EnumMember",
-  23: "Struct",
-  24: "Event",
-  25: "Operator",
-  26: "TypeParameter"
-};
 var SEVERITY_MAP = {
   1: "error",
   2: "warning",
   3: "information",
   4: "hint"
 };
-var DEFAULT_MAX_REFERENCES = 200;
-var DEFAULT_MAX_SYMBOLS = 200;
 var DEFAULT_MAX_DIAGNOSTICS = 200;
 var LSP_INSTALL_HINTS = {
   typescript: "npm install -g typescript-language-server typescript",
@@ -24178,7 +24601,8 @@ var LSP_INSTALL_HINTS = {
   nixd: "nix profile install nixpkgs#nixd",
   tinymist: "See https://github.com/Myriad-Dreamin/tinymist",
   "haskell-language-server": "ghcup install hls",
-  bash: "npm install -g bash-language-server"
+  bash: "npm install -g bash-language-server",
+  "kotlin-ls": "See https://github.com/Kotlin/kotlin-lsp"
 };
 var BUILTIN_SERVERS = {
   typescript: {
@@ -24354,6 +24778,10 @@ var BUILTIN_SERVERS = {
   "haskell-language-server": {
     command: ["haskell-language-server-wrapper", "--lsp"],
     extensions: [".hs", ".lhs"]
+  },
+  "kotlin-ls": {
+    command: ["kotlin-lsp"],
+    extensions: [".kt", ".kts"]
   }
 };
 var EXT_TO_LANG = {
@@ -24489,14 +24917,14 @@ var EXT_TO_LANG = {
   ".gql": "graphql"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync41, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync41, readFileSync as readFileSync28 } from "fs";
 import { join as join50 } from "path";
 import { homedir as homedir15 } from "os";
 function loadJsonFile(path8) {
   if (!existsSync41(path8))
     return null;
   try {
-    return JSON.parse(readFileSync27(path8, "utf-8"));
+    return JSON.parse(readFileSync28(path8, "utf-8"));
   } catch {
     return null;
   }
@@ -24695,7 +25123,7 @@ function getAllServers() {
 }
 // src/tools/lsp/client.ts
 var {spawn: spawn6 } = globalThis.Bun;
-import { readFileSync as readFileSync28 } from "fs";
+import { readFileSync as readFileSync29 } from "fs";
 import { extname, resolve as resolve8 } from "path";
 import { pathToFileURL } from "url";
 class LSPServerManager {
@@ -25145,7 +25573,7 @@ ${msg}`);
     const absPath = resolve8(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync28(absPath, "utf-8");
+    const text = readFileSync29(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -25159,41 +25587,6 @@ ${msg}`);
     this.openedFiles.add(absPath);
     await new Promise((r) => setTimeout(r, 1000));
   }
-  async hover(filePath, line, character) {
-    const absPath = resolve8(filePath);
-    await this.openFile(absPath);
-    return this.send("textDocument/hover", {
-      textDocument: { uri: pathToFileURL(absPath).href },
-      position: { line: line - 1, character }
-    });
-  }
-  async definition(filePath, line, character) {
-    const absPath = resolve8(filePath);
-    await this.openFile(absPath);
-    return this.send("textDocument/definition", {
-      textDocument: { uri: pathToFileURL(absPath).href },
-      position: { line: line - 1, character }
-    });
-  }
-  async references(filePath, line, character, includeDeclaration = true) {
-    const absPath = resolve8(filePath);
-    await this.openFile(absPath);
-    return this.send("textDocument/references", {
-      textDocument: { uri: pathToFileURL(absPath).href },
-      position: { line: line - 1, character },
-      context: { includeDeclaration }
-    });
-  }
-  async documentSymbols(filePath) {
-    const absPath = resolve8(filePath);
-    await this.openFile(absPath);
-    return this.send("textDocument/documentSymbol", {
-      textDocument: { uri: pathToFileURL(absPath).href }
-    });
-  }
-  async workspaceSymbols(query) {
-    return this.send("workspace/symbol", { query });
-  }
   async diagnostics(filePath) {
     const absPath = resolve8(filePath);
     const uri = pathToFileURL(absPath).href;
@@ -25226,24 +25619,6 @@ ${msg}`);
       newName
     });
   }
-  async codeAction(filePath, startLine, startChar, endLine, endChar, only) {
-    const absPath = resolve8(filePath);
-    await this.openFile(absPath);
-    return this.send("textDocument/codeAction", {
-      textDocument: { uri: pathToFileURL(absPath).href },
-      range: {
-        start: { line: startLine - 1, character: startChar },
-        end: { line: endLine - 1, character: endChar }
-      },
-      context: {
-        diagnostics: [],
-        only
-      }
-    });
-  }
-  async codeActionResolve(codeAction) {
-    return this.send("codeAction/resolve", codeAction);
-  }
   isAlive() {
     return this.proc !== null && !this.processExited && this.proc.exitCode === null;
   }
@@ -25261,7 +25636,7 @@ ${msg}`);
 // src/tools/lsp/utils.ts
 import { extname as extname2, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { existsSync as existsSync42, readFileSync as readFileSync29, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync30, writeFileSync as writeFileSync16 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve9(filePath);
   if (!existsSync42(dir) || !__require("fs").statSync(dir).isDirectory()) {
@@ -25341,45 +25716,11 @@ async function withLspClient(filePath, fn) {
     lspManager.releaseClient(root, server.id);
   }
 }
-function formatLocation(loc) {
-  if ("targetUri" in loc) {
-    const uri2 = uriToPath(loc.targetUri);
-    const line2 = loc.targetRange.start.line + 1;
-    const char2 = loc.targetRange.start.character;
-    return `${uri2}:${line2}:${char2}`;
-  }
-  const uri = uriToPath(loc.uri);
-  const line = loc.range.start.line + 1;
-  const char = loc.range.start.character;
-  return `${uri}:${line}:${char}`;
-}
-function formatSymbolKind(kind) {
-  return SYMBOL_KIND_MAP[kind] || `Unknown(${kind})`;
-}
 function formatSeverity(severity) {
   if (!severity)
     return "unknown";
   return SEVERITY_MAP[severity] || `unknown(${severity})`;
 }
-function formatDocumentSymbol(symbol, indent = 0) {
-  const prefix = "  ".repeat(indent);
-  const kind = formatSymbolKind(symbol.kind);
-  const line = symbol.range.start.line + 1;
-  let result = `${prefix}${symbol.name} (${kind}) - line ${line}`;
-  if (symbol.children && symbol.children.length > 0) {
-    for (const child of symbol.children) {
-      result += `
-` + formatDocumentSymbol(child, indent + 1);
-    }
-  }
-  return result;
-}
-function formatSymbolInfo(symbol) {
-  const kind = formatSymbolKind(symbol.kind);
-  const loc = formatLocation(symbol.location);
-  const container = symbol.containerName ? ` (in ${symbol.containerName})` : "";
-  return `${symbol.name} (${kind})${container} - ${loc}`;
-}
 function formatDiagnostic(diag) {
   const severity = formatSeverity(diag.severity);
   const line = diag.range.start.line + 1;
@@ -25426,7 +25767,7 @@ function formatPrepareRenameResult(result) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync29(filePath, "utf-8");
+    let content = readFileSync30(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -25492,7 +25833,7 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = uriToPath(change.oldUri);
             const newPath = uriToPath(change.newUri);
-            const content = readFileSync29(oldPath, "utf-8");
+            const content = readFileSync30(oldPath, "utf-8");
             writeFileSync16(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
@@ -37866,128 +38207,6 @@ function tool(input) {
 tool.schema = exports_external;
 
 // src/tools/lsp/tools.ts
-var lsp_goto_definition = tool({
-  description: "Jump to symbol definition. Find WHERE something is defined.",
-  args: {
-    filePath: tool.schema.string(),
-    line: tool.schema.number().min(1).describe("1-based"),
-    character: tool.schema.number().min(0).describe("0-based")
-  },
-  execute: async (args, context) => {
-    try {
-      const result = await withLspClient(args.filePath, async (client) => {
-        return await client.definition(args.filePath, args.line, args.character);
-      });
-      if (!result) {
-        const output2 = "No definition found";
-        return output2;
-      }
-      const locations = Array.isArray(result) ? result : [result];
-      if (locations.length === 0) {
-        const output2 = "No definition found";
-        return output2;
-      }
-      const output = locations.map(formatLocation).join(`
-`);
-      return output;
-    } catch (e) {
-      const output = `Error: ${e instanceof Error ? e.message : String(e)}`;
-      return output;
-    }
-  }
-});
-var lsp_find_references = tool({
-  description: "Find ALL usages/references of a symbol across the entire workspace.",
-  args: {
-    filePath: tool.schema.string(),
-    line: tool.schema.number().min(1).describe("1-based"),
-    character: tool.schema.number().min(0).describe("0-based"),
-    includeDeclaration: tool.schema.boolean().optional().describe("Include the declaration itself")
-  },
-  execute: async (args, context) => {
-    try {
-      const result = await withLspClient(args.filePath, async (client) => {
-        return await client.references(args.filePath, args.line, args.character, args.includeDeclaration ?? true);
-      });
-      if (!result || result.length === 0) {
-        const output2 = "No references found";
-        return output2;
-      }
-      const total = result.length;
-      const truncated = total > DEFAULT_MAX_REFERENCES;
-      const limited = truncated ? result.slice(0, DEFAULT_MAX_REFERENCES) : result;
-      const lines = limited.map(formatLocation);
-      if (truncated) {
-        lines.unshift(`Found ${total} references (showing first ${DEFAULT_MAX_REFERENCES}):`);
-      }
-      const output = lines.join(`
-`);
-      return output;
-    } catch (e) {
-      const output = `Error: ${e instanceof Error ? e.message : String(e)}`;
-      return output;
-    }
-  }
-});
-var lsp_symbols = tool({
-  description: "Get symbols from file (document) or search across workspace. Use scope='document' for file outline, scope='workspace' for project-wide symbol search.",
-  args: {
-    filePath: tool.schema.string().describe("File path for LSP context"),
-    scope: tool.schema.enum(["document", "workspace"]).default("document").describe("'document' for file symbols, 'workspace' for project-wide search"),
-    query: tool.schema.string().optional().describe("Symbol name to search (required for workspace scope)"),
-    limit: tool.schema.number().optional().describe("Max results (default 50)")
-  },
-  execute: async (args, context) => {
-    try {
-      const scope = args.scope ?? "document";
-      if (scope === "workspace") {
-        if (!args.query) {
-          return "Error: 'query' is required for workspace scope";
-        }
-        const result = await withLspClient(args.filePath, async (client) => {
-          return await client.workspaceSymbols(args.query);
-        });
-        if (!result || result.length === 0) {
-          return "No symbols found";
-        }
-        const total = result.length;
-        const limit = Math.min(args.limit ?? DEFAULT_MAX_SYMBOLS, DEFAULT_MAX_SYMBOLS);
-        const truncated = total > limit;
-        const limited = result.slice(0, limit);
-        const lines = limited.map(formatSymbolInfo);
-        if (truncated) {
-          lines.unshift(`Found ${total} symbols (showing first ${limit}):`);
-        }
-        return lines.join(`
-`);
-      } else {
-        const result = await withLspClient(args.filePath, async (client) => {
-          return await client.documentSymbols(args.filePath);
-        });
-        if (!result || result.length === 0) {
-          return "No symbols found";
-        }
-        const total = result.length;
-        const limit = Math.min(args.limit ?? DEFAULT_MAX_SYMBOLS, DEFAULT_MAX_SYMBOLS);
-        const truncated = total > limit;
-        const limited = truncated ? result.slice(0, limit) : result;
-        const lines = [];
-        if (truncated) {
-          lines.push(`Found ${total} symbols (showing first ${limit}):`);
-        }
-        if ("range" in limited[0]) {
-          lines.push(...limited.map((s) => formatDocumentSymbol(s)));
-        } else {
-          lines.push(...limited.map(formatSymbolInfo));
-        }
-        return lines.join(`
-`);
-      }
-    } catch (e) {
-      return `Error: ${e instanceof Error ? e.message : String(e)}`;
-    }
-  }
-});
 var lsp_diagnostics = tool({
   description: "Get errors, warnings, hints from language server BEFORE running build.",
   args: {
@@ -39222,7 +39441,7 @@ var glob = tool({
 init_shared();
 init_file_utils();
 init_shared();
-import { existsSync as existsSync48, readdirSync as readdirSync17, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync48, readdirSync as readdirSync17, readFileSync as readFileSync31 } from "fs";
 import { join as join55, basename as basename4, dirname as dirname12 } from "path";
 function discoverCommandsFromDir2(commandsDir, scope) {
   if (!existsSync48(commandsDir)) {
@@ -39236,7 +39455,7 @@ function discoverCommandsFromDir2(commandsDir, scope) {
     const commandPath = join55(commandsDir, entry.name);
     const commandName = basename4(entry.name, ".md");
     try {
-      const content = readFileSync30(commandPath, "utf-8");
+      const content = readFileSync31(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -39363,7 +39582,7 @@ ${commandListForDescription}
 }
 function createSlashcommandTool(options = {}) {
   let cachedCommands = options.commands ?? null;
-  let cachedSkills = options.skills ?? null;
+  let cachedSkills2 = options.skills ?? null;
   let cachedDescription = null;
   const getCommands = () => {
     if (cachedCommands)
@@ -39372,10 +39591,10 @@ function createSlashcommandTool(options = {}) {
     return cachedCommands;
   };
   const getSkills = async () => {
-    if (cachedSkills)
-      return cachedSkills;
-    cachedSkills = await discoverAllSkills();
-    return cachedSkills;
+    if (cachedSkills2)
+      return cachedSkills2;
+    cachedSkills2 = await discoverAllSkills();
+    return cachedSkills2;
   };
   const getAllItems = async () => {
     const commands = getCommands();
@@ -40116,7 +40335,28 @@ var interactive_bash = tool({
       }
       const subcommand = parts[0].toLowerCase();
       if (BLOCKED_TMUX_SUBCOMMANDS.includes(subcommand)) {
-        return `Error: '${parts[0]}' is blocked. Use bash tool instead for capturing/printing terminal output.`;
+        const sessionIdx = parts.findIndex((p) => p === "-t" || p.startsWith("-t"));
+        let sessionName = "omo-session";
+        if (sessionIdx !== -1) {
+          if (parts[sessionIdx] === "-t" && parts[sessionIdx + 1]) {
+            sessionName = parts[sessionIdx + 1];
+          } else if (parts[sessionIdx].startsWith("-t")) {
+            sessionName = parts[sessionIdx].slice(2);
+          }
+        }
+        return `Error: '${parts[0]}' is blocked in interactive_bash.
+
+**USE BASH TOOL INSTEAD:**
+
+\`\`\`bash
+# Capture terminal output
+tmux capture-pane -p -t ${sessionName}
+
+# Or capture with history (last 1000 lines)
+tmux capture-pane -p -t ${sessionName} -S -1000
+\`\`\`
+
+The Bash tool can execute these commands directly. Do NOT retry with interactive_bash.`;
       }
       const proc = Bun.spawn([tmuxPath2, ...parts], {
         stdout: "pipe",
@@ -40155,8 +40395,6 @@ Skills provide specialized knowledge and step-by-step guidance.
 Use this when a task matches an available skill's description.`;
 // src/tools/skill/tools.ts
 import { dirname as dirname13 } from "path";
-import { readFileSync as readFileSync31 } from "fs";
-init_frontmatter();
 function loadedSkillToInfo(skill) {
   return {
     name: skill.name,
@@ -40199,9 +40437,7 @@ async function extractSkillBody(skill) {
     return templateMatch2 ? templateMatch2[1].trim() : fullTemplate;
   }
   if (skill.path) {
-    const content = readFileSync31(skill.path, "utf-8");
-    const { body } = parseFrontmatter(content);
-    return body.trim();
+    return extractSkillTemplate(skill);
   }
   const templateMatch = skill.definition.template?.match(/<skill-instruction>([\s\S]*?)<\/skill-instruction>/);
   return templateMatch ? templateMatch[1].trim() : skill.definition.template || "";
@@ -40267,15 +40503,15 @@ async function formatMcpCapabilities(skill, manager, sessionID) {
 `);
 }
 function createSkillTool(options = {}) {
-  let cachedSkills = null;
+  let cachedSkills2 = null;
   let cachedDescription = null;
   const getSkills = async () => {
     if (options.skills)
       return options.skills;
-    if (cachedSkills)
-      return cachedSkills;
-    cachedSkills = await discoverSkills({ includeClaudeCodePaths: !options.opencodeOnly });
-    return cachedSkills;
+    if (cachedSkills2)
+      return cachedSkills2;
+    cachedSkills2 = await getAllSkills();
+    return cachedSkills2;
   };
   const getDescription = async () => {
     if (cachedDescription)
@@ -40474,6 +40710,7 @@ var BACKGROUND_CANCEL_DESCRIPTION = `Cancel running background task(s). Use all=
 
 // src/tools/background-task/tools.ts
 init_logger();
+init_session_cursor();
 function formatDuration(start, end) {
   const duration3 = (end ?? new Date).getTime() - start.getTime();
   const seconds = Math.floor(duration3 / 1000);
@@ -40580,8 +40817,22 @@ Session ID: ${task.sessionID}
     const timeB = String(b.info?.time ?? "");
     return timeA.localeCompare(timeB);
   });
+  const newMessages = consumeNewMessages(task.sessionID, sortedMessages);
+  if (newMessages.length === 0) {
+    const duration4 = formatDuration(task.startedAt, task.completedAt);
+    return `Task Result
+
+Task ID: ${task.id}
+Description: ${task.description}
+Duration: ${duration4}
+Session ID: ${task.sessionID}
+
+---
+
+(No new output since last check)`;
+  }
   const extractedContent = [];
-  for (const message of sortedMessages) {
+  for (const message of newMessages) {
     for (const part of message.parts ?? []) {
       if ((part.type === "text" || part.type === "reasoning") && part.text) {
         extractedContent.push(part.text);
@@ -40735,6 +40986,7 @@ Pass \`resume=session_id\` to continue previous agent with full context. Prompts
 import { existsSync as existsSync50, readdirSync as readdirSync19 } from "fs";
 import { join as join58 } from "path";
 init_logger();
+init_session_cursor();
 function getMessageDir13(sessionID) {
   if (!existsSync50(MESSAGE_STORAGE))
     return null;
@@ -40966,8 +41218,16 @@ session_id: ${sessionID}
     const timeB = b.info?.time?.created ?? 0;
     return timeA - timeB;
   });
+  const newMessages = consumeNewMessages(sessionID, sortedMessages);
+  if (newMessages.length === 0) {
+    return `No new output since last check.
+
+<task_metadata>
+session_id: ${sessionID}
+</task_metadata>`;
+  }
   const extractedContent = [];
-  for (const message of sortedMessages) {
+  for (const message of newMessages) {
     for (const part of message.parts ?? []) {
       if ((part.type === "text" || part.type === "reasoning") && part.text) {
         extractedContent.push(part.text);
@@ -41002,6 +41262,21 @@ var LOOK_AT_DESCRIPTION = `Analyze media files (PDFs, images, diagrams) that req
 import { extname as extname3, basename as basename5 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 init_logger();
+function normalizeArgs(args) {
+  return {
+    file_path: args.file_path ?? args.path ?? "",
+    goal: args.goal ?? ""
+  };
+}
+function validateArgs(args) {
+  if (!args.file_path) {
+    return `Error: Missing required parameter 'file_path'. Usage: look_at(file_path="/path/to/file", goal="what to extract")`;
+  }
+  if (!args.goal) {
+    return `Error: Missing required parameter 'goal'. Usage: look_at(file_path="/path/to/file", goal="what to extract")`;
+  }
+  return null;
+}
 function inferMimeType(filePath) {
   const ext = extname3(filePath).toLowerCase();
   const mimeTypes = {
@@ -41046,7 +41321,13 @@ function createLookAt(ctx) {
       file_path: tool.schema.string().describe("Absolute path to the file to analyze"),
       goal: tool.schema.string().describe("What specific information to extract from the file")
     },
-    async execute(args, toolContext) {
+    async execute(rawArgs, toolContext) {
+      const args = normalizeArgs(rawArgs);
+      const validationError = validateArgs(args);
+      if (validationError) {
+        log(`[look_at] Validation failed: ${validationError}`);
+        return validationError;
+      }
       log(`[look_at] Analyzing file: ${args.file_path}, goal: ${args.goal}`);
       const mimeType = inferMimeType(args.file_path);
       const filename = basename5(args.file_path);
@@ -41143,7 +41424,8 @@ class TaskToastManager {
       status: task.status ?? "running",
       startedAt: new Date,
       isBackground: task.isBackground,
-      skills: task.skills
+      skills: task.skills,
+      modelInfo: task.modelInfo
     };
     this.tasks.set(task.id, trackedTask);
     this.showTaskListToast(trackedTask);
@@ -41190,6 +41472,17 @@ class TaskToastManager {
     const queued = this.getQueuedTasks();
     const concurrencyInfo = this.getConcurrencyInfo();
     const lines = [];
+    if (newTask.modelInfo && newTask.modelInfo.type !== "user-defined") {
+      const icon = "\u26A0\uFE0F";
+      const suffixMap = {
+        inherited: " (inherited)",
+        "category-default": " (category default)",
+        "system-default": " (system default)"
+      };
+      const suffix = suffixMap[newTask.modelInfo.type] ?? "";
+      lines.push(`${icon} Model: ${newTask.modelInfo.model}${suffix}`);
+      lines.push("");
+    }
     if (running.length > 0) {
       lines.push(`Running (${running.length}):${concurrencyInfo}`);
       for (const task of running) {
@@ -41296,17 +41589,55 @@ function formatDuration2(start, end) {
     return `${minutes}m ${seconds % 60}s`;
   return `${seconds}s`;
 }
-function resolveCategoryConfig(categoryName, userCategories) {
+function formatDetailedError(error45, ctx) {
+  const message = error45 instanceof Error ? error45.message : String(error45);
+  const stack = error45 instanceof Error ? error45.stack : undefined;
+  const lines = [
+    `\u274C ${ctx.operation} failed`,
+    "",
+    `**Error**: ${message}`
+  ];
+  if (ctx.sessionID) {
+    lines.push(`**Session ID**: ${ctx.sessionID}`);
+  }
+  if (ctx.agent) {
+    lines.push(`**Agent**: ${ctx.agent}${ctx.category ? ` (category: ${ctx.category})` : ""}`);
+  }
+  if (ctx.args) {
+    lines.push("", "**Arguments**:");
+    lines.push(`- description: "${ctx.args.description}"`);
+    lines.push(`- category: ${ctx.args.category ?? "(none)"}`);
+    lines.push(`- subagent_type: ${ctx.args.subagent_type ?? "(none)"}`);
+    lines.push(`- run_in_background: ${ctx.args.run_in_background}`);
+    lines.push(`- skills: [${ctx.args.skills?.join(", ") ?? ""}]`);
+    if (ctx.args.resume) {
+      lines.push(`- resume: ${ctx.args.resume}`);
+    }
+  }
+  if (stack) {
+    lines.push("", "**Stack Trace**:");
+    lines.push("```");
+    lines.push(stack.split(`
+`).slice(0, 10).join(`
+`));
+    lines.push("```");
+  }
+  return lines.join(`
+`);
+}
+function resolveCategoryConfig(categoryName, options) {
+  const { userCategories, parentModelString, systemDefaultModel } = options;
   const defaultConfig = DEFAULT_CATEGORIES[categoryName];
   const userConfig = userCategories?.[categoryName];
   const defaultPromptAppend = CATEGORY_PROMPT_APPENDS[categoryName] ?? "";
   if (!defaultConfig && !userConfig) {
     return null;
   }
+  const model = userConfig?.model ?? parentModelString ?? defaultConfig?.model ?? systemDefaultModel;
   const config3 = {
     ...defaultConfig,
     ...userConfig,
-    model: userConfig?.model ?? defaultConfig?.model ?? "anthropic/claude-sonnet-4-5"
+    model
   };
   let promptAppend = defaultPromptAppend;
   if (userConfig?.prompt_append) {
@@ -41314,7 +41645,7 @@ function resolveCategoryConfig(categoryName, userCategories) {
 
 ` + userConfig.prompt_append : userConfig.prompt_append;
   }
-  return { config: config3, promptAppend };
+  return { config: config3, promptAppend, model };
 }
 function buildSystemContent(input) {
   const { skillContent, categoryPromptAppend } = input;
@@ -41352,9 +41683,10 @@ function createSisyphusTask(options) {
       const runInBackground = args.run_in_background === true;
       let skillContent;
       if (args.skills.length > 0) {
-        const { resolved, notFound } = resolveMultipleSkills(args.skills, { gitMasterConfig });
+        const { resolved, notFound } = await resolveMultipleSkillsAsync(args.skills, { gitMasterConfig });
         if (notFound.length > 0) {
-          const available = createBuiltinSkills().map((s) => s.name).join(", ");
+          const allSkills = await discoverSkills({ includeClaudeCodePaths: true });
+          const available = allSkills.map((s) => s.name).join(", ");
           return `\u274C Skills not found: ${notFound.join(", ")}. Available: ${available}`;
         }
         skillContent = Array.from(resolved.values()).join(`
@@ -41402,8 +41734,11 @@ Status: ${task.status}
 Agent continues with full previous context preserved.
 Use \`background_output\` with task_id="${task.id}" to check progress.`;
           } catch (error45) {
-            const message = error45 instanceof Error ? error45.message : String(error45);
-            return `\u274C Failed to resume task: ${message}`;
+            return formatDetailedError(error45, {
+              operation: "Resume background task",
+              args,
+              sessionID: args.resume
+            });
           }
         }
         const toastManager2 = getTaskToastManager();
@@ -41422,10 +41757,25 @@ Use \`background_output\` with task_id="${task.id}" to check progress.`;
           metadata: { sessionId: args.resume, sync: true }
         });
         try {
-          const resumeMessageDir = getMessageDir14(args.resume);
-          const resumeMessage = resumeMessageDir ? findNearestMessageWithFields(resumeMessageDir) : null;
-          const resumeAgent = resumeMessage?.agent;
-          const resumeModel = resumeMessage?.model?.providerID && resumeMessage?.model?.modelID ? { providerID: resumeMessage.model.providerID, modelID: resumeMessage.model.modelID } : undefined;
+          let resumeAgent;
+          let resumeModel;
+          try {
+            const messagesResp = await client2.session.messages({ path: { id: args.resume } });
+            const messages2 = messagesResp.data ?? [];
+            for (let i2 = messages2.length - 1;i2 >= 0; i2--) {
+              const info = messages2[i2].info;
+              if (info?.agent || info?.model) {
+                resumeAgent = info.agent;
+                resumeModel = info.model;
+                break;
+              }
+            }
+          } catch {
+            const resumeMessageDir = getMessageDir14(args.resume);
+            const resumeMessage = resumeMessageDir ? findNearestMessageWithFields(resumeMessageDir) : null;
+            resumeAgent = resumeMessage?.agent;
+            resumeModel = resumeMessage?.model?.providerID && resumeMessage?.model?.modelID ? { providerID: resumeMessage.model.providerID, modelID: resumeMessage.model.modelID } : undefined;
+          }
           await client2.session.prompt({
             path: { id: args.resume },
             body: {
@@ -41511,23 +41861,60 @@ ${textContent || "(No text output)"}`;
       if (!args.category && !args.subagent_type) {
         return `\u274C Invalid arguments: Must provide either category or subagent_type.`;
       }
+      let systemDefaultModel;
+      try {
+        const openCodeConfig = await client2.config.get();
+        systemDefaultModel = openCodeConfig?.model;
+      } catch {
+        systemDefaultModel = undefined;
+      }
       let agentToUse;
       let categoryModel;
       let categoryPromptAppend;
+      const parentModelString = parentModel ? `${parentModel.providerID}/${parentModel.modelID}` : undefined;
+      let modelInfo;
       if (args.category) {
-        const resolved = resolveCategoryConfig(args.category, userCategories);
+        const resolved = resolveCategoryConfig(args.category, {
+          userCategories,
+          parentModelString,
+          systemDefaultModel
+        });
         if (!resolved) {
           return `\u274C Unknown category: "${args.category}". Available: ${Object.keys({ ...DEFAULT_CATEGORIES, ...userCategories }).join(", ")}`;
         }
+        const actualModel = resolved.model;
+        const userDefinedModel = userCategories?.[args.category]?.model;
+        const categoryDefaultModel = DEFAULT_CATEGORIES[args.category]?.model;
+        if (!actualModel) {
+          return `\u274C No model configured. Set a model in your OpenCode config, plugin config, or use a category with a default model.`;
+        }
+        if (!parseModelString(actualModel)) {
+          return `\u274C Invalid model format "${actualModel}". Expected "provider/model" format (e.g., "anthropic/claude-sonnet-4-5").`;
+        }
+        switch (actualModel) {
+          case userDefinedModel:
+            modelInfo = { model: actualModel, type: "user-defined" };
+            break;
+          case parentModelString:
+            modelInfo = { model: actualModel, type: "inherited" };
+            break;
+          case categoryDefaultModel:
+            modelInfo = { model: actualModel, type: "category-default" };
+            break;
+          case systemDefaultModel:
+            modelInfo = { model: actualModel, type: "system-default" };
+            break;
+        }
         agentToUse = SISYPHUS_JUNIOR_AGENT;
-        const parsedModel = parseModelString(resolved.config.model);
+        const parsedModel = parseModelString(actualModel);
         categoryModel = parsedModel ? resolved.config.variant ? { ...parsedModel, variant: resolved.config.variant } : parsedModel : undefined;
         categoryPromptAppend = resolved.promptAppend || undefined;
       } else {
-        agentToUse = args.subagent_type.trim();
-        if (!agentToUse) {
+        if (!args.subagent_type?.trim()) {
           return `\u274C Agent name cannot be empty.`;
         }
+        const agentName = args.subagent_type.trim();
+        agentToUse = agentName;
         try {
           const agentsResult = await client2.app.agents();
           const agents = agentsResult.data ?? agentsResult;
@@ -41572,8 +41959,12 @@ Status: ${task.status}
 
 System notifies on completion. Use \`background_output\` with task_id="${task.id}" to check.`;
         } catch (error45) {
-          const message = error45 instanceof Error ? error45.message : String(error45);
-          return `\u274C Failed to launch task: ${message}`;
+          return formatDetailedError(error45, {
+            operation: "Launch background task",
+            args,
+            agent: agentToUse,
+            category: args.category
+          });
         }
       }
       const toastManager = getTaskToastManager();
@@ -41605,7 +41996,8 @@ System notifies on completion. Use \`background_output\` with task_id="${task.id
             description: args.description,
             agent: agentToUse,
             isBackground: false,
-            skills: args.skills
+            skills: args.skills,
+            modelInfo
           });
         }
         ctx.metadata?.({
@@ -41633,13 +42025,21 @@ System notifies on completion. Use \`background_output\` with task_id="${task.id
           }
           const errorMessage = promptError instanceof Error ? promptError.message : String(promptError);
           if (errorMessage.includes("agent.name") || errorMessage.includes("undefined")) {
-            return `\u274C Agent "${agentToUse}" not found. Make sure the agent is registered in your opencode.json or provided by a plugin.
-
-Session ID: ${sessionID}`;
+            return formatDetailedError(new Error(`Agent "${agentToUse}" not found. Make sure the agent is registered in your opencode.json or provided by a plugin.`), {
+              operation: "Send prompt to agent",
+              args,
+              sessionID,
+              agent: agentToUse,
+              category: args.category
+            });
           }
-          return `\u274C Failed to send prompt: ${errorMessage}
-
-Session ID: ${sessionID}`;
+          return formatDetailedError(promptError, {
+            operation: "Send prompt",
+            args,
+            sessionID,
+            agent: agentToUse,
+            category: args.category
+          });
         }
         const POLL_INTERVAL_MS = 500;
         const MAX_POLL_TIME_MS = 10 * 60 * 1000;
@@ -41739,8 +42139,13 @@ ${textContent || "(No text output)"}`;
         if (syncSessionID) {
           subagentSessions.delete(syncSessionID);
         }
-        const message = error45 instanceof Error ? error45.message : String(error45);
-        return `\u274C Task failed: ${message}`;
+        return formatDetailedError(error45, {
+          operation: "Execute task",
+          args,
+          sessionID: syncSessionID,
+          agent: agentToUse,
+          category: args.category
+        });
       }
     }
   });
@@ -41756,9 +42161,6 @@ function createBackgroundTools(manager, client2) {
   };
 }
 var builtinTools = {
-  lsp_goto_definition,
-  lsp_find_references,
-  lsp_symbols,
   lsp_diagnostics,
   lsp_servers,
   lsp_prepare_rename,
@@ -41963,6 +42365,7 @@ class BackgroundManager {
         existingTask.completedAt = new Date;
         if (existingTask.concurrencyKey) {
           this.concurrencyManager.release(existingTask.concurrencyKey);
+          existingTask.concurrencyKey = undefined;
         }
         this.markForNotification(existingTask);
         this.notifyParentSession(existingTask).catch((err) => {
@@ -42040,6 +42443,7 @@ class BackgroundManager {
     existingTask.parentMessageID = input.parentMessageID;
     existingTask.parentModel = input.parentModel;
     existingTask.parentAgent = input.parentAgent;
+    existingTask.startedAt = new Date;
     existingTask.progress = {
       toolCalls: existingTask.progress?.toolCalls ?? 0,
       lastUpdate: new Date
@@ -42081,6 +42485,10 @@ class BackgroundManager {
       const errorMessage = error45 instanceof Error ? error45.message : String(error45);
       existingTask.error = errorMessage;
       existingTask.completedAt = new Date;
+      if (existingTask.concurrencyKey) {
+        this.concurrencyManager.release(existingTask.concurrencyKey);
+        existingTask.concurrencyKey = undefined;
+      }
       this.markForNotification(existingTask);
       this.notifyParentSession(existingTask).catch((err) => {
         log("[background-agent] Failed to notify on resume error:", err);
@@ -42151,6 +42559,11 @@ class BackgroundManager {
         }
         task.status = "completed";
         task.completedAt = new Date;
+        if (task.concurrencyKey) {
+          this.concurrencyManager.release(task.concurrencyKey);
+          task.concurrencyKey = undefined;
+        }
+        this.cleanupPendingByParent(task);
         this.markForNotification(task);
         await this.notifyParentSession(task);
         log("[background-agent] Task completed via session.idle event:", task.id);
@@ -42173,7 +42586,9 @@ class BackgroundManager {
       }
       if (task.concurrencyKey) {
         this.concurrencyManager.release(task.concurrencyKey);
+        task.concurrencyKey = undefined;
       }
+      this.cleanupPendingByParent(task);
       this.tasks.delete(task.id);
       this.clearNotificationsForTask(task.id);
       subagentSessions.delete(sessionID);
@@ -42227,6 +42642,17 @@ class BackgroundManager {
       }
     }
   }
+  cleanupPendingByParent(task) {
+    if (!task.parentSessionID)
+      return;
+    const pending = this.pendingByParent.get(task.parentSessionID);
+    if (pending) {
+      pending.delete(task.id);
+      if (pending.size === 0) {
+        this.pendingByParent.delete(task.parentSessionID);
+      }
+    }
+  }
   startPolling() {
     if (this.pollingInterval)
       return;
@@ -42305,15 +42731,27 @@ Do NOT poll - continue productive work.
 Use \`background_output(task_id="${task.id}")\` to retrieve this result when ready.
 </system-reminder>`;
     }
-    const messageDir = getMessageDir15(task.parentSessionID);
-    const currentMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
-    const agent = currentMessage?.agent ?? task.parentAgent;
-    const model = currentMessage?.model?.providerID && currentMessage?.model?.modelID ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID } : undefined;
+    let agent = task.parentAgent;
+    let model;
+    try {
+      const messagesResp = await this.client.session.messages({ path: { id: task.parentSessionID } });
+      const messages = messagesResp.data ?? [];
+      for (let i2 = messages.length - 1;i2 >= 0; i2--) {
+        const info = messages[i2].info;
+        if (info?.agent || info?.model) {
+          agent = info.agent ?? task.parentAgent;
+          model = info.model;
+          break;
+        }
+      }
+    } catch {
+      const messageDir = getMessageDir15(task.parentSessionID);
+      const currentMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
+      agent = currentMessage?.agent ?? task.parentAgent;
+      model = currentMessage?.model?.providerID && currentMessage?.model?.modelID ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID } : undefined;
+    }
     log("[background-agent] notifyParentSession context:", {
       taskId: task.id,
-      messageDir: !!messageDir,
-      currentAgent: currentMessage?.agent,
-      currentModel: currentMessage?.model,
       resolvedAgent: agent,
       resolvedModel: model
     });
@@ -42372,7 +42810,9 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
         task.completedAt = new Date;
         if (task.concurrencyKey) {
           this.concurrencyManager.release(task.concurrencyKey);
+          task.concurrencyKey = undefined;
         }
+        this.cleanupPendingByParent(task);
         this.clearNotificationsForTask(taskId);
         this.tasks.delete(taskId);
         subagentSessions.delete(task.sessionID);
@@ -42416,6 +42856,11 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
           }
           task.status = "completed";
           task.completedAt = new Date;
+          if (task.concurrencyKey) {
+            this.concurrencyManager.release(task.concurrencyKey);
+            task.concurrencyKey = undefined;
+          }
+          this.cleanupPendingByParent(task);
           this.markForNotification(task);
           await this.notifyParentSession(task);
           log("[background-agent] Task completed via polling:", task.id);
@@ -42467,6 +42912,11 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
                 if (!hasIncompleteTodos2) {
                   task.status = "completed";
                   task.completedAt = new Date;
+                  if (task.concurrencyKey) {
+                    this.concurrencyManager.release(task.concurrencyKey);
+                    task.concurrencyKey = undefined;
+                  }
+                  this.cleanupPendingByParent(task);
                   this.markForNotification(task);
                   await this.notifyParentSession(task);
                   log("[background-agent] Task completed via stability detection:", task.id);
@@ -42764,6 +43214,7 @@ var InitializedNotificationSchema = NotificationSchema.extend({
   method: literal("notifications/initialized"),
   params: NotificationsParamsSchema.optional()
 });
+var isInitializedNotification = (value) => InitializedNotificationSchema.safeParse(value).success;
 var PingRequestSchema = RequestSchema.extend({
   method: literal("ping"),
   params: BaseRequestParamsSchema.optional()
@@ -45037,6 +45488,1317 @@ function isElectron() {
   return "type" in process2;
 }
 
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/transport.js
+function normalizeHeaders(headers) {
+  if (!headers)
+    return {};
+  if (headers instanceof Headers) {
+    return Object.fromEntries(headers.entries());
+  }
+  if (Array.isArray(headers)) {
+    return Object.fromEntries(headers);
+  }
+  return { ...headers };
+}
+function createFetchWithInit(baseFetch = fetch, baseInit) {
+  if (!baseInit) {
+    return baseFetch;
+  }
+  return async (url2, init) => {
+    const mergedInit = {
+      ...baseInit,
+      ...init,
+      headers: init?.headers ? { ...normalizeHeaders(baseInit.headers), ...normalizeHeaders(init.headers) } : baseInit.headers
+    };
+    return baseFetch(url2, mergedInit);
+  };
+}
+
+// node_modules/pkce-challenge/dist/index.node.js
+var crypto2;
+crypto2 = globalThis.crypto?.webcrypto ?? globalThis.crypto ?? import("crypto").then((m) => m.webcrypto);
+async function getRandomValues(size) {
+  return (await crypto2).getRandomValues(new Uint8Array(size));
+}
+async function random(size) {
+  const mask = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
+  const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask.length;
+  let result = "";
+  while (result.length < size) {
+    const randomBytes = await getRandomValues(size - result.length);
+    for (const randomByte of randomBytes) {
+      if (randomByte < evenDistCutoff) {
+        result += mask[randomByte % mask.length];
+      }
+    }
+  }
+  return result;
+}
+async function generateVerifier(length) {
+  return await random(length);
+}
+async function generateChallenge(code_verifier) {
+  const buffer = await (await crypto2).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
+  return btoa(String.fromCharCode(...new Uint8Array(buffer))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "");
+}
+async function pkceChallenge(length) {
+  if (!length)
+    length = 43;
+  if (length < 43 || length > 128) {
+    throw `Expected a length between 43 and 128. Received ${length}.`;
+  }
+  const verifier = await generateVerifier(length);
+  const challenge = await generateChallenge(verifier);
+  return {
+    code_verifier: verifier,
+    code_challenge: challenge
+  };
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js
+var SafeUrlSchema = url().superRefine((val, ctx) => {
+  if (!URL.canParse(val)) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: "URL must be parseable",
+      fatal: true
+    });
+    return NEVER;
+  }
+}).refine((url2) => {
+  const u = new URL(url2);
+  return u.protocol !== "javascript:" && u.protocol !== "data:" && u.protocol !== "vbscript:";
+}, { message: "URL cannot use javascript:, data:, or vbscript: scheme" });
+var OAuthProtectedResourceMetadataSchema = looseObject({
+  resource: string2().url(),
+  authorization_servers: array(SafeUrlSchema).optional(),
+  jwks_uri: string2().url().optional(),
+  scopes_supported: array(string2()).optional(),
+  bearer_methods_supported: array(string2()).optional(),
+  resource_signing_alg_values_supported: array(string2()).optional(),
+  resource_name: string2().optional(),
+  resource_documentation: string2().optional(),
+  resource_policy_uri: string2().url().optional(),
+  resource_tos_uri: string2().url().optional(),
+  tls_client_certificate_bound_access_tokens: boolean2().optional(),
+  authorization_details_types_supported: array(string2()).optional(),
+  dpop_signing_alg_values_supported: array(string2()).optional(),
+  dpop_bound_access_tokens_required: boolean2().optional()
+});
+var OAuthMetadataSchema = looseObject({
+  issuer: string2(),
+  authorization_endpoint: SafeUrlSchema,
+  token_endpoint: SafeUrlSchema,
+  registration_endpoint: SafeUrlSchema.optional(),
+  scopes_supported: array(string2()).optional(),
+  response_types_supported: array(string2()),
+  response_modes_supported: array(string2()).optional(),
+  grant_types_supported: array(string2()).optional(),
+  token_endpoint_auth_methods_supported: array(string2()).optional(),
+  token_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  service_documentation: SafeUrlSchema.optional(),
+  revocation_endpoint: SafeUrlSchema.optional(),
+  revocation_endpoint_auth_methods_supported: array(string2()).optional(),
+  revocation_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  introspection_endpoint: string2().optional(),
+  introspection_endpoint_auth_methods_supported: array(string2()).optional(),
+  introspection_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  code_challenge_methods_supported: array(string2()).optional(),
+  client_id_metadata_document_supported: boolean2().optional()
+});
+var OpenIdProviderMetadataSchema = looseObject({
+  issuer: string2(),
+  authorization_endpoint: SafeUrlSchema,
+  token_endpoint: SafeUrlSchema,
+  userinfo_endpoint: SafeUrlSchema.optional(),
+  jwks_uri: SafeUrlSchema,
+  registration_endpoint: SafeUrlSchema.optional(),
+  scopes_supported: array(string2()).optional(),
+  response_types_supported: array(string2()),
+  response_modes_supported: array(string2()).optional(),
+  grant_types_supported: array(string2()).optional(),
+  acr_values_supported: array(string2()).optional(),
+  subject_types_supported: array(string2()),
+  id_token_signing_alg_values_supported: array(string2()),
+  id_token_encryption_alg_values_supported: array(string2()).optional(),
+  id_token_encryption_enc_values_supported: array(string2()).optional(),
+  userinfo_signing_alg_values_supported: array(string2()).optional(),
+  userinfo_encryption_alg_values_supported: array(string2()).optional(),
+  userinfo_encryption_enc_values_supported: array(string2()).optional(),
+  request_object_signing_alg_values_supported: array(string2()).optional(),
+  request_object_encryption_alg_values_supported: array(string2()).optional(),
+  request_object_encryption_enc_values_supported: array(string2()).optional(),
+  token_endpoint_auth_methods_supported: array(string2()).optional(),
+  token_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  display_values_supported: array(string2()).optional(),
+  claim_types_supported: array(string2()).optional(),
+  claims_supported: array(string2()).optional(),
+  service_documentation: string2().optional(),
+  claims_locales_supported: array(string2()).optional(),
+  ui_locales_supported: array(string2()).optional(),
+  claims_parameter_supported: boolean2().optional(),
+  request_parameter_supported: boolean2().optional(),
+  request_uri_parameter_supported: boolean2().optional(),
+  require_request_uri_registration: boolean2().optional(),
+  op_policy_uri: SafeUrlSchema.optional(),
+  op_tos_uri: SafeUrlSchema.optional(),
+  client_id_metadata_document_supported: boolean2().optional()
+});
+var OpenIdProviderDiscoveryMetadataSchema = object({
+  ...OpenIdProviderMetadataSchema.shape,
+  ...OAuthMetadataSchema.pick({
+    code_challenge_methods_supported: true
+  }).shape
+});
+var OAuthTokensSchema = object({
+  access_token: string2(),
+  id_token: string2().optional(),
+  token_type: string2(),
+  expires_in: exports_coerce.number().optional(),
+  scope: string2().optional(),
+  refresh_token: string2().optional()
+}).strip();
+var OAuthErrorResponseSchema = object({
+  error: string2(),
+  error_description: string2().optional(),
+  error_uri: string2().optional()
+});
+var OptionalSafeUrlSchema = SafeUrlSchema.optional().or(literal("").transform(() => {
+  return;
+}));
+var OAuthClientMetadataSchema = object({
+  redirect_uris: array(SafeUrlSchema),
+  token_endpoint_auth_method: string2().optional(),
+  grant_types: array(string2()).optional(),
+  response_types: array(string2()).optional(),
+  client_name: string2().optional(),
+  client_uri: SafeUrlSchema.optional(),
+  logo_uri: OptionalSafeUrlSchema,
+  scope: string2().optional(),
+  contacts: array(string2()).optional(),
+  tos_uri: OptionalSafeUrlSchema,
+  policy_uri: string2().optional(),
+  jwks_uri: SafeUrlSchema.optional(),
+  jwks: any().optional(),
+  software_id: string2().optional(),
+  software_version: string2().optional(),
+  software_statement: string2().optional()
+}).strip();
+var OAuthClientInformationSchema = object({
+  client_id: string2(),
+  client_secret: string2().optional(),
+  client_id_issued_at: number2().optional(),
+  client_secret_expires_at: number2().optional()
+}).strip();
+var OAuthClientInformationFullSchema = OAuthClientMetadataSchema.merge(OAuthClientInformationSchema);
+var OAuthClientRegistrationErrorSchema = object({
+  error: string2(),
+  error_description: string2().optional()
+}).strip();
+var OAuthTokenRevocationRequestSchema = object({
+  token: string2(),
+  token_type_hint: string2().optional()
+}).strip();
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth-utils.js
+function resourceUrlFromServerUrl(url2) {
+  const resourceURL = typeof url2 === "string" ? new URL(url2) : new URL(url2.href);
+  resourceURL.hash = "";
+  return resourceURL;
+}
+function checkResourceAllowed({ requestedResource, configuredResource }) {
+  const requested = typeof requestedResource === "string" ? new URL(requestedResource) : new URL(requestedResource.href);
+  const configured = typeof configuredResource === "string" ? new URL(configuredResource) : new URL(configuredResource.href);
+  if (requested.origin !== configured.origin) {
+    return false;
+  }
+  if (requested.pathname.length < configured.pathname.length) {
+    return false;
+  }
+  const requestedPath = requested.pathname.endsWith("/") ? requested.pathname : requested.pathname + "/";
+  const configuredPath = configured.pathname.endsWith("/") ? configured.pathname : configured.pathname + "/";
+  return requestedPath.startsWith(configuredPath);
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/auth/errors.js
+class OAuthError extends Error {
+  constructor(message, errorUri) {
+    super(message);
+    this.errorUri = errorUri;
+    this.name = this.constructor.name;
+  }
+  toResponseObject() {
+    const response = {
+      error: this.errorCode,
+      error_description: this.message
+    };
+    if (this.errorUri) {
+      response.error_uri = this.errorUri;
+    }
+    return response;
+  }
+  get errorCode() {
+    return this.constructor.errorCode;
+  }
+}
+
+class InvalidRequestError extends OAuthError {
+}
+InvalidRequestError.errorCode = "invalid_request";
+
+class InvalidClientError extends OAuthError {
+}
+InvalidClientError.errorCode = "invalid_client";
+
+class InvalidGrantError extends OAuthError {
+}
+InvalidGrantError.errorCode = "invalid_grant";
+
+class UnauthorizedClientError extends OAuthError {
+}
+UnauthorizedClientError.errorCode = "unauthorized_client";
+
+class UnsupportedGrantTypeError extends OAuthError {
+}
+UnsupportedGrantTypeError.errorCode = "unsupported_grant_type";
+
+class InvalidScopeError extends OAuthError {
+}
+InvalidScopeError.errorCode = "invalid_scope";
+
+class AccessDeniedError extends OAuthError {
+}
+AccessDeniedError.errorCode = "access_denied";
+
+class ServerError extends OAuthError {
+}
+ServerError.errorCode = "server_error";
+
+class TemporarilyUnavailableError extends OAuthError {
+}
+TemporarilyUnavailableError.errorCode = "temporarily_unavailable";
+
+class UnsupportedResponseTypeError extends OAuthError {
+}
+UnsupportedResponseTypeError.errorCode = "unsupported_response_type";
+
+class UnsupportedTokenTypeError extends OAuthError {
+}
+UnsupportedTokenTypeError.errorCode = "unsupported_token_type";
+
+class InvalidTokenError extends OAuthError {
+}
+InvalidTokenError.errorCode = "invalid_token";
+
+class MethodNotAllowedError extends OAuthError {
+}
+MethodNotAllowedError.errorCode = "method_not_allowed";
+
+class TooManyRequestsError extends OAuthError {
+}
+TooManyRequestsError.errorCode = "too_many_requests";
+
+class InvalidClientMetadataError extends OAuthError {
+}
+InvalidClientMetadataError.errorCode = "invalid_client_metadata";
+
+class InsufficientScopeError extends OAuthError {
+}
+InsufficientScopeError.errorCode = "insufficient_scope";
+
+class InvalidTargetError extends OAuthError {
+}
+InvalidTargetError.errorCode = "invalid_target";
+var OAUTH_ERRORS = {
+  [InvalidRequestError.errorCode]: InvalidRequestError,
+  [InvalidClientError.errorCode]: InvalidClientError,
+  [InvalidGrantError.errorCode]: InvalidGrantError,
+  [UnauthorizedClientError.errorCode]: UnauthorizedClientError,
+  [UnsupportedGrantTypeError.errorCode]: UnsupportedGrantTypeError,
+  [InvalidScopeError.errorCode]: InvalidScopeError,
+  [AccessDeniedError.errorCode]: AccessDeniedError,
+  [ServerError.errorCode]: ServerError,
+  [TemporarilyUnavailableError.errorCode]: TemporarilyUnavailableError,
+  [UnsupportedResponseTypeError.errorCode]: UnsupportedResponseTypeError,
+  [UnsupportedTokenTypeError.errorCode]: UnsupportedTokenTypeError,
+  [InvalidTokenError.errorCode]: InvalidTokenError,
+  [MethodNotAllowedError.errorCode]: MethodNotAllowedError,
+  [TooManyRequestsError.errorCode]: TooManyRequestsError,
+  [InvalidClientMetadataError.errorCode]: InvalidClientMetadataError,
+  [InsufficientScopeError.errorCode]: InsufficientScopeError,
+  [InvalidTargetError.errorCode]: InvalidTargetError
+};
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/auth.js
+class UnauthorizedError extends Error {
+  constructor(message) {
+    super(message ?? "Unauthorized");
+  }
+}
+function isClientAuthMethod(method) {
+  return ["client_secret_basic", "client_secret_post", "none"].includes(method);
+}
+var AUTHORIZATION_CODE_RESPONSE_TYPE = "code";
+var AUTHORIZATION_CODE_CHALLENGE_METHOD = "S256";
+function selectClientAuthMethod(clientInformation, supportedMethods) {
+  const hasClientSecret = clientInformation.client_secret !== undefined;
+  if (supportedMethods.length === 0) {
+    return hasClientSecret ? "client_secret_post" : "none";
+  }
+  if ("token_endpoint_auth_method" in clientInformation && clientInformation.token_endpoint_auth_method && isClientAuthMethod(clientInformation.token_endpoint_auth_method) && supportedMethods.includes(clientInformation.token_endpoint_auth_method)) {
+    return clientInformation.token_endpoint_auth_method;
+  }
+  if (hasClientSecret && supportedMethods.includes("client_secret_basic")) {
+    return "client_secret_basic";
+  }
+  if (hasClientSecret && supportedMethods.includes("client_secret_post")) {
+    return "client_secret_post";
+  }
+  if (supportedMethods.includes("none")) {
+    return "none";
+  }
+  return hasClientSecret ? "client_secret_post" : "none";
+}
+function applyClientAuthentication(method, clientInformation, headers, params) {
+  const { client_id, client_secret } = clientInformation;
+  switch (method) {
+    case "client_secret_basic":
+      applyBasicAuth(client_id, client_secret, headers);
+      return;
+    case "client_secret_post":
+      applyPostAuth(client_id, client_secret, params);
+      return;
+    case "none":
+      applyPublicAuth(client_id, params);
+      return;
+    default:
+      throw new Error(`Unsupported client authentication method: ${method}`);
+  }
+}
+function applyBasicAuth(clientId, clientSecret, headers) {
+  if (!clientSecret) {
+    throw new Error("client_secret_basic authentication requires a client_secret");
+  }
+  const credentials = btoa(`${clientId}:${clientSecret}`);
+  headers.set("Authorization", `Basic ${credentials}`);
+}
+function applyPostAuth(clientId, clientSecret, params) {
+  params.set("client_id", clientId);
+  if (clientSecret) {
+    params.set("client_secret", clientSecret);
+  }
+}
+function applyPublicAuth(clientId, params) {
+  params.set("client_id", clientId);
+}
+async function parseErrorResponse(input) {
+  const statusCode = input instanceof Response ? input.status : undefined;
+  const body = input instanceof Response ? await input.text() : input;
+  try {
+    const result = OAuthErrorResponseSchema.parse(JSON.parse(body));
+    const { error: error45, error_description, error_uri } = result;
+    const errorClass = OAUTH_ERRORS[error45] || ServerError;
+    return new errorClass(error_description || "", error_uri);
+  } catch (error45) {
+    const errorMessage = `${statusCode ? `HTTP ${statusCode}: ` : ""}Invalid OAuth error response: ${error45}. Raw body: ${body}`;
+    return new ServerError(errorMessage);
+  }
+}
+async function auth(provider, options) {
+  try {
+    return await authInternal(provider, options);
+  } catch (error45) {
+    if (error45 instanceof InvalidClientError || error45 instanceof UnauthorizedClientError) {
+      await provider.invalidateCredentials?.("all");
+      return await authInternal(provider, options);
+    } else if (error45 instanceof InvalidGrantError) {
+      await provider.invalidateCredentials?.("tokens");
+      return await authInternal(provider, options);
+    }
+    throw error45;
+  }
+}
+async function authInternal(provider, { serverUrl, authorizationCode, scope, resourceMetadataUrl, fetchFn }) {
+  let resourceMetadata;
+  let authorizationServerUrl;
+  try {
+    resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl }, fetchFn);
+    if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
+      authorizationServerUrl = resourceMetadata.authorization_servers[0];
+    }
+  } catch {}
+  if (!authorizationServerUrl) {
+    authorizationServerUrl = new URL("/", serverUrl);
+  }
+  const resource = await selectResourceURL(serverUrl, provider, resourceMetadata);
+  const metadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, {
+    fetchFn
+  });
+  let clientInformation = await Promise.resolve(provider.clientInformation());
+  if (!clientInformation) {
+    if (authorizationCode !== undefined) {
+      throw new Error("Existing OAuth client information is required when exchanging an authorization code");
+    }
+    const supportsUrlBasedClientId = metadata?.client_id_metadata_document_supported === true;
+    const clientMetadataUrl = provider.clientMetadataUrl;
+    if (clientMetadataUrl && !isHttpsUrl(clientMetadataUrl)) {
+      throw new InvalidClientMetadataError(`clientMetadataUrl must be a valid HTTPS URL with a non-root pathname, got: ${clientMetadataUrl}`);
+    }
+    const shouldUseUrlBasedClientId = supportsUrlBasedClientId && clientMetadataUrl;
+    if (shouldUseUrlBasedClientId) {
+      clientInformation = {
+        client_id: clientMetadataUrl
+      };
+      await provider.saveClientInformation?.(clientInformation);
+    } else {
+      if (!provider.saveClientInformation) {
+        throw new Error("OAuth client information must be saveable for dynamic registration");
+      }
+      const fullInformation = await registerClient(authorizationServerUrl, {
+        metadata,
+        clientMetadata: provider.clientMetadata,
+        fetchFn
+      });
+      await provider.saveClientInformation(fullInformation);
+      clientInformation = fullInformation;
+    }
+  }
+  const nonInteractiveFlow = !provider.redirectUrl;
+  if (authorizationCode !== undefined || nonInteractiveFlow) {
+    const tokens2 = await fetchToken(provider, authorizationServerUrl, {
+      metadata,
+      resource,
+      authorizationCode,
+      fetchFn
+    });
+    await provider.saveTokens(tokens2);
+    return "AUTHORIZED";
+  }
+  const tokens = await provider.tokens();
+  if (tokens?.refresh_token) {
+    try {
+      const newTokens = await refreshAuthorization(authorizationServerUrl, {
+        metadata,
+        clientInformation,
+        refreshToken: tokens.refresh_token,
+        resource,
+        addClientAuthentication: provider.addClientAuthentication,
+        fetchFn
+      });
+      await provider.saveTokens(newTokens);
+      return "AUTHORIZED";
+    } catch (error45) {
+      if (!(error45 instanceof OAuthError) || error45 instanceof ServerError) {} else {
+        throw error45;
+      }
+    }
+  }
+  const state2 = provider.state ? await provider.state() : undefined;
+  const { authorizationUrl, codeVerifier } = await startAuthorization(authorizationServerUrl, {
+    metadata,
+    clientInformation,
+    state: state2,
+    redirectUrl: provider.redirectUrl,
+    scope: scope || resourceMetadata?.scopes_supported?.join(" ") || provider.clientMetadata.scope,
+    resource
+  });
+  await provider.saveCodeVerifier(codeVerifier);
+  await provider.redirectToAuthorization(authorizationUrl);
+  return "REDIRECT";
+}
+function isHttpsUrl(value) {
+  if (!value)
+    return false;
+  try {
+    const url2 = new URL(value);
+    return url2.protocol === "https:" && url2.pathname !== "/";
+  } catch {
+    return false;
+  }
+}
+async function selectResourceURL(serverUrl, provider, resourceMetadata) {
+  const defaultResource = resourceUrlFromServerUrl(serverUrl);
+  if (provider.validateResourceURL) {
+    return await provider.validateResourceURL(defaultResource, resourceMetadata?.resource);
+  }
+  if (!resourceMetadata) {
+    return;
+  }
+  if (!checkResourceAllowed({ requestedResource: defaultResource, configuredResource: resourceMetadata.resource })) {
+    throw new Error(`Protected resource ${resourceMetadata.resource} does not match expected ${defaultResource} (or origin)`);
+  }
+  return new URL(resourceMetadata.resource);
+}
+function extractWWWAuthenticateParams(res) {
+  const authenticateHeader = res.headers.get("WWW-Authenticate");
+  if (!authenticateHeader) {
+    return {};
+  }
+  const [type2, scheme] = authenticateHeader.split(" ");
+  if (type2.toLowerCase() !== "bearer" || !scheme) {
+    return {};
+  }
+  const resourceMetadataMatch = extractFieldFromWwwAuth(res, "resource_metadata") || undefined;
+  let resourceMetadataUrl;
+  if (resourceMetadataMatch) {
+    try {
+      resourceMetadataUrl = new URL(resourceMetadataMatch);
+    } catch {}
+  }
+  const scope = extractFieldFromWwwAuth(res, "scope") || undefined;
+  const error45 = extractFieldFromWwwAuth(res, "error") || undefined;
+  return {
+    resourceMetadataUrl,
+    scope,
+    error: error45
+  };
+}
+function extractFieldFromWwwAuth(response, fieldName) {
+  const wwwAuthHeader = response.headers.get("WWW-Authenticate");
+  if (!wwwAuthHeader) {
+    return null;
+  }
+  const pattern = new RegExp(`${fieldName}=(?:"([^"]+)"|([^\\s,]+))`);
+  const match = wwwAuthHeader.match(pattern);
+  if (match) {
+    return match[1] || match[2];
+  }
+  return null;
+}
+async function discoverOAuthProtectedResourceMetadata(serverUrl, opts, fetchFn = fetch) {
+  const response = await discoverMetadataWithFallback(serverUrl, "oauth-protected-resource", fetchFn, {
+    protocolVersion: opts?.protocolVersion,
+    metadataUrl: opts?.resourceMetadataUrl
+  });
+  if (!response || response.status === 404) {
+    await response?.body?.cancel();
+    throw new Error(`Resource server does not implement OAuth 2.0 Protected Resource Metadata.`);
+  }
+  if (!response.ok) {
+    await response.body?.cancel();
+    throw new Error(`HTTP ${response.status} trying to load well-known OAuth protected resource metadata.`);
+  }
+  return OAuthProtectedResourceMetadataSchema.parse(await response.json());
+}
+async function fetchWithCorsRetry(url2, headers, fetchFn = fetch) {
+  try {
+    return await fetchFn(url2, { headers });
+  } catch (error45) {
+    if (error45 instanceof TypeError) {
+      if (headers) {
+        return fetchWithCorsRetry(url2, undefined, fetchFn);
+      } else {
+        return;
+      }
+    }
+    throw error45;
+  }
+}
+function buildWellKnownPath(wellKnownPrefix, pathname = "", options = {}) {
+  if (pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  return options.prependPathname ? `${pathname}/.well-known/${wellKnownPrefix}` : `/.well-known/${wellKnownPrefix}${pathname}`;
+}
+async function tryMetadataDiscovery(url2, protocolVersion, fetchFn = fetch) {
+  const headers = {
+    "MCP-Protocol-Version": protocolVersion
+  };
+  return await fetchWithCorsRetry(url2, headers, fetchFn);
+}
+function shouldAttemptFallback(response, pathname) {
+  return !response || response.status >= 400 && response.status < 500 && pathname !== "/";
+}
+async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, opts) {
+  const issuer = new URL(serverUrl);
+  const protocolVersion = opts?.protocolVersion ?? LATEST_PROTOCOL_VERSION;
+  let url2;
+  if (opts?.metadataUrl) {
+    url2 = new URL(opts.metadataUrl);
+  } else {
+    const wellKnownPath = buildWellKnownPath(wellKnownType, issuer.pathname);
+    url2 = new URL(wellKnownPath, opts?.metadataServerUrl ?? issuer);
+    url2.search = issuer.search;
+  }
+  let response = await tryMetadataDiscovery(url2, protocolVersion, fetchFn);
+  if (!opts?.metadataUrl && shouldAttemptFallback(response, issuer.pathname)) {
+    const rootUrl = new URL(`/.well-known/${wellKnownType}`, issuer);
+    response = await tryMetadataDiscovery(rootUrl, protocolVersion, fetchFn);
+  }
+  return response;
+}
+function buildDiscoveryUrls(authorizationServerUrl) {
+  const url2 = typeof authorizationServerUrl === "string" ? new URL(authorizationServerUrl) : authorizationServerUrl;
+  const hasPath = url2.pathname !== "/";
+  const urlsToTry = [];
+  if (!hasPath) {
+    urlsToTry.push({
+      url: new URL("/.well-known/oauth-authorization-server", url2.origin),
+      type: "oauth"
+    });
+    urlsToTry.push({
+      url: new URL(`/.well-known/openid-configuration`, url2.origin),
+      type: "oidc"
+    });
+    return urlsToTry;
+  }
+  let pathname = url2.pathname;
+  if (pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  urlsToTry.push({
+    url: new URL(`/.well-known/oauth-authorization-server${pathname}`, url2.origin),
+    type: "oauth"
+  });
+  urlsToTry.push({
+    url: new URL(`/.well-known/openid-configuration${pathname}`, url2.origin),
+    type: "oidc"
+  });
+  urlsToTry.push({
+    url: new URL(`${pathname}/.well-known/openid-configuration`, url2.origin),
+    type: "oidc"
+  });
+  return urlsToTry;
+}
+async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn = fetch, protocolVersion = LATEST_PROTOCOL_VERSION } = {}) {
+  const headers = {
+    "MCP-Protocol-Version": protocolVersion,
+    Accept: "application/json"
+  };
+  const urlsToTry = buildDiscoveryUrls(authorizationServerUrl);
+  for (const { url: endpointUrl, type: type2 } of urlsToTry) {
+    const response = await fetchWithCorsRetry(endpointUrl, headers, fetchFn);
+    if (!response) {
+      continue;
+    }
+    if (!response.ok) {
+      await response.body?.cancel();
+      if (response.status >= 400 && response.status < 500) {
+        continue;
+      }
+      throw new Error(`HTTP ${response.status} trying to load ${type2 === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${endpointUrl}`);
+    }
+    if (type2 === "oauth") {
+      return OAuthMetadataSchema.parse(await response.json());
+    } else {
+      return OpenIdProviderDiscoveryMetadataSchema.parse(await response.json());
+    }
+  }
+  return;
+}
+async function startAuthorization(authorizationServerUrl, { metadata, clientInformation, redirectUrl, scope, state: state2, resource }) {
+  let authorizationUrl;
+  if (metadata) {
+    authorizationUrl = new URL(metadata.authorization_endpoint);
+    if (!metadata.response_types_supported.includes(AUTHORIZATION_CODE_RESPONSE_TYPE)) {
+      throw new Error(`Incompatible auth server: does not support response type ${AUTHORIZATION_CODE_RESPONSE_TYPE}`);
+    }
+    if (metadata.code_challenge_methods_supported && !metadata.code_challenge_methods_supported.includes(AUTHORIZATION_CODE_CHALLENGE_METHOD)) {
+      throw new Error(`Incompatible auth server: does not support code challenge method ${AUTHORIZATION_CODE_CHALLENGE_METHOD}`);
+    }
+  } else {
+    authorizationUrl = new URL("/authorize", authorizationServerUrl);
+  }
+  const challenge = await pkceChallenge();
+  const codeVerifier = challenge.code_verifier;
+  const codeChallenge = challenge.code_challenge;
+  authorizationUrl.searchParams.set("response_type", AUTHORIZATION_CODE_RESPONSE_TYPE);
+  authorizationUrl.searchParams.set("client_id", clientInformation.client_id);
+  authorizationUrl.searchParams.set("code_challenge", codeChallenge);
+  authorizationUrl.searchParams.set("code_challenge_method", AUTHORIZATION_CODE_CHALLENGE_METHOD);
+  authorizationUrl.searchParams.set("redirect_uri", String(redirectUrl));
+  if (state2) {
+    authorizationUrl.searchParams.set("state", state2);
+  }
+  if (scope) {
+    authorizationUrl.searchParams.set("scope", scope);
+  }
+  if (scope?.includes("offline_access")) {
+    authorizationUrl.searchParams.append("prompt", "consent");
+  }
+  if (resource) {
+    authorizationUrl.searchParams.set("resource", resource.href);
+  }
+  return { authorizationUrl, codeVerifier };
+}
+function prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, redirectUri) {
+  return new URLSearchParams({
+    grant_type: "authorization_code",
+    code: authorizationCode,
+    code_verifier: codeVerifier,
+    redirect_uri: String(redirectUri)
+  });
+}
+async function executeTokenRequest(authorizationServerUrl, { metadata, tokenRequestParams, clientInformation, addClientAuthentication, resource, fetchFn }) {
+  const tokenUrl = metadata?.token_endpoint ? new URL(metadata.token_endpoint) : new URL("/token", authorizationServerUrl);
+  const headers = new Headers({
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json"
+  });
+  if (resource) {
+    tokenRequestParams.set("resource", resource.href);
+  }
+  if (addClientAuthentication) {
+    await addClientAuthentication(headers, tokenRequestParams, tokenUrl, metadata);
+  } else if (clientInformation) {
+    const supportedMethods = metadata?.token_endpoint_auth_methods_supported ?? [];
+    const authMethod = selectClientAuthMethod(clientInformation, supportedMethods);
+    applyClientAuthentication(authMethod, clientInformation, headers, tokenRequestParams);
+  }
+  const response = await (fetchFn ?? fetch)(tokenUrl, {
+    method: "POST",
+    headers,
+    body: tokenRequestParams
+  });
+  if (!response.ok) {
+    throw await parseErrorResponse(response);
+  }
+  return OAuthTokensSchema.parse(await response.json());
+}
+async function refreshAuthorization(authorizationServerUrl, { metadata, clientInformation, refreshToken, resource, addClientAuthentication, fetchFn }) {
+  const tokenRequestParams = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken
+  });
+  const tokens = await executeTokenRequest(authorizationServerUrl, {
+    metadata,
+    tokenRequestParams,
+    clientInformation,
+    addClientAuthentication,
+    resource,
+    fetchFn
+  });
+  return { refresh_token: refreshToken, ...tokens };
+}
+async function fetchToken(provider, authorizationServerUrl, { metadata, resource, authorizationCode, fetchFn } = {}) {
+  const scope = provider.clientMetadata.scope;
+  let tokenRequestParams;
+  if (provider.prepareTokenRequest) {
+    tokenRequestParams = await provider.prepareTokenRequest(scope);
+  }
+  if (!tokenRequestParams) {
+    if (!authorizationCode) {
+      throw new Error("Either provider.prepareTokenRequest() or authorizationCode is required");
+    }
+    if (!provider.redirectUrl) {
+      throw new Error("redirectUrl is required for authorization_code flow");
+    }
+    const codeVerifier = await provider.codeVerifier();
+    tokenRequestParams = prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, provider.redirectUrl);
+  }
+  const clientInformation = await provider.clientInformation();
+  return executeTokenRequest(authorizationServerUrl, {
+    metadata,
+    tokenRequestParams,
+    clientInformation: clientInformation ?? undefined,
+    addClientAuthentication: provider.addClientAuthentication,
+    resource,
+    fetchFn
+  });
+}
+async function registerClient(authorizationServerUrl, { metadata, clientMetadata, fetchFn }) {
+  let registrationUrl;
+  if (metadata) {
+    if (!metadata.registration_endpoint) {
+      throw new Error("Incompatible auth server: does not support dynamic client registration");
+    }
+    registrationUrl = new URL(metadata.registration_endpoint);
+  } else {
+    registrationUrl = new URL("/register", authorizationServerUrl);
+  }
+  const response = await (fetchFn ?? fetch)(registrationUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(clientMetadata)
+  });
+  if (!response.ok) {
+    throw await parseErrorResponse(response);
+  }
+  return OAuthClientInformationFullSchema.parse(await response.json());
+}
+
+// node_modules/eventsource-parser/dist/index.js
+class ParseError2 extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+}
+function noop(_arg) {}
+function createParser(callbacks) {
+  if (typeof callbacks == "function")
+    throw new TypeError("`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?");
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
+  let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
+  function feed(newChunk) {
+    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
+    for (const line of complete)
+      parseLine(line);
+    incompleteLine = incomplete, isFirstChunk = false;
+  }
+  function parseLine(line) {
+    if (line === "") {
+      dispatchEvent();
+      return;
+    }
+    if (line.startsWith(":")) {
+      onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
+      return;
+    }
+    const fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex !== -1) {
+      const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+      processField(field, value, line);
+      return;
+    }
+    processField(line, "", line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value;
+        break;
+      case "data":
+        data = `${data}${value}
+`;
+        break;
+      case "id":
+        id = value.includes("\x00") ? undefined : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(new ParseError2(`Invalid \`retry\` value: "${value}"`, {
+          type: "invalid-retry",
+          value,
+          line
+        }));
+        break;
+      default:
+        onError(new ParseError2(`Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`, { type: "unknown-field", field, value, line }));
+        break;
+    }
+  }
+  function dispatchEvent() {
+    data.length > 0 && onEvent({
+      id,
+      event: eventType || undefined,
+      data: data.endsWith(`
+`) ? data.slice(0, -1) : data
+    }), id = undefined, data = "", eventType = "";
+  }
+  function reset(options = {}) {
+    incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = undefined, data = "", eventType = "", incompleteLine = "";
+  }
+  return { feed, reset };
+}
+function splitLines(chunk) {
+  const lines = [];
+  let incompleteLine = "", searchIndex = 0;
+  for (;searchIndex < chunk.length; ) {
+    const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+    let lineEnd = -1;
+    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
+      incompleteLine = chunk.slice(searchIndex);
+      break;
+    } else {
+      const line = chunk.slice(searchIndex, lineEnd);
+      lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
+` && searchIndex++;
+    }
+  }
+  return [lines, incompleteLine];
+}
+
+// node_modules/eventsource-parser/dist/stream.js
+class EventSourceParserStream extends TransformStream {
+  constructor({ onError, onRetry, onComment } = {}) {
+    let parser;
+    super({
+      start(controller) {
+        parser = createParser({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          },
+          onError(error45) {
+            onError === "terminate" ? controller.error(error45) : typeof onError == "function" && onError(error45);
+          },
+          onRetry,
+          onComment
+        });
+      },
+      transform(chunk) {
+        parser.feed(chunk);
+      }
+    });
+  }
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/streamableHttp.js
+var DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS = {
+  initialReconnectionDelay: 1000,
+  maxReconnectionDelay: 30000,
+  reconnectionDelayGrowFactor: 1.5,
+  maxRetries: 2
+};
+
+class StreamableHTTPError extends Error {
+  constructor(code, message) {
+    super(`Streamable HTTP error: ${message}`);
+    this.code = code;
+  }
+}
+
+class StreamableHTTPClientTransport {
+  constructor(url2, opts) {
+    this._hasCompletedAuthFlow = false;
+    this._url = url2;
+    this._resourceMetadataUrl = undefined;
+    this._scope = undefined;
+    this._requestInit = opts?.requestInit;
+    this._authProvider = opts?.authProvider;
+    this._fetch = opts?.fetch;
+    this._fetchWithInit = createFetchWithInit(opts?.fetch, opts?.requestInit);
+    this._sessionId = opts?.sessionId;
+    this._reconnectionOptions = opts?.reconnectionOptions ?? DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS;
+  }
+  async _authThenStart() {
+    if (!this._authProvider) {
+      throw new UnauthorizedError("No auth provider");
+    }
+    let result;
+    try {
+      result = await auth(this._authProvider, {
+        serverUrl: this._url,
+        resourceMetadataUrl: this._resourceMetadataUrl,
+        scope: this._scope,
+        fetchFn: this._fetchWithInit
+      });
+    } catch (error45) {
+      this.onerror?.(error45);
+      throw error45;
+    }
+    if (result !== "AUTHORIZED") {
+      throw new UnauthorizedError;
+    }
+    return await this._startOrAuthSse({ resumptionToken: undefined });
+  }
+  async _commonHeaders() {
+    const headers = {};
+    if (this._authProvider) {
+      const tokens = await this._authProvider.tokens();
+      if (tokens) {
+        headers["Authorization"] = `Bearer ${tokens.access_token}`;
+      }
+    }
+    if (this._sessionId) {
+      headers["mcp-session-id"] = this._sessionId;
+    }
+    if (this._protocolVersion) {
+      headers["mcp-protocol-version"] = this._protocolVersion;
+    }
+    const extraHeaders = normalizeHeaders(this._requestInit?.headers);
+    return new Headers({
+      ...headers,
+      ...extraHeaders
+    });
+  }
+  async _startOrAuthSse(options) {
+    const { resumptionToken } = options;
+    try {
+      const headers = await this._commonHeaders();
+      headers.set("Accept", "text/event-stream");
+      if (resumptionToken) {
+        headers.set("last-event-id", resumptionToken);
+      }
+      const response = await (this._fetch ?? fetch)(this._url, {
+        method: "GET",
+        headers,
+        signal: this._abortController?.signal
+      });
+      if (!response.ok) {
+        await response.body?.cancel();
+        if (response.status === 401 && this._authProvider) {
+          return await this._authThenStart();
+        }
+        if (response.status === 405) {
+          return;
+        }
+        throw new StreamableHTTPError(response.status, `Failed to open SSE stream: ${response.statusText}`);
+      }
+      this._handleSseStream(response.body, options, true);
+    } catch (error45) {
+      this.onerror?.(error45);
+      throw error45;
+    }
+  }
+  _getNextReconnectionDelay(attempt) {
+    if (this._serverRetryMs !== undefined) {
+      return this._serverRetryMs;
+    }
+    const initialDelay = this._reconnectionOptions.initialReconnectionDelay;
+    const growFactor = this._reconnectionOptions.reconnectionDelayGrowFactor;
+    const maxDelay = this._reconnectionOptions.maxReconnectionDelay;
+    return Math.min(initialDelay * Math.pow(growFactor, attempt), maxDelay);
+  }
+  _scheduleReconnection(options, attemptCount = 0) {
+    const maxRetries = this._reconnectionOptions.maxRetries;
+    if (attemptCount >= maxRetries) {
+      this.onerror?.(new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`));
+      return;
+    }
+    const delay2 = this._getNextReconnectionDelay(attemptCount);
+    this._reconnectionTimeout = setTimeout(() => {
+      this._startOrAuthSse(options).catch((error45) => {
+        this.onerror?.(new Error(`Failed to reconnect SSE stream: ${error45 instanceof Error ? error45.message : String(error45)}`));
+        this._scheduleReconnection(options, attemptCount + 1);
+      });
+    }, delay2);
+  }
+  _handleSseStream(stream, options, isReconnectable) {
+    if (!stream) {
+      return;
+    }
+    const { onresumptiontoken, replayMessageId } = options;
+    let lastEventId;
+    let hasPrimingEvent = false;
+    let receivedResponse = false;
+    const processStream = async () => {
+      try {
+        const reader = stream.pipeThrough(new TextDecoderStream).pipeThrough(new EventSourceParserStream({
+          onRetry: (retryMs) => {
+            this._serverRetryMs = retryMs;
+          }
+        })).getReader();
+        while (true) {
+          const { value: event, done } = await reader.read();
+          if (done) {
+            break;
+          }
+          if (event.id) {
+            lastEventId = event.id;
+            hasPrimingEvent = true;
+            onresumptiontoken?.(event.id);
+          }
+          if (!event.data) {
+            continue;
+          }
+          if (!event.event || event.event === "message") {
+            try {
+              const message = JSONRPCMessageSchema.parse(JSON.parse(event.data));
+              if (isJSONRPCResultResponse(message)) {
+                receivedResponse = true;
+                if (replayMessageId !== undefined) {
+                  message.id = replayMessageId;
+                }
+              }
+              this.onmessage?.(message);
+            } catch (error45) {
+              this.onerror?.(error45);
+            }
+          }
+        }
+        const canResume = isReconnectable || hasPrimingEvent;
+        const needsReconnect = canResume && !receivedResponse;
+        if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
+          this._scheduleReconnection({
+            resumptionToken: lastEventId,
+            onresumptiontoken,
+            replayMessageId
+          }, 0);
+        }
+      } catch (error45) {
+        this.onerror?.(new Error(`SSE stream disconnected: ${error45}`));
+        const canResume = isReconnectable || hasPrimingEvent;
+        const needsReconnect = canResume && !receivedResponse;
+        if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
+          try {
+            this._scheduleReconnection({
+              resumptionToken: lastEventId,
+              onresumptiontoken,
+              replayMessageId
+            }, 0);
+          } catch (error46) {
+            this.onerror?.(new Error(`Failed to reconnect: ${error46 instanceof Error ? error46.message : String(error46)}`));
+          }
+        }
+      }
+    };
+    processStream();
+  }
+  async start() {
+    if (this._abortController) {
+      throw new Error("StreamableHTTPClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+    }
+    this._abortController = new AbortController;
+  }
+  async finishAuth(authorizationCode) {
+    if (!this._authProvider) {
+      throw new UnauthorizedError("No auth provider");
+    }
+    const result = await auth(this._authProvider, {
+      serverUrl: this._url,
+      authorizationCode,
+      resourceMetadataUrl: this._resourceMetadataUrl,
+      scope: this._scope,
+      fetchFn: this._fetchWithInit
+    });
+    if (result !== "AUTHORIZED") {
+      throw new UnauthorizedError("Failed to authorize");
+    }
+  }
+  async close() {
+    if (this._reconnectionTimeout) {
+      clearTimeout(this._reconnectionTimeout);
+      this._reconnectionTimeout = undefined;
+    }
+    this._abortController?.abort();
+    this.onclose?.();
+  }
+  async send(message, options) {
+    try {
+      const { resumptionToken, onresumptiontoken } = options || {};
+      if (resumptionToken) {
+        this._startOrAuthSse({ resumptionToken, replayMessageId: isJSONRPCRequest(message) ? message.id : undefined }).catch((err) => this.onerror?.(err));
+        return;
+      }
+      const headers = await this._commonHeaders();
+      headers.set("content-type", "application/json");
+      headers.set("accept", "application/json, text/event-stream");
+      const init = {
+        ...this._requestInit,
+        method: "POST",
+        headers,
+        body: JSON.stringify(message),
+        signal: this._abortController?.signal
+      };
+      const response = await (this._fetch ?? fetch)(this._url, init);
+      const sessionId = response.headers.get("mcp-session-id");
+      if (sessionId) {
+        this._sessionId = sessionId;
+      }
+      if (!response.ok) {
+        const text = await response.text().catch(() => null);
+        if (response.status === 401 && this._authProvider) {
+          if (this._hasCompletedAuthFlow) {
+            throw new StreamableHTTPError(401, "Server returned 401 after successful authentication");
+          }
+          const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
+          this._resourceMetadataUrl = resourceMetadataUrl;
+          this._scope = scope;
+          const result = await auth(this._authProvider, {
+            serverUrl: this._url,
+            resourceMetadataUrl: this._resourceMetadataUrl,
+            scope: this._scope,
+            fetchFn: this._fetchWithInit
+          });
+          if (result !== "AUTHORIZED") {
+            throw new UnauthorizedError;
+          }
+          this._hasCompletedAuthFlow = true;
+          return this.send(message);
+        }
+        if (response.status === 403 && this._authProvider) {
+          const { resourceMetadataUrl, scope, error: error45 } = extractWWWAuthenticateParams(response);
+          if (error45 === "insufficient_scope") {
+            const wwwAuthHeader = response.headers.get("WWW-Authenticate");
+            if (this._lastUpscopingHeader === wwwAuthHeader) {
+              throw new StreamableHTTPError(403, "Server returned 403 after trying upscoping");
+            }
+            if (scope) {
+              this._scope = scope;
+            }
+            if (resourceMetadataUrl) {
+              this._resourceMetadataUrl = resourceMetadataUrl;
+            }
+            this._lastUpscopingHeader = wwwAuthHeader ?? undefined;
+            const result = await auth(this._authProvider, {
+              serverUrl: this._url,
+              resourceMetadataUrl: this._resourceMetadataUrl,
+              scope: this._scope,
+              fetchFn: this._fetch
+            });
+            if (result !== "AUTHORIZED") {
+              throw new UnauthorizedError;
+            }
+            return this.send(message);
+          }
+        }
+        throw new StreamableHTTPError(response.status, `Error POSTing to endpoint: ${text}`);
+      }
+      this._hasCompletedAuthFlow = false;
+      this._lastUpscopingHeader = undefined;
+      if (response.status === 202) {
+        await response.body?.cancel();
+        if (isInitializedNotification(message)) {
+          this._startOrAuthSse({ resumptionToken: undefined }).catch((err) => this.onerror?.(err));
+        }
+        return;
+      }
+      const messages = Array.isArray(message) ? message : [message];
+      const hasRequests = messages.filter((msg) => ("method" in msg) && ("id" in msg) && msg.id !== undefined).length > 0;
+      const contentType = response.headers.get("content-type");
+      if (hasRequests) {
+        if (contentType?.includes("text/event-stream")) {
+          this._handleSseStream(response.body, { onresumptiontoken }, false);
+        } else if (contentType?.includes("application/json")) {
+          const data = await response.json();
+          const responseMessages = Array.isArray(data) ? data.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(data)];
+          for (const msg of responseMessages) {
+            this.onmessage?.(msg);
+          }
+        } else {
+          await response.body?.cancel();
+          throw new StreamableHTTPError(-1, `Unexpected content type: ${contentType}`);
+        }
+      } else {
+        await response.body?.cancel();
+      }
+    } catch (error45) {
+      this.onerror?.(error45);
+      throw error45;
+    }
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  async terminateSession() {
+    if (!this._sessionId) {
+      return;
+    }
+    try {
+      const headers = await this._commonHeaders();
+      const init = {
+        ...this._requestInit,
+        method: "DELETE",
+        headers,
+        signal: this._abortController?.signal
+      };
+      const response = await (this._fetch ?? fetch)(this._url, init);
+      await response.body?.cancel();
+      if (!response.ok && response.status !== 405) {
+        throw new StreamableHTTPError(response.status, `Failed to terminate session: ${response.statusText}`);
+      }
+      this._sessionId = undefined;
+    } catch (error45) {
+      this.onerror?.(error45);
+      throw error45;
+    }
+  }
+  setProtocolVersion(version2) {
+    this._protocolVersion = version2;
+  }
+  get protocolVersion() {
+    return this._protocolVersion;
+  }
+  async resumeStream(lastEventId, options) {
+    await this._startOrAuthSse({
+      resumptionToken: lastEventId,
+      onresumptiontoken: options?.onresumptiontoken
+    });
+  }
+}
+
 // src/features/skill-mcp-manager/env-cleaner.ts
 var EXCLUDED_ENV_PATTERNS = [
   /^NPM_CONFIG_/i,
@@ -45060,6 +46822,22 @@ function createCleanMcpEnvironment(customEnv = {}) {
 }
 
 // src/features/skill-mcp-manager/manager.ts
+function getConnectionType(config3) {
+  if (config3.type === "http" || config3.type === "sse") {
+    return "http";
+  }
+  if (config3.type === "stdio") {
+    return "stdio";
+  }
+  if (config3.url) {
+    return "http";
+  }
+  if (config3.command) {
+    return "stdio";
+  }
+  return null;
+}
+
 class SkillMcpManager {
   clients = new Map;
   pendingConnections = new Map;
@@ -45122,17 +46900,88 @@ class SkillMcpManager {
     }
   }
   async createClient(info, config3) {
+    const connectionType = getConnectionType(config3);
+    if (!connectionType) {
+      throw new Error(`MCP server "${info.serverName}" has no valid connection configuration.
+
+` + `The MCP configuration in skill "${info.skillName}" must specify either:
+` + `  - A URL for HTTP connection (remote MCP server)
+` + `  - A command for stdio connection (local MCP process)
+
+` + `Examples:
+` + `  HTTP:
+` + `    mcp:
+` + `      ${info.serverName}:
+` + `        url: https://mcp.example.com/mcp
+` + `        headers:
+` + `          Authorization: Bearer \${API_KEY}
+
+` + `  Stdio:
+` + `    mcp:
+` + `      ${info.serverName}:
+` + `        command: npx
+` + `        args: [-y, @some/mcp-server]`);
+    }
+    if (connectionType === "http") {
+      return this.createHttpClient(info, config3);
+    } else {
+      return this.createStdioClient(info, config3);
+    }
+  }
+  async createHttpClient(info, config3) {
     const key = this.getClientKey(info);
-    if (!config3.command) {
-      throw new Error(`MCP server "${info.serverName}" is missing required 'command' field.
+    if (!config3.url) {
+      throw new Error(`MCP server "${info.serverName}" is configured for HTTP but missing 'url' field.`);
+    }
+    let url2;
+    try {
+      url2 = new URL(config3.url);
+    } catch {
+      throw new Error(`MCP server "${info.serverName}" has invalid URL: ${config3.url}
 
-` + `The MCP configuration in skill "${info.skillName}" must specify a command to execute.
+` + `Expected a valid URL like: https://mcp.example.com/mcp`);
+    }
+    this.registerProcessCleanup();
+    const requestInit = {};
+    if (config3.headers && Object.keys(config3.headers).length > 0) {
+      requestInit.headers = config3.headers;
+    }
+    const transport = new StreamableHTTPClientTransport(url2, {
+      requestInit: Object.keys(requestInit).length > 0 ? requestInit : undefined
+    });
+    const client2 = new Client({ name: `skill-mcp-${info.skillName}-${info.serverName}`, version: "1.0.0" }, { capabilities: {} });
+    try {
+      await client2.connect(transport);
+    } catch (error45) {
+      try {
+        await transport.close();
+      } catch {}
+      const errorMessage = error45 instanceof Error ? error45.message : String(error45);
+      throw new Error(`Failed to connect to MCP server "${info.serverName}".
 
-` + `Example:
-` + `  mcp:
-` + `    ${info.serverName}:
-` + `      command: npx
-` + `      args: [-y, @some/mcp-server]`);
+` + `URL: ${config3.url}
+` + `Reason: ${errorMessage}
+
+` + `Hints:
+` + `  - Verify the URL is correct and the server is running
+` + `  - Check if authentication headers are required
+` + `  - Ensure the server supports MCP over HTTP`);
+    }
+    const managedClient = {
+      client: client2,
+      transport,
+      skillName: info.skillName,
+      lastUsedAt: Date.now(),
+      connectionType: "http"
+    };
+    this.clients.set(key, managedClient);
+    this.startCleanupTimer();
+    return client2;
+  }
+  async createStdioClient(info, config3) {
+    const key = this.getClientKey(info);
+    if (!config3.command) {
+      throw new Error(`MCP server "${info.serverName}" is configured for stdio but missing 'command' field.`);
     }
     const command = config3.command;
     const args = config3.args || [];
@@ -45162,7 +47011,14 @@ class SkillMcpManager {
 ` + `  - Check if the MCP server package exists
 ` + `  - Verify the args are correct for this server`);
     }
-    this.clients.set(key, { client: client2, transport, skillName: info.skillName, lastUsedAt: Date.now() });
+    const managedClient = {
+      client: client2,
+      transport,
+      skillName: info.skillName,
+      lastUsedAt: Date.now(),
+      connectionType: "stdio"
+    };
+    this.clients.set(key, managedClient);
     this.startCleanupTimer();
     return client2;
   }
@@ -45365,6 +47221,7 @@ var HookNameSchema = exports_external.enum([
   "claude-code-hooks",
   "auto-slash-command",
   "edit-error-recovery",
+  "sisyphus-task-retry",
   "prometheus-md-only",
   "start-work",
   "sisyphus-orchestrator"
@@ -45828,28 +47685,55 @@ function buildFrontendSection(agents) {
   const frontendAgent = agents.find((a) => a.name === "frontend-ui-ux-engineer");
   if (!frontendAgent)
     return "";
-  return `### Frontend Files: Decision Gate (NOT a blind block)
+  return `### Frontend Files: VISUAL = HARD BLOCK (zero tolerance)
 
-Frontend files (.tsx, .jsx, .vue, .svelte, .css, etc.) require **classification before action**.
+**DEFAULT ASSUMPTION**: Any frontend file change is VISUAL until proven otherwise.
 
-#### Step 1: Classify the Change Type
+#### HARD BLOCK: Visual Changes (NEVER touch directly)
 
-| Change Type | Examples | Action |
-|-------------|----------|--------|
-| **Visual/UI/UX** | Color, spacing, layout, typography, animation, responsive breakpoints, hover states, shadows, borders, icons, images | **DELEGATE** to \`frontend-ui-ux-engineer\` |
-| **Pure Logic** | API calls, data fetching, state management, event handlers (non-visual), type definitions, utility functions, business logic | **CAN handle directly** |
-| **Mixed** | Component changes both visual AND logic | **Split**: handle logic yourself, delegate visual to \`frontend-ui-ux-engineer\` |
+| Pattern | Action | No Exceptions |
+|---------|--------|---------------|
+| \`.tsx\`, \`.jsx\` with styling | DELEGATE | Even "just add className" |
+| \`.vue\`, \`.svelte\` | DELEGATE | Even single prop change |
+| \`.css\`, \`.scss\`, \`.sass\`, \`.less\` | DELEGATE | Even color/margin tweak |
+| Any file with visual keywords | DELEGATE | See keyword list below |
 
-#### Step 2: Ask Yourself
+#### Keyword Detection (INSTANT DELEGATE)
 
-Before touching any frontend file, think:
-> "Is this change about **how it LOOKS** or **how it WORKS**?"
+If your change involves **ANY** of these keywords \u2192 **STOP. DELEGATE.**
 
-- **LOOKS** (colors, sizes, positions, animations) \u2192 DELEGATE
-- **WORKS** (data flow, API integration, state) \u2192 Handle directly
+\`\`\`
+style, className, tailwind, css, color, background, border, shadow,
+margin, padding, width, height, flex, grid, animation, transition,
+hover, responsive, font-size, font-weight, icon, svg, image, layout,
+position, display, opacity, z-index, transform, gradient, theme
+\`\`\`
 
-#### When in Doubt \u2192 DELEGATE if ANY of these keywords involved:
-style, className, tailwind, color, background, border, shadow, margin, padding, width, height, flex, grid, animation, transition, hover, responsive, font-size, icon, svg`;
+**YOU CANNOT**:
+- "Just quickly fix this style"
+- "It's only one className"
+- "Too simple to delegate"
+
+#### EXCEPTION: Pure Logic Only
+
+You MAY handle directly **ONLY IF ALL** conditions are met:
+1. Change is **100% logic** (API, state, event handlers, types, utils)
+2. **Zero** visual keywords in your diff
+3. No styling, layout, or appearance changes whatsoever
+
+| Pure Logic Examples | Visual Examples (DELEGATE) |
+|---------------------|---------------------------|
+| Add onClick API call | Change button color |
+| Fix pagination logic | Add loading spinner animation |
+| Add form validation | Make modal responsive |
+| Update state management | Adjust spacing/margins |
+
+#### Mixed Changes \u2192 SPLIT
+
+If change has BOTH logic AND visual:
+1. Handle logic yourself
+2. DELEGATE visual part to \`frontend-ui-ux-engineer\`
+3. **Never** combine them into one edit`;
 }
 function buildOracleSection(agents) {
   const oracleAgent = agents.find((a) => a.name === "oracle");
@@ -45889,7 +47773,7 @@ function buildHardBlocksSection(agents) {
     "| Leave code in broken state after failures | Never |"
   ];
   if (frontendAgent) {
-    blocks.unshift("| Frontend VISUAL changes (styling, layout, animation) | Always delegate to `frontend-ui-ux-engineer` |");
+    blocks.unshift("| Frontend VISUAL changes (styling, className, layout, animation, any visual keyword) | **HARD BLOCK** - Always delegate to `frontend-ui-ux-engineer`. Zero tolerance. |");
   }
   return `## Hard Blocks (NEVER violate)
 
@@ -45908,7 +47792,7 @@ function buildAntiPatternsSection(agents) {
     "| **Debugging** | Shotgun debugging, random changes |"
   ];
   if (frontendAgent) {
-    patterns.splice(4, 0, "| **Frontend** | Direct edit to visual/styling code (logic changes OK) |");
+    patterns.splice(4, 0, "| **Frontend** | ANY direct edit to visual/styling code. Keyword detected = DELEGATE. Pure logic only = OK |");
   }
   return `## Anti-Patterns (BLOCKING violations)
 
@@ -49618,7 +51502,7 @@ function createBuiltinAgents(disabledAgents = [], agentOverrides = {}, directory
   }
   if (!disabledAgents.includes("orchestrator-sisyphus")) {
     const orchestratorOverride = agentOverrides["orchestrator-sisyphus"];
-    const orchestratorModel = orchestratorOverride?.model;
+    const orchestratorModel = orchestratorOverride?.model ?? systemDefaultModel;
     let orchestratorConfig = createOrchestratorSisyphusAgent({
       model: orchestratorModel,
       availableAgents
@@ -49705,11 +51589,11 @@ var SISYPHUS_JUNIOR_DEFAULTS = {
   model: "anthropic/claude-sonnet-4-5",
   temperature: 0.1
 };
-function createSisyphusJuniorAgentWithOverrides(override) {
+function createSisyphusJuniorAgentWithOverrides(override, systemDefaultModel) {
   if (override?.disable) {
     override = undefined;
   }
-  const model = override?.model ?? SISYPHUS_JUNIOR_DEFAULTS.model;
+  const model = override?.model ?? systemDefaultModel ?? SISYPHUS_JUNIOR_DEFAULTS.model;
   const temperature = override?.temperature ?? SISYPHUS_JUNIOR_DEFAULTS.temperature;
   const promptAppend = override?.prompt_append;
   const prompt = buildSisyphusJuniorPrompt(promptAppend);
@@ -52485,7 +54369,7 @@ function createConfigHandler(deps) {
       const agentConfig = {
         Sisyphus: builtinAgents.Sisyphus
       };
-      agentConfig["Sisyphus-Junior"] = createSisyphusJuniorAgentWithOverrides(pluginConfig.agents?.["Sisyphus-Junior"]);
+      agentConfig["Sisyphus-Junior"] = createSisyphusJuniorAgentWithOverrides(pluginConfig.agents?.["Sisyphus-Junior"], config3.model);
       if (builderEnabled) {
         const { name: _buildName, ...buildConfigWithoutName } = configAgent?.build ?? {};
         const migratedBuildConfig = migrateAgentConfig(buildConfigWithoutName);
@@ -52697,6 +54581,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
     checkSessionExists: async (sessionId) => sessionExists(sessionId)
   }) : null;
   const editErrorRecovery = isHookEnabled("edit-error-recovery") ? createEditErrorRecoveryHook(ctx) : null;
+  const sisyphusTaskRetry = isHookEnabled("sisyphus-task-retry") ? createSisyphusTaskRetryHook(ctx) : null;
   const startWork = isHookEnabled("start-work") ? createStartWorkHook(ctx) : null;
   const sisyphusOrchestrator = isHookEnabled("sisyphus-orchestrator") ? createSisyphusOrchestratorHook(ctx) : null;
   const prometheusMdOnly = isHookEnabled("prometheus-md-only") ? createPrometheusMdOnlyHook(ctx) : null;
@@ -52859,6 +54744,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
         }
         if (sessionInfo?.id) {
           clearSessionAgent(sessionInfo.id);
+          resetMessageCursor(sessionInfo.id);
           firstMessageVariantGate.clear(sessionInfo.id);
           await skillMcpManager.disconnectSession(sessionInfo.id);
           await lspManager.cleanupTempDirectoryClients();
@@ -52943,6 +54829,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
       await agentUsageReminder?.["tool.execute.after"](input, output);
       await interactiveBashSession?.["tool.execute.after"](input, output);
       await editErrorRecovery?.["tool.execute.after"](input, output);
+      await sisyphusTaskRetry?.["tool.execute.after"](input, output);
       await sisyphusOrchestrator?.["tool.execute.after"]?.(input, output);
       await taskResumeInfo["tool.execute.after"](input, output);
     }