oh-my-opencode 3.6.0 → 3.7.1

package/dist/index.js

@@ -15329,9 +15329,12 @@ function normalizeSDKResponse(response, fallback, options) {
 }
 
 // src/shared/dynamic-truncator.ts
-var ANTHROPIC_ACTUAL_LIMIT = process.env.ANTHROPIC_1M_CONTEXT === "true" || process.env.VERTEX_ANTHROPIC_1M_CONTEXT === "true" ? 1e6 : 200000;
+var DEFAULT_ANTHROPIC_ACTUAL_LIMIT = 200000;
 var CHARS_PER_TOKEN_ESTIMATE = 4;
 var DEFAULT_TARGET_MAX_TOKENS = 50000;
+function getAnthropicActualLimit(modelCacheState) {
+  return (modelCacheState?.anthropicContext1MEnabled ?? false) || process.env.ANTHROPIC_1M_CONTEXT === "true" || process.env.VERTEX_ANTHROPIC_1M_CONTEXT === "true" ? 1e6 : DEFAULT_ANTHROPIC_ACTUAL_LIMIT;
+}
 function estimateTokens(text) {
   return Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE);
 }
@@ -15392,7 +15395,7 @@ function truncateToTokenLimit(output, maxTokens, preserveHeaderLines = 3) {
     removedCount
   };
 }
-async function getContextWindowUsage(ctx, sessionID) {
+async function getContextWindowUsage(ctx, sessionID, modelCacheState) {
   try {
     const response = await ctx.client.session.messages({
       path: { id: sessionID }
@@ -15404,17 +15407,18 @@ async function getContextWindowUsage(ctx, sessionID) {
     const lastAssistant = assistantMessages[assistantMessages.length - 1];
     const lastTokens = lastAssistant.tokens;
     const usedTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0) + (lastTokens?.output ?? 0);
-    const remainingTokens = ANTHROPIC_ACTUAL_LIMIT - usedTokens;
+    const anthropicActualLimit = getAnthropicActualLimit(modelCacheState);
+    const remainingTokens = anthropicActualLimit - usedTokens;
     return {
       usedTokens,
       remainingTokens,
-      usagePercentage: usedTokens / ANTHROPIC_ACTUAL_LIMIT
+      usagePercentage: usedTokens / anthropicActualLimit
     };
   } catch {
     return null;
   }
 }
-async function dynamicTruncate(ctx, sessionID, output, options = {}) {
+async function dynamicTruncate(ctx, sessionID, output, options = {}, modelCacheState) {
   if (typeof output !== "string") {
     return { result: String(output ?? ""), truncated: false };
   }
@@ -15422,7 +15426,7 @@ async function dynamicTruncate(ctx, sessionID, output, options = {}) {
     targetMaxTokens = DEFAULT_TARGET_MAX_TOKENS,
     preserveHeaderLines = 3
   } = options;
-  const usage = await getContextWindowUsage(ctx, sessionID);
+  const usage = await getContextWindowUsage(ctx, sessionID, modelCacheState);
   if (!usage) {
     return truncateToTokenLimit(output, targetMaxTokens, preserveHeaderLines);
   }
@@ -15435,10 +15439,10 @@ async function dynamicTruncate(ctx, sessionID, output, options = {}) {
   }
   return truncateToTokenLimit(output, maxOutputTokens, preserveHeaderLines);
 }
-function createDynamicTruncator(ctx) {
+function createDynamicTruncator(ctx, modelCacheState) {
   return {
-    truncate: (sessionID, output, options) => dynamicTruncate(ctx, sessionID, output, options),
-    getUsage: (sessionID) => getContextWindowUsage(ctx, sessionID),
+    truncate: (sessionID, output, options) => dynamicTruncate(ctx, sessionID, output, options, modelCacheState),
+    getUsage: (sessionID) => getContextWindowUsage(ctx, sessionID, modelCacheState),
     truncateSync: (output, maxTokens, preserveHeaderLines) => truncateToTokenLimit(output, maxTokens, preserveHeaderLines)
   };
 }
@@ -17434,7 +17438,7 @@ init_logger();
 import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
 import { join as join10 } from "path";
 function normalizeModelName(name) {
-  return name.toLowerCase().replace(/claude-(opus|sonnet|haiku)-4-5/g, "claude-$1-4.5").replace(/claude-(opus|sonnet|haiku)-4\.5/g, "claude-$1-4.5");
+  return name.toLowerCase().replace(/claude-(opus|sonnet|haiku)-(\d+)[.-](\d+)/g, "claude-$1-$2.$3");
 }
 function fuzzyMatchModel(target, available, providers) {
   log("[fuzzyMatchModel] called", { target, availableCount: available.size, providers });
@@ -17459,6 +17463,7 @@ function fuzzyMatchModel(target, available, providers) {
   const matches = candidates.filter((model) => normalizeModelName(model).includes(targetNormalized));
   log("[fuzzyMatchModel] substring matches", { targetNormalized, matchCount: matches.length, matches });
   if (matches.length === 0) {
+    log("[fuzzyMatchModel] WARNING: no match found", { target, availableCount: available.size, providers });
     return null;
   }
   const exactMatch = matches.find((model) => normalizeModelName(model) === targetNormalized);
@@ -17620,55 +17625,6 @@ async function fetchAvailableModels(client, options) {
   }
   return modelSet;
 }
-function isAnyFallbackModelAvailable(fallbackChain, availableModels) {
-  if (availableModels.size > 0) {
-    for (const entry of fallbackChain) {
-      const hasAvailableProvider = entry.providers.some((provider) => {
-        return fuzzyMatchModel(entry.model, availableModels, [provider]) !== null;
-      });
-      if (hasAvailableProvider) {
-        return true;
-      }
-    }
-  }
-  const connectedProviders = readConnectedProvidersCache();
-  if (connectedProviders) {
-    const connectedSet = new Set(connectedProviders);
-    for (const entry of fallbackChain) {
-      if (entry.providers.some((p) => connectedSet.has(p))) {
-        log("[isAnyFallbackModelAvailable] model not in available set, but provider is connected", {
-          model: entry.model,
-          availableCount: availableModels.size
-        });
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function isAnyProviderConnected(providers, availableModels) {
-  if (availableModels.size > 0) {
-    const providerSet = new Set(providers);
-    for (const model of availableModels) {
-      const [provider] = model.split("/");
-      if (providerSet.has(provider)) {
-        log("[isAnyProviderConnected] found model from required provider", { provider, model });
-        return true;
-      }
-    }
-  }
-  const connectedProviders = readConnectedProvidersCache();
-  if (connectedProviders) {
-    const connectedSet = new Set(connectedProviders);
-    for (const provider of providers) {
-      if (connectedSet.has(provider)) {
-        log("[isAnyProviderConnected] provider connected via cache", { provider });
-        return true;
-      }
-    }
-  }
-  return false;
-}
 function isModelCacheAvailable() {
   if (hasProviderModelsCache()) {
     return true;
@@ -17816,6 +17772,139 @@ function normalizeModel2(model) {
 function resolveModel(input) {
   return normalizeModel2(input.userModel) ?? normalizeModel2(input.inheritedModel) ?? input.systemDefault;
 }
+// src/shared/fallback-model-availability.ts
+init_logger();
+
+// src/shared/model-name-matcher.ts
+init_logger();
+function normalizeModelName2(name) {
+  return name.toLowerCase().replace(/claude-(opus|sonnet|haiku)-(\d+)[.-](\d+)/g, "claude-$1-$2.$3");
+}
+function fuzzyMatchModel2(target, available, providers) {
+  log("[fuzzyMatchModel] called", { target, availableCount: available.size, providers });
+  if (available.size === 0) {
+    log("[fuzzyMatchModel] empty available set");
+    return null;
+  }
+  const targetNormalized = normalizeModelName2(target);
+  let candidates = Array.from(available);
+  if (providers && providers.length > 0) {
+    const providerSet = new Set(providers);
+    candidates = candidates.filter((model) => {
+      const [provider] = model.split("/");
+      return providerSet.has(provider);
+    });
+    log("[fuzzyMatchModel] filtered by providers", {
+      candidateCount: candidates.length,
+      candidates: candidates.slice(0, 10)
+    });
+  }
+  if (candidates.length === 0) {
+    log("[fuzzyMatchModel] no candidates after filter");
+    return null;
+  }
+  const matches = candidates.filter((model) => normalizeModelName2(model).includes(targetNormalized));
+  log("[fuzzyMatchModel] substring matches", {
+    targetNormalized,
+    matchCount: matches.length,
+    matches
+  });
+  if (matches.length === 0) {
+    return null;
+  }
+  const exactMatch = matches.find((model) => normalizeModelName2(model) === targetNormalized);
+  if (exactMatch) {
+    log("[fuzzyMatchModel] exact match found", { exactMatch });
+    return exactMatch;
+  }
+  const exactModelIdMatches = matches.filter((model) => {
+    const modelId = model.split("/").slice(1).join("/");
+    return normalizeModelName2(modelId) === targetNormalized;
+  });
+  if (exactModelIdMatches.length > 0) {
+    const result2 = exactModelIdMatches.reduce((shortest, current) => current.length < shortest.length ? current : shortest);
+    log("[fuzzyMatchModel] exact model ID match found", {
+      result: result2,
+      candidateCount: exactModelIdMatches.length
+    });
+    return result2;
+  }
+  const result = matches.reduce((shortest, current) => current.length < shortest.length ? current : shortest);
+  log("[fuzzyMatchModel] shortest match", { result });
+  return result;
+}
+
+// src/shared/fallback-model-availability.ts
+function resolveFirstAvailableFallback(fallbackChain, availableModels) {
+  for (const entry of fallbackChain) {
+    for (const provider of entry.providers) {
+      const matchedModel = fuzzyMatchModel2(entry.model, availableModels, [provider]);
+      log("[resolveFirstAvailableFallback] attempt", {
+        provider,
+        requestedModel: entry.model,
+        resolvedModel: matchedModel
+      });
+      if (matchedModel !== null) {
+        log("[resolveFirstAvailableFallback] resolved", {
+          provider,
+          requestedModel: entry.model,
+          resolvedModel: matchedModel
+        });
+        return { provider, model: matchedModel };
+      }
+    }
+  }
+  log("[resolveFirstAvailableFallback] WARNING: no fallback model resolved", {
+    chain: fallbackChain.map((entry) => ({
+      model: entry.model,
+      providers: entry.providers
+    })),
+    availableCount: availableModels.size
+  });
+  return null;
+}
+function isAnyFallbackModelAvailable(fallbackChain, availableModels) {
+  if (resolveFirstAvailableFallback(fallbackChain, availableModels) !== null) {
+    return true;
+  }
+  const connectedProviders = readConnectedProvidersCache();
+  if (connectedProviders) {
+    const connectedSet = new Set(connectedProviders);
+    for (const entry of fallbackChain) {
+      if (entry.providers.some((p) => connectedSet.has(p))) {
+        log("[isAnyFallbackModelAvailable] WARNING: No fuzzy match found for any model in fallback chain, but provider is connected. Agent may fail at runtime.", { chain: fallbackChain.map((entryItem) => entryItem.model), availableCount: availableModels.size });
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isAnyProviderConnected(providers, availableModels) {
+  if (availableModels.size > 0) {
+    const providerSet = new Set(providers);
+    for (const model of availableModels) {
+      const [provider] = model.split("/");
+      if (providerSet.has(provider)) {
+        log("[isAnyProviderConnected] found model from required provider", {
+          provider,
+          model
+        });
+        return true;
+      }
+    }
+  }
+  const connectedProviders = readConnectedProvidersCache();
+  if (connectedProviders) {
+    const connectedSet = new Set(connectedProviders);
+    for (const provider of providers) {
+      if (connectedSet.has(provider)) {
+        log("[isAnyProviderConnected] provider connected via cache", { provider });
+        return true;
+      }
+    }
+  }
+  return false;
+}
 // src/features/hook-message-injector/injector.ts
 import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync6, readdirSync, writeFileSync as writeFileSync3 } from "fs";
 import { join as join11 } from "path";
@@ -18303,13 +18392,29 @@ async function replaceTmuxPane(paneId, sessionId, description, config, serverUrl
 }
 // src/shared/tmux/tmux-utils/layout.ts
 var {spawn: spawn8 } = globalThis.Bun;
-async function enforceMainPaneWidth(mainPaneId, windowWidth) {
+async function applyLayout(layout, mainPaneSize) {
+  const tmux = await getTmuxPath();
+  if (!tmux)
+    return;
+  const layoutProc = spawn8([tmux, "select-layout", layout], {
+    stdout: "ignore",
+    stderr: "ignore"
+  });
+  await layoutProc.exited;
+  if (layout.startsWith("main-")) {
+    const dimension = layout === "main-horizontal" ? "main-pane-height" : "main-pane-width";
+    const sizeProc = spawn8([tmux, "set-window-option", dimension, `${mainPaneSize}%`], { stdout: "ignore", stderr: "ignore" });
+    await sizeProc.exited;
+  }
+}
+async function enforceMainPaneWidth(mainPaneId, windowWidth, mainPaneSize) {
   const { log: log2 } = await Promise.resolve().then(() => (init_logger(), exports_logger));
   const tmux = await getTmuxPath();
   if (!tmux)
     return;
   const dividerWidth = 1;
-  const mainWidth = Math.floor((windowWidth - dividerWidth) / 2);
+  const boundedMainPaneSize = Math.max(20, Math.min(80, mainPaneSize));
+  const mainWidth = Math.floor((windowWidth - dividerWidth) * boundedMainPaneSize / 100);
   const proc = spawn8([tmux, "resize-pane", "-t", mainPaneId, "-x", String(mainWidth)], {
     stdout: "ignore",
     stderr: "ignore"
@@ -18318,7 +18423,8 @@ async function enforceMainPaneWidth(mainPaneId, windowWidth) {
   log2("[enforceMainPaneWidth] main pane resized", {
     mainPaneId,
     mainWidth,
-    windowWidth
+    windowWidth,
+    mainPaneSize: boundedMainPaneSize
   });
 }
 // src/shared/model-suggestion-retry.ts
@@ -18668,6 +18774,26 @@ async function deletePart(client, sessionID, messageID, partID) {
     return false;
   }
 }
+// src/shared/git-worktree/parse-status-porcelain-line.ts
+function toGitFileStatus(statusToken) {
+  if (statusToken === "A" || statusToken === "??")
+    return "added";
+  if (statusToken === "D")
+    return "deleted";
+  return "modified";
+}
+function parseGitStatusPorcelainLine(line) {
+  if (!line)
+    return null;
+  const statusToken = line.substring(0, 2).trim();
+  const filePath = line.substring(3);
+  if (!filePath)
+    return null;
+  return {
+    filePath,
+    status: toGitFileStatus(statusToken)
+  };
+}
 // src/shared/git-worktree/parse-status-porcelain.ts
 function parseGitStatusPorcelain(output) {
   const map2 = new Map;
@@ -18675,19 +18801,10 @@ function parseGitStatusPorcelain(output) {
     return map2;
   for (const line of output.split(`
 `)) {
-    if (!line)
-      continue;
-    const status = line.substring(0, 2).trim();
-    const filePath = line.substring(3);
-    if (!filePath)
+    const parsed = parseGitStatusPorcelainLine(line);
+    if (!parsed)
       continue;
-    if (status === "A" || status === "??") {
-      map2.set(filePath, "added");
-    } else if (status === "D") {
-      map2.set(filePath, "deleted");
-    } else {
-      map2.set(filePath, "modified");
-    }
+    map2.set(parsed.filePath, parsed.status);
   }
   return map2;
 }
@@ -19372,14 +19489,20 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
 }
 // src/hooks/context-window-monitor.ts
 var ANTHROPIC_DISPLAY_LIMIT = 1e6;
-var ANTHROPIC_ACTUAL_LIMIT2 = process.env.ANTHROPIC_1M_CONTEXT === "true" || process.env.VERTEX_ANTHROPIC_1M_CONTEXT === "true" ? 1e6 : 200000;
+var DEFAULT_ANTHROPIC_ACTUAL_LIMIT2 = 200000;
 var CONTEXT_WARNING_THRESHOLD = 0.7;
+function getAnthropicActualLimit2(modelCacheState) {
+  return (modelCacheState?.anthropicContext1MEnabled ?? false) || process.env.ANTHROPIC_1M_CONTEXT === "true" || process.env.VERTEX_ANTHROPIC_1M_CONTEXT === "true" ? 1e6 : DEFAULT_ANTHROPIC_ACTUAL_LIMIT2;
+}
 var CONTEXT_REMINDER = `${createSystemDirective(SystemDirectiveTypes.CONTEXT_WINDOW_MONITOR)}
 
 You are using Anthropic Claude with 1M context window.
 You have plenty of context remaining - do NOT rush or skip tasks.
 Complete your work thoroughly and methodically.`;
-function createContextWindowMonitorHook(_ctx) {
+function isAnthropicProvider(providerID) {
+  return providerID === "anthropic" || providerID === "google-vertex-anthropic";
+}
+function createContextWindowMonitorHook(_ctx, modelCacheState) {
   const remindedSessions = new Set;
   const tokenCache = new Map;
   const toolExecuteAfter = async (input, output) => {
@@ -19389,11 +19512,11 @@ function createContextWindowMonitorHook(_ctx) {
     const cached = tokenCache.get(sessionID);
     if (!cached)
       return;
-    if (cached.providerID !== "anthropic")
+    if (!isAnthropicProvider(cached.providerID))
       return;
     const lastTokens = cached.tokens;
     const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0);
-    const actualUsagePercentage = totalInputTokens / ANTHROPIC_ACTUAL_LIMIT2;
+    const actualUsagePercentage = totalInputTokens / getAnthropicActualLimit2(modelCacheState);
     if (actualUsagePercentage < CONTEXT_WARNING_THRESHOLD)
       return;
     remindedSessions.add(sessionID);
@@ -33307,6 +33430,7 @@ function isCliPathUsable(cliPath) {
 var pendingCalls = new Map;
 var PENDING_CALL_TTL = 60000;
 var cleanupIntervalStarted = false;
+var cleanupInterval;
 function cleanupOldPendingCalls() {
   const now = Date.now();
   for (const [callID, call] of pendingCalls) {
@@ -33319,7 +33443,10 @@ function startPendingCallCleanup() {
   if (cleanupIntervalStarted)
     return;
   cleanupIntervalStarted = true;
-  setInterval(cleanupOldPendingCalls, 1e4);
+  cleanupInterval = setInterval(cleanupOldPendingCalls, 1e4);
+  if (typeof cleanupInterval === "object" && "unref" in cleanupInterval) {
+    cleanupInterval.unref();
+  }
 }
 function registerPendingCall(callID, pendingCall) {
   pendingCalls.set(callID, pendingCall);
@@ -33476,7 +33603,7 @@ var TOOL_SPECIFIC_MAX_TOKENS = {
   WebFetch: WEBFETCH_MAX_TOKENS
 };
 function createToolOutputTruncatorHook(ctx, options) {
-  const truncator = createDynamicTruncator(ctx);
+  const truncator = createDynamicTruncator(ctx, options?.modelCacheState);
   const truncateAll = options?.experimental?.truncate_all_tool_outputs ?? false;
   const toolExecuteAfter = async (input, output) => {
     if (!truncateAll && !TRUNCATABLE_TOOLS.includes(input.tool))
@@ -33632,9 +33759,9 @@ ${result}${truncationNotice}`;
 }
 
 // src/hooks/directory-agents-injector/hook.ts
-function createDirectoryAgentsInjectorHook(ctx) {
+function createDirectoryAgentsInjectorHook(ctx, modelCacheState) {
   const sessionCaches = new Map;
-  const truncator = createDynamicTruncator(ctx);
+  const truncator = createDynamicTruncator(ctx, modelCacheState);
   const toolExecuteAfter = async (input, output) => {
     const toolName = input.tool.toLowerCase();
     if (toolName === "read") {
@@ -33760,9 +33887,9 @@ ${result}${truncationNotice}`;
 }
 
 // src/hooks/directory-readme-injector/hook.ts
-function createDirectoryReadmeInjectorHook(ctx) {
+function createDirectoryReadmeInjectorHook(ctx, modelCacheState) {
   const sessionCaches = new Map;
-  const truncator = createDynamicTruncator(ctx);
+  const truncator = createDynamicTruncator(ctx, modelCacheState);
   const toolExecuteAfter = async (input, output) => {
     const toolName = input.tool.toLowerCase();
     if (toolName === "read") {
@@ -35389,6 +35516,13 @@ var THINKING_CONFIGS = {
     },
     maxTokens: 128000
   },
+  "google-vertex-anthropic": {
+    thinking: {
+      type: "enabled",
+      budgetTokens: 64000
+    },
+    maxTokens: 128000
+  },
   "amazon-bedrock": {
     reasoningConfig: {
       type: "enabled",
@@ -35431,6 +35565,7 @@ var THINKING_CONFIGS = {
 };
 var THINKING_CAPABLE_MODELS = {
   anthropic: ["claude-sonnet-4", "claude-opus-4", "claude-3"],
+  "google-vertex-anthropic": ["claude-sonnet-4", "claude-opus-4", "claude-3"],
   "amazon-bedrock": ["claude", "anthropic"],
   google: ["gemini-2", "gemini-3"],
   "google-vertex": ["gemini-2", "gemini-3"],
@@ -36426,7 +36561,7 @@ function getToolInput(sessionId, toolName, invocationId) {
     return null;
   return entry.toolInput;
 }
-var cleanupInterval = setInterval(() => {
+var cleanupInterval2 = setInterval(() => {
   const now = Date.now();
   for (const [key, entry] of cache.entries()) {
     if (now - entry.timestamp > CACHE_TTL) {
@@ -36434,8 +36569,8 @@ var cleanupInterval = setInterval(() => {
     }
   }
 }, CACHE_TTL);
-if (typeof cleanupInterval === "object" && "unref" in cleanupInterval) {
-  cleanupInterval.unref();
+if (typeof cleanupInterval2 === "object" && "unref" in cleanupInterval2) {
+  cleanupInterval2.unref();
 }
 
 // src/hooks/claude-code-hooks/handlers/tool-execute-after-handler.ts
@@ -37195,8 +37330,8 @@ ${result}${truncationNotice}`;
 
 // src/hooks/rules-injector/hook.ts
 var TRACKED_TOOLS = ["read", "write", "edit", "multiedit"];
-function createRulesInjectorHook(ctx) {
-  const truncator = createDynamicTruncator(ctx);
+function createRulesInjectorHook(ctx, modelCacheState) {
+  const truncator = createDynamicTruncator(ctx, modelCacheState);
   const { getSessionCache: getSessionCache3, clearSessionCache } = createSessionCacheStore();
   const { processFilePathForInjection } = createRuleInjectionProcessor({
     workspaceDirectory: ctx.directory,
@@ -37848,6 +37983,7 @@ async function showLocalDevToast(ctx, version2, isSisyphusEnabled) {
 // src/hooks/auto-update-checker/hook.ts
 function createAutoUpdateCheckerHook(ctx, options = {}) {
   const { showStartupToast = true, isSisyphusEnabled = false, autoUpdate = true } = options;
+  const isCliRunMode = process.env.OPENCODE_CLI_RUN_MODE === "true";
   const getToastMessage = (isUpdate, latestVersion) => {
     if (isSisyphusEnabled) {
       return isUpdate ? `Sisyphus on steroids is steering OpenCode.
@@ -37861,6 +37997,8 @@ v${latestVersion} available. Restart OpenCode to apply.` : "OpenCode is now on S
     event: ({ event }) => {
       if (event.type !== "session.created")
         return;
+      if (isCliRunMode)
+        return;
       if (hasChecked)
         return;
       const props = event.properties;
@@ -42046,6 +42184,265 @@ agent-browser trace stop trace.zip                   # Stop and save trace
 Install: \`bun add -g agent-browser && agent-browser install\`. Run \`agent-browser --help\` for all commands. Repo: https://github.com/vercel-labs/agent-browser`,
   allowedTools: ["Bash(agent-browser:*)"]
 };
+// src/features/builtin-skills/skills/playwright-cli.ts
+var playwrightCliSkill = {
+  name: "playwright",
+  description: "MUST USE for any browser-related tasks. Browser automation via playwright-cli - verification, browsing, information gathering, web scraping, testing, screenshots, and all browser interactions.",
+  template: `# Browser Automation with playwright-cli
+
+## Quick start
+
+\`\`\`bash
+# open new browser
+playwright-cli open
+# navigate to a page
+playwright-cli goto https://playwright.dev
+# interact with the page using refs from the snapshot
+playwright-cli click e15
+playwright-cli type "page.click"
+playwright-cli press Enter
+# take a screenshot
+playwright-cli screenshot
+# close the browser
+playwright-cli close
+\`\`\`
+
+## Commands
+
+### Core
+
+\`\`\`bash
+playwright-cli open
+# open and navigate right away
+playwright-cli open https://example.com/
+playwright-cli goto https://playwright.dev
+playwright-cli type "search query"
+playwright-cli click e3
+playwright-cli dblclick e7
+playwright-cli fill e5 "user@example.com"
+playwright-cli drag e2 e8
+playwright-cli hover e4
+playwright-cli select e9 "option-value"
+playwright-cli upload ./document.pdf
+playwright-cli check e12
+playwright-cli uncheck e12
+playwright-cli snapshot
+playwright-cli snapshot --filename=after-click.yaml
+playwright-cli eval "document.title"
+playwright-cli eval "el => el.textContent" e5
+playwright-cli dialog-accept
+playwright-cli dialog-accept "confirmation text"
+playwright-cli dialog-dismiss
+playwright-cli resize 1920 1080
+playwright-cli close
+\`\`\`
+
+### Navigation
+
+\`\`\`bash
+playwright-cli go-back
+playwright-cli go-forward
+playwright-cli reload
+\`\`\`
+
+### Keyboard
+
+\`\`\`bash
+playwright-cli press Enter
+playwright-cli press ArrowDown
+playwright-cli keydown Shift
+playwright-cli keyup Shift
+\`\`\`
+
+### Mouse
+
+\`\`\`bash
+playwright-cli mousemove 150 300
+playwright-cli mousedown
+playwright-cli mousedown right
+playwright-cli mouseup
+playwright-cli mouseup right
+playwright-cli mousewheel 0 100
+\`\`\`
+
+### Save as
+
+\`\`\`bash
+playwright-cli screenshot
+playwright-cli screenshot e5
+playwright-cli screenshot --filename=page.png
+playwright-cli pdf --filename=page.pdf
+\`\`\`
+
+### Tabs
+
+\`\`\`bash
+playwright-cli tab-list
+playwright-cli tab-new
+playwright-cli tab-new https://example.com/page
+playwright-cli tab-close
+playwright-cli tab-close 2
+playwright-cli tab-select 0
+\`\`\`
+
+### Storage
+
+\`\`\`bash
+playwright-cli state-save
+playwright-cli state-save auth.json
+playwright-cli state-load auth.json
+
+# Cookies
+playwright-cli cookie-list
+playwright-cli cookie-list --domain=example.com
+playwright-cli cookie-get session_id
+playwright-cli cookie-set session_id abc123
+playwright-cli cookie-set session_id abc123 --domain=example.com --httpOnly --secure
+playwright-cli cookie-delete session_id
+playwright-cli cookie-clear
+
+# LocalStorage
+playwright-cli localstorage-list
+playwright-cli localstorage-get theme
+playwright-cli localstorage-set theme dark
+playwright-cli localstorage-delete theme
+playwright-cli localstorage-clear
+
+# SessionStorage
+playwright-cli sessionstorage-list
+playwright-cli sessionstorage-get step
+playwright-cli sessionstorage-set step 3
+playwright-cli sessionstorage-delete step
+playwright-cli sessionstorage-clear
+\`\`\`
+
+### Network
+
+\`\`\`bash
+playwright-cli route "**/*.jpg" --status=404
+playwright-cli route "https://api.example.com/**" --body='{"mock": true}'
+playwright-cli route-list
+playwright-cli unroute "**/*.jpg"
+playwright-cli unroute
+\`\`\`
+
+### DevTools
+
+\`\`\`bash
+playwright-cli console
+playwright-cli console warning
+playwright-cli network
+playwright-cli run-code "async page => await page.context().grantPermissions(['geolocation'])"
+playwright-cli tracing-start
+playwright-cli tracing-stop
+playwright-cli video-start
+playwright-cli video-stop video.webm
+\`\`\`
+
+### Install
+
+\`\`\`bash
+playwright-cli install --skills
+playwright-cli install-browser
+\`\`\`
+
+### Configuration
+\`\`\`bash
+# Use specific browser when creating session
+playwright-cli open --browser=chrome
+playwright-cli open --browser=firefox
+playwright-cli open --browser=webkit
+playwright-cli open --browser=msedge
+# Connect to browser via extension
+playwright-cli open --extension
+
+# Use persistent profile (by default profile is in-memory)
+playwright-cli open --persistent
+# Use persistent profile with custom directory
+playwright-cli open --profile=/path/to/profile
+
+# Start with config file
+playwright-cli open --config=my-config.json
+
+# Close the browser
+playwright-cli close
+# Delete user data for the default session
+playwright-cli delete-data
+\`\`\`
+
+### Browser Sessions
+
+\`\`\`bash
+# create new browser session named "mysession" with persistent profile
+playwright-cli -s=mysession open example.com --persistent
+# same with manually specified profile directory (use when requested explicitly)
+playwright-cli -s=mysession open example.com --profile=/path/to/profile
+playwright-cli -s=mysession click e6
+playwright-cli -s=mysession close  # stop a named browser
+playwright-cli -s=mysession delete-data  # delete user data for persistent session
+
+playwright-cli list
+# Close all browsers
+playwright-cli close-all
+# Forcefully kill all browser processes
+playwright-cli kill-all
+\`\`\`
+
+## Example: Form submission
+
+\`\`\`bash
+playwright-cli open https://example.com/form
+playwright-cli snapshot
+
+playwright-cli fill e1 "user@example.com"
+playwright-cli fill e2 "password123"
+playwright-cli click e3
+playwright-cli snapshot
+playwright-cli close
+\`\`\`
+
+## Example: Multi-tab workflow
+
+\`\`\`bash
+playwright-cli open https://example.com
+playwright-cli tab-new https://example.com/other
+playwright-cli tab-list
+playwright-cli tab-select 0
+playwright-cli snapshot
+playwright-cli close
+\`\`\`
+
+## Example: Debugging with DevTools
+
+\`\`\`bash
+playwright-cli open https://example.com
+playwright-cli click e4
+playwright-cli fill e7 "test"
+playwright-cli console
+playwright-cli network
+playwright-cli close
+\`\`\`
+
+\`\`\`bash
+playwright-cli open https://example.com
+playwright-cli tracing-start
+playwright-cli click e4
+playwright-cli fill e7 "test"
+playwright-cli tracing-stop
+playwright-cli close
+\`\`\`
+
+## Specific tasks
+
+* **Request mocking** [references/request-mocking.md](references/request-mocking.md)
+* **Running Playwright code** [references/running-code.md](references/running-code.md)
+* **Browser session management** [references/session-management.md](references/session-management.md)
+* **Storage state (cookies, localStorage)** [references/storage-state.md](references/storage-state.md)
+* **Test generation** [references/test-generation.md](references/test-generation.md)
+* **Tracing** [references/tracing.md](references/tracing.md)
+* **Video recording** [references/video-recording.md](references/video-recording.md)`,
+  allowedTools: ["Bash(playwright-cli:*)"]
+};
 // src/features/builtin-skills/skills/frontend-ui-ux.ts
 var frontendUiUxSkill = {
   name: "frontend-ui-ux",
@@ -43455,7 +43852,14 @@ EOF
 // src/features/builtin-skills/skills.ts
 function createBuiltinSkills(options = {}) {
   const { browserProvider = "playwright", disabledSkills } = options;
-  const browserSkill = browserProvider === "agent-browser" ? agentBrowserSkill : playwrightSkill;
+  let browserSkill;
+  if (browserProvider === "agent-browser") {
+    browserSkill = agentBrowserSkill;
+  } else if (browserProvider === "playwright-cli") {
+    browserSkill = playwrightCliSkill;
+  } else {
+    browserSkill = playwrightSkill;
+  }
   const skills = [browserSkill, frontendUiUxSkill, gitMasterSkill, devBrowserSkill];
   if (!disabledSkills) {
     return skills;
@@ -45835,9 +46239,14 @@ function createUnstableAgentBabysitterHook(ctx, options) {
 // src/hooks/preemptive-compaction.ts
 init_logger();
 var DEFAULT_ACTUAL_LIMIT = 200000;
-var ANTHROPIC_ACTUAL_LIMIT3 = process.env.ANTHROPIC_1M_CONTEXT === "true" || process.env.VERTEX_ANTHROPIC_1M_CONTEXT === "true" ? 1e6 : DEFAULT_ACTUAL_LIMIT;
+function getAnthropicActualLimit3(modelCacheState) {
+  return (modelCacheState?.anthropicContext1MEnabled ?? false) || process.env.ANTHROPIC_1M_CONTEXT === "true" || process.env.VERTEX_ANTHROPIC_1M_CONTEXT === "true" ? 1e6 : DEFAULT_ACTUAL_LIMIT;
+}
 var PREEMPTIVE_COMPACTION_THRESHOLD = 0.78;
-function createPreemptiveCompactionHook(ctx) {
+function isAnthropicProvider2(providerID) {
+  return providerID === "anthropic" || providerID === "google-vertex-anthropic";
+}
+function createPreemptiveCompactionHook(ctx, modelCacheState) {
   const compactionInProgress = new Set;
   const compactedSessions = new Set;
   const tokenCache = new Map;
@@ -45848,7 +46257,7 @@ function createPreemptiveCompactionHook(ctx) {
     const cached2 = tokenCache.get(sessionID);
     if (!cached2)
       return;
-    const actualLimit = cached2.providerID === "anthropic" ? ANTHROPIC_ACTUAL_LIMIT3 : DEFAULT_ACTUAL_LIMIT;
+    const actualLimit = isAnthropicProvider2(cached2.providerID) ? getAnthropicActualLimit3(modelCacheState) : DEFAULT_ACTUAL_LIMIT;
     const lastTokens = cached2.tokens;
     const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0);
     const usageRatio = totalInputTokens / actualLimit;
@@ -45982,13 +46391,332 @@ function createWriteExistingFileGuardHook(ctx) {
     }
   };
 }
+// src/tools/hashline-edit/constants.ts
+var HASH_DICT = [
+  "00",
+  "01",
+  "02",
+  "03",
+  "04",
+  "05",
+  "06",
+  "07",
+  "08",
+  "09",
+  "0a",
+  "0b",
+  "0c",
+  "0d",
+  "0e",
+  "0f",
+  "10",
+  "11",
+  "12",
+  "13",
+  "14",
+  "15",
+  "16",
+  "17",
+  "18",
+  "19",
+  "1a",
+  "1b",
+  "1c",
+  "1d",
+  "1e",
+  "1f",
+  "20",
+  "21",
+  "22",
+  "23",
+  "24",
+  "25",
+  "26",
+  "27",
+  "28",
+  "29",
+  "2a",
+  "2b",
+  "2c",
+  "2d",
+  "2e",
+  "2f",
+  "30",
+  "31",
+  "32",
+  "33",
+  "34",
+  "35",
+  "36",
+  "37",
+  "38",
+  "39",
+  "3a",
+  "3b",
+  "3c",
+  "3d",
+  "3e",
+  "3f",
+  "40",
+  "41",
+  "42",
+  "43",
+  "44",
+  "45",
+  "46",
+  "47",
+  "48",
+  "49",
+  "4a",
+  "4b",
+  "4c",
+  "4d",
+  "4e",
+  "4f",
+  "50",
+  "51",
+  "52",
+  "53",
+  "54",
+  "55",
+  "56",
+  "57",
+  "58",
+  "59",
+  "5a",
+  "5b",
+  "5c",
+  "5d",
+  "5e",
+  "5f",
+  "60",
+  "61",
+  "62",
+  "63",
+  "64",
+  "65",
+  "66",
+  "67",
+  "68",
+  "69",
+  "6a",
+  "6b",
+  "6c",
+  "6d",
+  "6e",
+  "6f",
+  "70",
+  "71",
+  "72",
+  "73",
+  "74",
+  "75",
+  "76",
+  "77",
+  "78",
+  "79",
+  "7a",
+  "7b",
+  "7c",
+  "7d",
+  "7e",
+  "7f",
+  "80",
+  "81",
+  "82",
+  "83",
+  "84",
+  "85",
+  "86",
+  "87",
+  "88",
+  "89",
+  "8a",
+  "8b",
+  "8c",
+  "8d",
+  "8e",
+  "8f",
+  "90",
+  "91",
+  "92",
+  "93",
+  "94",
+  "95",
+  "96",
+  "97",
+  "98",
+  "99",
+  "9a",
+  "9b",
+  "9c",
+  "9d",
+  "9e",
+  "9f",
+  "a0",
+  "a1",
+  "a2",
+  "a3",
+  "a4",
+  "a5",
+  "a6",
+  "a7",
+  "a8",
+  "a9",
+  "aa",
+  "ab",
+  "ac",
+  "ad",
+  "ae",
+  "af",
+  "b0",
+  "b1",
+  "b2",
+  "b3",
+  "b4",
+  "b5",
+  "b6",
+  "b7",
+  "b8",
+  "b9",
+  "ba",
+  "bb",
+  "bc",
+  "bd",
+  "be",
+  "bf",
+  "c0",
+  "c1",
+  "c2",
+  "c3",
+  "c4",
+  "c5",
+  "c6",
+  "c7",
+  "c8",
+  "c9",
+  "ca",
+  "cb",
+  "cc",
+  "cd",
+  "ce",
+  "cf",
+  "d0",
+  "d1",
+  "d2",
+  "d3",
+  "d4",
+  "d5",
+  "d6",
+  "d7",
+  "d8",
+  "d9",
+  "da",
+  "db",
+  "dc",
+  "dd",
+  "de",
+  "df",
+  "e0",
+  "e1",
+  "e2",
+  "e3",
+  "e4",
+  "e5",
+  "e6",
+  "e7",
+  "e8",
+  "e9",
+  "ea",
+  "eb",
+  "ec",
+  "ed",
+  "ee",
+  "ef",
+  "f0",
+  "f1",
+  "f2",
+  "f3",
+  "f4",
+  "f5",
+  "f6",
+  "f7",
+  "f8",
+  "f9",
+  "fa",
+  "fb",
+  "fc",
+  "fd",
+  "fe",
+  "ff"
+];
+
+// src/tools/hashline-edit/hash-computation.ts
+function computeLineHash(_lineNumber, content) {
+  const stripped = content.replace(/\s+/g, "");
+  const hash2 = Bun.hash.xxHash32(stripped);
+  const index = hash2 % 256;
+  return HASH_DICT[index];
+}
+
+// src/hooks/hashline-read-enhancer/hook.ts
+var READ_LINE_PATTERN = /^(\d+): (.*)$/;
+function isReadTool(toolName) {
+  return toolName.toLowerCase() === "read";
+}
+function shouldProcess(config2) {
+  return config2.hashline_edit?.enabled ?? false;
+}
+function isTextFile(output) {
+  const firstLine = output.split(`
+`)[0] ?? "";
+  return READ_LINE_PATTERN.test(firstLine);
+}
+function transformLine(line) {
+  const match = READ_LINE_PATTERN.exec(line);
+  if (!match) {
+    return line;
+  }
+  const lineNumber = parseInt(match[1], 10);
+  const content = match[2];
+  const hash2 = computeLineHash(lineNumber, content);
+  return `${lineNumber}:${hash2}|${content}`;
+}
+function transformOutput(output) {
+  if (!output) {
+    return output;
+  }
+  if (!isTextFile(output)) {
+    return output;
+  }
+  const lines = output.split(`
+`);
+  return lines.map(transformLine).join(`
+`);
+}
+function createHashlineReadEnhancerHook(_ctx, config2) {
+  return {
+    "tool.execute.after": async (input, output) => {
+      if (!isReadTool(input.tool)) {
+        return;
+      }
+      if (typeof output.output !== "string") {
+        return;
+      }
+      if (!shouldProcess(config2)) {
+        return;
+      }
+      output.output = transformOutput(output.output);
+    }
+  };
+}
 // src/hooks/anthropic-effort/hook.ts
 var OPUS_4_6_PATTERN = /claude-opus-4[-.]6/i;
 function normalizeModelID2(modelID) {
   return modelID.replace(/\.(\d+)/g, "-$1");
 }
 function isClaudeProvider(providerID, modelID) {
-  if (["anthropic", "opencode"].includes(providerID))
+  if (["anthropic", "google-vertex-anthropic", "opencode"].includes(providerID))
     return true;
   if (providerID === "github-copilot" && modelID.toLowerCase().includes("claude"))
     return true;
@@ -47987,10 +48715,11 @@ function createSgResultFromStdout(stdout) {
 
 // src/tools/ast-grep/cli.ts
 async function runSg(options) {
+  const shouldSeparateWritePass = !!(options.rewrite && options.updateAll);
   const args = ["run", "-p", options.pattern, "--lang", options.lang, "--json=compact"];
   if (options.rewrite) {
     args.push("-r", options.rewrite);
-    if (options.updateAll) {
+    if (options.updateAll && !shouldSeparateWritePass) {
       args.push("--update-all");
     }
   }
@@ -48083,7 +48812,26 @@ async function runSg(options) {
     }
     return { matches: [], totalMatches: 0, truncated: false };
   }
-  return createSgResultFromStdout(stdout);
+  const jsonResult = createSgResultFromStdout(stdout);
+  if (shouldSeparateWritePass && jsonResult.matches.length > 0) {
+    const writeArgs = args.filter((a) => a !== "--json=compact");
+    writeArgs.push("--update-all");
+    const writeProc = spawn10([cliPath, ...writeArgs], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    try {
+      const writeOutput = await collectProcessOutputWithTimeout(writeProc, timeout);
+      if (writeOutput.exitCode !== 0) {
+        const errorDetail = writeOutput.stderr.trim() || `ast-grep exited with code ${writeOutput.exitCode}`;
+        return { ...jsonResult, error: `Replace failed: ${errorDetail}` };
+      }
+    } catch (error45) {
+      const errorMessage = error45 instanceof Error ? error45.message : String(error45);
+      return { ...jsonResult, error: `Replace failed: ${errorMessage}` };
+    }
+  }
+  return jsonResult;
 }
 
 // src/tools/ast-grep/result-formatter.ts
@@ -51027,7 +51775,7 @@ session_id: ${sessionID}
 }
 
 // src/tools/call-omo-agent/tools.ts
-function createCallOmoAgent(ctx, backgroundManager) {
+function createCallOmoAgent(ctx, backgroundManager, disabledAgents = []) {
   const agentDescriptions = ALLOWED_AGENTS.map((name) => `- ${name}: Specialized agent for ${name} tasks`).join(`
 `);
   const description = CALL_OMO_AGENT_DESCRIPTION.replace("{agents}", agentDescriptions);
@@ -51048,6 +51796,9 @@ function createCallOmoAgent(ctx, backgroundManager) {
       }
       const normalizedAgent = args.subagent_type.toLowerCase();
       args = { ...args, subagent_type: normalizedAgent };
+      if (disabledAgents.some((disabled) => disabled.toLowerCase() === normalizedAgent)) {
+        return `Error: Agent "${normalizedAgent}" is disabled via disabled_agents configuration. Remove it from disabled_agents in your oh-my-opencode.json to use it.`;
+      }
       if (args.run_in_background) {
         if (args.session_id) {
           return `Error: session_id is not supported in background mode. Use run_in_background=false to continue an existing session.`;
@@ -52240,28 +52991,49 @@ async function createSyncSession(client2, input) {
 
 // src/tools/delegate-task/sync-prompt-sender.ts
 init_constants();
-async function sendSyncPrompt(client2, input) {
+var sendSyncPromptDeps = {
+  promptWithModelSuggestionRetry,
+  promptSyncWithModelSuggestionRetry
+};
+function isOracleAgent(agentToUse) {
+  return agentToUse.toLowerCase() === "oracle";
+}
+function isUnexpectedEofError(error45) {
+  const message = error45 instanceof Error ? error45.message : String(error45);
+  const lowered = message.toLowerCase();
+  return lowered.includes("unexpected eof") || lowered.includes("json parse error");
+}
+async function sendSyncPrompt(client2, input, deps = sendSyncPromptDeps) {
+  const allowTask = isPlanFamily(input.agentToUse);
+  const tools = {
+    task: allowTask,
+    call_omo_agent: true,
+    question: false,
+    ...getAgentToolRestrictions(input.agentToUse)
+  };
+  setSessionTools(input.sessionID, tools);
+  const promptArgs = {
+    path: { id: input.sessionID },
+    body: {
+      agent: input.agentToUse,
+      system: input.systemContent,
+      tools,
+      parts: [{ type: "text", text: input.args.prompt }],
+      ...input.categoryModel ? { model: { providerID: input.categoryModel.providerID, modelID: input.categoryModel.modelID } } : {},
+      ...input.categoryModel?.variant ? { variant: input.categoryModel.variant } : {}
+    }
+  };
   try {
-    const allowTask = isPlanFamily(input.agentToUse);
-    const tools = {
-      task: allowTask,
-      call_omo_agent: true,
-      question: false,
-      ...getAgentToolRestrictions(input.agentToUse)
-    };
-    setSessionTools(input.sessionID, tools);
-    await promptWithModelSuggestionRetry(client2, {
-      path: { id: input.sessionID },
-      body: {
-        agent: input.agentToUse,
-        system: input.systemContent,
-        tools,
-        parts: [{ type: "text", text: input.args.prompt }],
-        ...input.categoryModel ? { model: { providerID: input.categoryModel.providerID, modelID: input.categoryModel.modelID } } : {},
-        ...input.categoryModel?.variant ? { variant: input.categoryModel.variant } : {}
-      }
-    });
+    await deps.promptWithModelSuggestionRetry(client2, promptArgs);
   } catch (promptError) {
+    if (isOracleAgent(input.agentToUse) && isUnexpectedEofError(promptError)) {
+      try {
+        await deps.promptSyncWithModelSuggestionRetry(client2, promptArgs);
+        return null;
+      } catch (oracleRetryError) {
+        promptError = oracleRetryError;
+      }
+    }
     if (input.toastManager && input.taskId !== undefined) {
       input.toastManager.removeTask(input.taskId);
     }
@@ -52689,6 +53461,7 @@ Available categories: ${categoryNames.join(", ")}`
 }
 // src/tools/delegate-task/subagent-resolver.ts
 init_constants();
+init_logger();
 async function resolveSubagentExecution(args, executorCtx, parentAgent, categoryExamples) {
   const { client: client2, agentOverrides } = executorCtx;
   if (!args.subagent_type?.trim()) {
@@ -52764,7 +53537,19 @@ Create the work plan directly - that's your job as the planning agent.`
     if (!categoryModel && matchedAgent.model) {
       categoryModel = matchedAgent.model;
     }
-  } catch {}
+  } catch (error45) {
+    const errorMessage = error45 instanceof Error ? error45.message : String(error45);
+    log("[delegate-task] Failed to resolve subagent execution", {
+      requestedAgent: agentToUse,
+      parentAgent,
+      error: errorMessage
+    });
+    return {
+      agentToUse: "",
+      categoryModel: undefined,
+      error: `Failed to delegate to agent "${agentToUse}": ${errorMessage}`
+    };
+  }
   return { agentToUse, categoryModel };
 }
 // src/tools/delegate-task/tools.ts
@@ -53492,6 +54277,223 @@ async function handleUpdate(args, config3, ctx, context) {
     return JSON.stringify({ error: "internal_error" });
   }
 }
+// src/tools/hashline-edit/validation.ts
+function parseLineRef(ref) {
+  const match = ref.match(/^(\d+):([0-9a-f]{2})$/);
+  if (!match) {
+    throw new Error(`Invalid line reference format: "${ref}". Expected format: "LINE:HASH" (e.g., "42:a3")`);
+  }
+  return {
+    line: Number.parseInt(match[1], 10),
+    hash: match[2]
+  };
+}
+function validateLineRef(lines, ref) {
+  const { line, hash: hash2 } = parseLineRef(ref);
+  if (line < 1 || line > lines.length) {
+    throw new Error(`Line number ${line} out of bounds. File has ${lines.length} lines.`);
+  }
+  const content = lines[line - 1];
+  const currentHash = computeLineHash(line, content);
+  if (currentHash !== hash2) {
+    throw new Error(`Hash mismatch at line ${line}. Expected hash: ${hash2}, current hash: ${currentHash}. ` + `Line content may have changed. Current content: "${content}"`);
+  }
+}
+// src/tools/hashline-edit/edit-operations.ts
+function unescapeNewlines(text) {
+  return text.replace(/\\n/g, `
+`);
+}
+function getEditLineNumber(edit) {
+  switch (edit.type) {
+    case "set_line":
+      return parseLineRef(edit.line).line;
+    case "replace_lines":
+      return parseLineRef(edit.end_line).line;
+    case "insert_after":
+      return parseLineRef(edit.line).line;
+    case "replace":
+      return Number.NEGATIVE_INFINITY;
+    default:
+      return Number.POSITIVE_INFINITY;
+  }
+}
+function applyHashlineEdits(content, edits) {
+  if (edits.length === 0) {
+    return content;
+  }
+  const sortedEdits = [...edits].sort((a, b) => getEditLineNumber(b) - getEditLineNumber(a));
+  let result = content;
+  let lines = result.split(`
+`);
+  for (const edit of sortedEdits) {
+    switch (edit.type) {
+      case "set_line": {
+        validateLineRef(lines, edit.line);
+        const { line } = parseLineRef(edit.line);
+        lines[line - 1] = unescapeNewlines(edit.text);
+        break;
+      }
+      case "replace_lines": {
+        validateLineRef(lines, edit.start_line);
+        validateLineRef(lines, edit.end_line);
+        const { line: startLine } = parseLineRef(edit.start_line);
+        const { line: endLine } = parseLineRef(edit.end_line);
+        if (startLine > endLine) {
+          throw new Error(`Invalid range: start line ${startLine} cannot be greater than end line ${endLine}`);
+        }
+        const newLines = unescapeNewlines(edit.text).split(`
+`);
+        lines.splice(startLine - 1, endLine - startLine + 1, ...newLines);
+        break;
+      }
+      case "insert_after": {
+        validateLineRef(lines, edit.line);
+        const { line } = parseLineRef(edit.line);
+        const newLines = unescapeNewlines(edit.text).split(`
+`);
+        lines.splice(line, 0, ...newLines);
+        break;
+      }
+      case "replace": {
+        result = lines.join(`
+`);
+        if (!result.includes(edit.old_text)) {
+          throw new Error(`Text not found: "${edit.old_text}"`);
+        }
+        result = result.replaceAll(edit.old_text, unescapeNewlines(edit.new_text));
+        lines = result.split(`
+`);
+        break;
+      }
+    }
+  }
+  return lines.join(`
+`);
+}
+// src/tools/hashline-edit/tools.ts
+function generateDiff(oldContent, newContent, filePath) {
+  const oldLines = oldContent.split(`
+`);
+  const newLines = newContent.split(`
+`);
+  let diff = `--- ${filePath}
++++ ${filePath}
+`;
+  const maxLines = Math.max(oldLines.length, newLines.length);
+  for (let i2 = 0;i2 < maxLines; i2++) {
+    const oldLine = oldLines[i2] ?? "";
+    const newLine = newLines[i2] ?? "";
+    const lineNum = i2 + 1;
+    const hash2 = computeLineHash(lineNum, newLine);
+    if (i2 >= oldLines.length) {
+      diff += `+ ${lineNum}:${hash2}|${newLine}
+`;
+    } else if (i2 >= newLines.length) {
+      diff += `- ${lineNum}:  |${oldLine}
+`;
+    } else if (oldLine !== newLine) {
+      diff += `- ${lineNum}:  |${oldLine}
+`;
+      diff += `+ ${lineNum}:${hash2}|${newLine}
+`;
+    }
+  }
+  return diff;
+}
+function createHashlineEditTool() {
+  return tool({
+    description: `Edit files using LINE:HASH format for precise, safe modifications.
+
+LINE:HASH FORMAT:
+Each line reference must be in "LINE:HASH" format where:
+- LINE: 1-based line number
+- HASH: First 2 characters of xxHash32 hash of line content (computed with computeLineHash)
+- Example: "5:a3|const x = 1" means line 5 with hash "a3"
+
+GETTING HASHES:
+Use the read tool - it returns lines in "LINE:HASH|content" format.
+
+FOUR OPERATION TYPES:
+
+1. set_line: Replace a single line
+   { "type": "set_line", "line": "5:a3", "text": "const y = 2" }
+
+2. replace_lines: Replace a range of lines
+   { "type": "replace_lines", "start_line": "5:a3", "end_line": "7:b2", "text": "new
+content" }
+
+3. insert_after: Insert lines after a specific line
+   { "type": "insert_after", "line": "5:a3", "text": "console.log('hi')" }
+
+4. replace: Simple text replacement (no hash validation)
+   { "type": "replace", "old_text": "foo", "new_text": "bar" }
+
+HASH MISMATCH HANDLING:
+If the hash doesn't match the current content, the edit fails with a hash mismatch error. This prevents editing stale content.
+
+BOTTOM-UP APPLICATION:
+Edits are applied from bottom to top (highest line numbers first) to preserve line number references.
+
+ESCAPING:
+Use \\n in text to represent literal newlines.`,
+    args: {
+      path: tool.schema.string().describe("Absolute path to the file to edit"),
+      edits: tool.schema.array(tool.schema.union([
+        tool.schema.object({
+          type: tool.schema.literal("set_line"),
+          line: tool.schema.string().describe("Line reference in LINE:HASH format"),
+          text: tool.schema.string().describe("New content for the line")
+        }),
+        tool.schema.object({
+          type: tool.schema.literal("replace_lines"),
+          start_line: tool.schema.string().describe("Start line in LINE:HASH format"),
+          end_line: tool.schema.string().describe("End line in LINE:HASH format"),
+          text: tool.schema.string().describe("New content to replace the range")
+        }),
+        tool.schema.object({
+          type: tool.schema.literal("insert_after"),
+          line: tool.schema.string().describe("Line reference in LINE:HASH format"),
+          text: tool.schema.string().describe("Content to insert after the line")
+        }),
+        tool.schema.object({
+          type: tool.schema.literal("replace"),
+          old_text: tool.schema.string().describe("Text to find"),
+          new_text: tool.schema.string().describe("Replacement text")
+        })
+      ])).describe("Array of edit operations to apply")
+    },
+    execute: async (args) => {
+      try {
+        const { path: filePath, edits } = args;
+        if (!filePath) {
+          return "Error: path parameter is required";
+        }
+        if (!edits || !Array.isArray(edits) || edits.length === 0) {
+          return "Error: edits parameter must be a non-empty array";
+        }
+        const file2 = Bun.file(filePath);
+        const exists = await file2.exists();
+        if (!exists) {
+          return `Error: File not found: ${filePath}`;
+        }
+        const oldContent = await file2.text();
+        const newContent = applyHashlineEdits(oldContent, edits);
+        await Bun.write(filePath, newContent);
+        const diff = generateDiff(oldContent, newContent, filePath);
+        return `Successfully applied ${edits.length} edit(s) to ${filePath}
+
+${diff}`;
+      } catch (error45) {
+        const message = error45 instanceof Error ? error45.message : String(error45);
+        if (message.includes("hash")) {
+          return `Error: Hash mismatch - ${message}`;
+        }
+        return `Error: ${message}`;
+      }
+    }
+  });
+}
 // src/tools/index.ts
 function createBackgroundTools(manager, client2) {
   const outputManager = manager;
@@ -53512,10 +54514,10 @@ var builtinTools = {
 
 // src/plugin/hooks/create-session-hooks.ts
 function createSessionHooks(args) {
-  const { ctx, pluginConfig, isHookEnabled, safeHookEnabled } = args;
+  const { ctx, pluginConfig, modelCacheState, isHookEnabled, safeHookEnabled } = args;
   const safeHook = (hookName, factory) => safeCreateHook(hookName, factory, { enabled: safeHookEnabled });
-  const contextWindowMonitor = isHookEnabled("context-window-monitor") ? safeHook("context-window-monitor", () => createContextWindowMonitorHook(ctx)) : null;
-  const preemptiveCompaction = isHookEnabled("preemptive-compaction") && pluginConfig.experimental?.preemptive_compaction ? safeHook("preemptive-compaction", () => createPreemptiveCompactionHook(ctx)) : null;
+  const contextWindowMonitor = isHookEnabled("context-window-monitor") ? safeHook("context-window-monitor", () => createContextWindowMonitorHook(ctx, modelCacheState)) : null;
+  const preemptiveCompaction = isHookEnabled("preemptive-compaction") && pluginConfig.experimental?.preemptive_compaction ? safeHook("preemptive-compaction", () => createPreemptiveCompactionHook(ctx, modelCacheState)) : null;
   const sessionRecovery = isHookEnabled("session-recovery") ? safeHook("session-recovery", () => createSessionRecoveryHook(ctx, { experimental: pluginConfig.experimental })) : null;
   let sessionNotification = null;
   if (isHookEnabled("session-notification")) {
@@ -53574,10 +54576,13 @@ function createSessionHooks(args) {
 
 // src/plugin/hooks/create-tool-guard-hooks.ts
 function createToolGuardHooks(args) {
-  const { ctx, pluginConfig, isHookEnabled, safeHookEnabled } = args;
+  const { ctx, pluginConfig, modelCacheState, isHookEnabled, safeHookEnabled } = args;
   const safeHook = (hookName, factory) => safeCreateHook(hookName, factory, { enabled: safeHookEnabled });
   const commentChecker = isHookEnabled("comment-checker") ? safeHook("comment-checker", () => createCommentCheckerHooks(pluginConfig.comment_checker)) : null;
-  const toolOutputTruncator = isHookEnabled("tool-output-truncator") ? safeHook("tool-output-truncator", () => createToolOutputTruncatorHook(ctx, { experimental: pluginConfig.experimental })) : null;
+  const toolOutputTruncator = isHookEnabled("tool-output-truncator") ? safeHook("tool-output-truncator", () => createToolOutputTruncatorHook(ctx, {
+    modelCacheState,
+    experimental: pluginConfig.experimental
+  })) : null;
   let directoryAgentsInjector = null;
   if (isHookEnabled("directory-agents-injector")) {
     const currentVersion = getOpenCodeVersion();
@@ -53588,14 +54593,15 @@ function createToolGuardHooks(args) {
         nativeVersion: OPENCODE_NATIVE_AGENTS_INJECTION_VERSION
       });
     } else {
-      directoryAgentsInjector = safeHook("directory-agents-injector", () => createDirectoryAgentsInjectorHook(ctx));
+      directoryAgentsInjector = safeHook("directory-agents-injector", () => createDirectoryAgentsInjectorHook(ctx, modelCacheState));
     }
   }
-  const directoryReadmeInjector = isHookEnabled("directory-readme-injector") ? safeHook("directory-readme-injector", () => createDirectoryReadmeInjectorHook(ctx)) : null;
+  const directoryReadmeInjector = isHookEnabled("directory-readme-injector") ? safeHook("directory-readme-injector", () => createDirectoryReadmeInjectorHook(ctx, modelCacheState)) : null;
   const emptyTaskResponseDetector = isHookEnabled("empty-task-response-detector") ? safeHook("empty-task-response-detector", () => createEmptyTaskResponseDetectorHook(ctx)) : null;
-  const rulesInjector = isHookEnabled("rules-injector") ? safeHook("rules-injector", () => createRulesInjectorHook(ctx)) : null;
+  const rulesInjector = isHookEnabled("rules-injector") ? safeHook("rules-injector", () => createRulesInjectorHook(ctx, modelCacheState)) : null;
   const tasksTodowriteDisabler = isHookEnabled("tasks-todowrite-disabler") ? safeHook("tasks-todowrite-disabler", () => createTasksTodowriteDisablerHook({ experimental: pluginConfig.experimental })) : null;
   const writeExistingFileGuard = isHookEnabled("write-existing-file-guard") ? safeHook("write-existing-file-guard", () => createWriteExistingFileGuardHook(ctx)) : null;
+  const hashlineReadEnhancer = isHookEnabled("hashline-read-enhancer") ? safeHook("hashline-read-enhancer", () => createHashlineReadEnhancerHook(ctx, { hashline_edit: { enabled: pluginConfig.experimental?.hashline_edit ?? false } })) : null;
   return {
     commentChecker,
     toolOutputTruncator,
@@ -53604,7 +54610,8 @@ function createToolGuardHooks(args) {
     emptyTaskResponseDetector,
     rulesInjector,
     tasksTodowriteDisabler,
-    writeExistingFileGuard
+    writeExistingFileGuard,
+    hashlineReadEnhancer
   };
 }
 
@@ -53770,16 +54777,18 @@ function createTransformHooks(args) {
 
 // src/plugin/hooks/create-core-hooks.ts
 function createCoreHooks(args) {
-  const { ctx, pluginConfig, isHookEnabled, safeHookEnabled } = args;
+  const { ctx, pluginConfig, modelCacheState, isHookEnabled, safeHookEnabled } = args;
   const session = createSessionHooks({
     ctx,
     pluginConfig,
+    modelCacheState,
     isHookEnabled,
     safeHookEnabled
   });
   const tool3 = createToolGuardHooks({
     ctx,
     pluginConfig,
+    modelCacheState,
     isHookEnabled,
     safeHookEnabled
   });
@@ -53897,6 +54906,7 @@ function createHooks(args) {
   const {
     ctx,
     pluginConfig,
+    modelCacheState,
     backgroundManager,
     isHookEnabled,
     safeHookEnabled,
@@ -53906,6 +54916,7 @@ function createHooks(args) {
   const core3 = createCoreHooks({
     ctx,
     pluginConfig,
+    modelCacheState,
     isHookEnabled,
     safeHookEnabled
   });
@@ -54095,7 +55106,7 @@ var POLLING_INTERVAL_MS = 3000;
 var TASK_CLEANUP_DELAY_MS = 10 * 60 * 1000;
 
 // src/features/background-agent/manager.ts
-import { existsSync as existsSync61, readdirSync as readdirSync18 } from "fs";
+import { existsSync as existsSync61, readFileSync as readFileSync40, readdirSync as readdirSync18 } from "fs";
 import { join as join72 } from "path";
 
 class BackgroundManager {
@@ -54108,6 +55119,7 @@ class BackgroundManager {
   client;
   directory;
   pollingInterval;
+  pollingInFlight = false;
   concurrencyManager;
   shutdownTriggered = false;
   config;
@@ -54119,6 +55131,7 @@ class BackgroundManager {
   completionTimers = new Map;
   idleDeferralTimers = new Map;
   notificationQueueByParent = new Map;
+  enableParentSessionNotifications;
   taskHistory = new TaskHistory;
   constructor(ctx, config3, options) {
     this.tasks = new Map;
@@ -54131,6 +55144,7 @@ class BackgroundManager {
     this.tmuxEnabled = options?.tmuxConfig?.enabled ?? false;
     this.onSubagentSessionCreated = options?.onSubagentSessionCreated;
     this.onShutdown = options?.onShutdown;
+    this.enableParentSessionNotifications = options?.enableParentSessionNotifications ?? true;
     this.registerProcessCleanup();
   }
   async launch(input) {
@@ -54965,13 +55979,12 @@ class BackgroundManager {
     } else {
       allComplete = true;
     }
+    const completedTasks = allComplete ? Array.from(this.tasks.values()).filter((t) => t.parentSessionID === task.parentSessionID && t.status !== "running" && t.status !== "pending") : [];
     const statusText = task.status === "completed" ? "COMPLETED" : task.status === "interrupt" ? "INTERRUPTED" : "CANCELLED";
     const errorInfo = task.error ? `
 **Error:** ${task.error}` : "";
     let notification;
-    let completedTasks = [];
     if (allComplete) {
-      completedTasks = Array.from(this.tasks.values()).filter((t) => t.parentSessionID === task.parentSessionID && t.status !== "running" && t.status !== "pending");
       const completedTasksText = completedTasks.map((t) => `- \`${t.id}\`: ${t.description}`).join(`
 `);
       notification = `<system-reminder>
@@ -54997,59 +56010,69 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     }
     let agent = task.parentAgent;
     let model;
-    try {
-      const messagesResp = await this.client.session.messages({ path: { id: task.parentSessionID } });
-      const messages = normalizeSDKResponse(messagesResp, []);
-      for (let i2 = messages.length - 1;i2 >= 0; i2--) {
-        const info = messages[i2].info;
-        if (info?.agent || info?.model || info?.modelID && info?.providerID) {
-          agent = info.agent ?? task.parentAgent;
-          model = info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined);
-          break;
+    if (this.enableParentSessionNotifications) {
+      try {
+        const messagesResp = await this.client.session.messages({ path: { id: task.parentSessionID } });
+        const messages = normalizeSDKResponse(messagesResp, []);
+        for (let i2 = messages.length - 1;i2 >= 0; i2--) {
+          const info = messages[i2].info;
+          if (isCompactionAgent(info?.agent)) {
+            continue;
+          }
+          if (info?.agent || info?.model || info?.modelID && info?.providerID) {
+            agent = info.agent ?? task.parentAgent;
+            model = info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined);
+            break;
+          }
         }
-      }
-    } catch (error45) {
-      if (this.isAbortedSessionError(error45)) {
-        log("[background-agent] Parent session aborted while loading messages; using messageDir fallback:", {
-          taskId: task.id,
-          parentSessionID: task.parentSessionID
-        });
-      }
-      const messageDir = getMessageDir2(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,
-      resolvedAgent: agent,
-      resolvedModel: model
-    });
-    try {
-      await this.client.session.promptAsync({
-        path: { id: task.parentSessionID },
-        body: {
-          noReply: !allComplete,
-          ...agent !== undefined ? { agent } : {},
-          ...model !== undefined ? { model } : {},
-          ...task.parentTools ? { tools: task.parentTools } : {},
-          parts: [{ type: "text", text: notification }]
+      } catch (error45) {
+        if (this.isAbortedSessionError(error45)) {
+          log("[background-agent] Parent session aborted while loading messages; using messageDir fallback:", {
+            taskId: task.id,
+            parentSessionID: task.parentSessionID
+          });
         }
-      });
-      log("[background-agent] Sent notification to parent session:", {
+        const messageDir = getMessageDir2(task.parentSessionID);
+        const currentMessage = messageDir ? findNearestMessageExcludingCompaction(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,
-        allComplete,
-        noReply: !allComplete
+        resolvedAgent: agent,
+        resolvedModel: model
       });
-    } catch (error45) {
-      if (this.isAbortedSessionError(error45)) {
-        log("[background-agent] Parent session aborted while sending notification; continuing cleanup:", {
+      try {
+        await this.client.session.promptAsync({
+          path: { id: task.parentSessionID },
+          body: {
+            noReply: !allComplete,
+            ...agent !== undefined ? { agent } : {},
+            ...model !== undefined ? { model } : {},
+            ...task.parentTools ? { tools: task.parentTools } : {},
+            parts: [{ type: "text", text: notification }]
+          }
+        });
+        log("[background-agent] Sent notification to parent session:", {
           taskId: task.id,
-          parentSessionID: task.parentSessionID
+          allComplete,
+          noReply: !allComplete
         });
-      } else {
-        log("[background-agent] Failed to send notification:", error45);
+      } catch (error45) {
+        if (this.isAbortedSessionError(error45)) {
+          log("[background-agent] Parent session aborted while sending notification; continuing cleanup:", {
+            taskId: task.id,
+            parentSessionID: task.parentSessionID
+          });
+        } else {
+          log("[background-agent] Failed to send notification:", error45);
+        }
       }
+    } else {
+      log("[background-agent] Parent session notifications disabled, skipping prompt injection:", {
+        taskId: task.id,
+        parentSessionID: task.parentSessionID
+      });
     }
     if (allComplete) {
       for (const completedTask of completedTasks) {
@@ -55253,46 +56276,53 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     }
   }
   async pollRunningTasks() {
-    this.pruneStaleTasksAndNotifications();
-    const statusResult = await this.client.session.status();
-    const allStatuses = normalizeSDKResponse(statusResult, {});
-    await this.checkAndInterruptStaleTasks(allStatuses);
-    for (const task of this.tasks.values()) {
-      if (task.status !== "running")
-        continue;
-      const sessionID = task.sessionID;
-      if (!sessionID)
-        continue;
-      try {
-        const sessionStatus = allStatuses[sessionID];
-        if (sessionStatus?.type === "idle") {
-          const hasValidOutput = await this.validateSessionHasOutput(sessionID);
-          if (!hasValidOutput) {
-            log("[background-agent] Polling idle but no valid output yet, waiting:", task.id);
-            continue;
-          }
-          if (task.status !== "running")
-            continue;
-          const hasIncompleteTodos2 = await this.checkSessionTodos(sessionID);
-          if (hasIncompleteTodos2) {
-            log("[background-agent] Task has incomplete todos via polling, waiting:", task.id);
+    if (this.pollingInFlight)
+      return;
+    this.pollingInFlight = true;
+    try {
+      this.pruneStaleTasksAndNotifications();
+      const statusResult = await this.client.session.status();
+      const allStatuses = normalizeSDKResponse(statusResult, {});
+      await this.checkAndInterruptStaleTasks(allStatuses);
+      for (const task of this.tasks.values()) {
+        if (task.status !== "running")
+          continue;
+        const sessionID = task.sessionID;
+        if (!sessionID)
+          continue;
+        try {
+          const sessionStatus = allStatuses[sessionID];
+          if (sessionStatus?.type === "idle") {
+            const hasValidOutput = await this.validateSessionHasOutput(sessionID);
+            if (!hasValidOutput) {
+              log("[background-agent] Polling idle but no valid output yet, waiting:", task.id);
+              continue;
+            }
+            if (task.status !== "running")
+              continue;
+            const hasIncompleteTodos2 = await this.checkSessionTodos(sessionID);
+            if (hasIncompleteTodos2) {
+              log("[background-agent] Task has incomplete todos via polling, waiting:", task.id);
+              continue;
+            }
+            await this.tryCompleteTask(task, "polling (idle status)");
             continue;
           }
-          await this.tryCompleteTask(task, "polling (idle status)");
-          continue;
+          log("[background-agent] Session still running, relying on event-based progress:", {
+            taskId: task.id,
+            sessionID,
+            sessionStatus: sessionStatus?.type ?? "not_in_status",
+            toolCalls: task.progress?.toolCalls ?? 0
+          });
+        } catch (error45) {
+          log("[background-agent] Poll error for task:", { taskId: task.id, error: error45 });
         }
-        log("[background-agent] Session still running, relying on event-based progress:", {
-          taskId: task.id,
-          sessionID,
-          sessionStatus: sessionStatus?.type ?? "not_in_status",
-          toolCalls: task.progress?.toolCalls ?? 0
-        });
-      } catch (error45) {
-        log("[background-agent] Poll error for task:", { taskId: task.id, error: error45 });
       }
-    }
-    if (!this.hasRunningTasks()) {
-      this.stopPolling();
+      if (!this.hasRunningTasks()) {
+        this.stopPolling();
+      }
+    } finally {
+      this.pollingInFlight = false;
     }
   }
   shutdown() {
@@ -55378,6 +56408,47 @@ function getMessageDir2(sessionID) {
   }
   return null;
 }
+function isCompactionAgent(agent) {
+  return agent?.trim().toLowerCase() === "compaction";
+}
+function hasFullAgentAndModel(message) {
+  return !!message.agent && !isCompactionAgent(message.agent) && !!message.model?.providerID && !!message.model?.modelID;
+}
+function hasPartialAgentOrModel(message) {
+  const hasAgent = !!message.agent && !isCompactionAgent(message.agent);
+  const hasModel = !!message.model?.providerID && !!message.model?.modelID;
+  return hasAgent || hasModel;
+}
+function findNearestMessageExcludingCompaction(messageDir) {
+  try {
+    const files = readdirSync18(messageDir).filter((name) => name.endsWith(".json")).sort().reverse();
+    for (const file2 of files) {
+      try {
+        const content = readFileSync40(join72(messageDir, file2), "utf-8");
+        const parsed = JSON.parse(content);
+        if (hasFullAgentAndModel(parsed)) {
+          return parsed;
+        }
+      } catch {
+        continue;
+      }
+    }
+    for (const file2 of files) {
+      try {
+        const content = readFileSync40(join72(messageDir, file2), "utf-8");
+        const parsed = JSON.parse(content);
+        if (hasPartialAgentOrModel(parsed)) {
+          return parsed;
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
 // src/features/background-agent/state.ts
 class TaskStateManager {
   tasks = new Map;
@@ -59363,7 +60434,7 @@ class StreamableHTTPClientTransport {
 }
 
 // src/features/mcp-oauth/storage.ts
-import { chmodSync as chmodSync2, existsSync as existsSync62, mkdirSync as mkdirSync14, readFileSync as readFileSync40, unlinkSync as unlinkSync10, writeFileSync as writeFileSync19 } from "fs";
+import { chmodSync as chmodSync2, existsSync as existsSync62, mkdirSync as mkdirSync14, readFileSync as readFileSync41, unlinkSync as unlinkSync10, writeFileSync as writeFileSync19 } from "fs";
 import { dirname as dirname20, join as join73 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
@@ -59408,7 +60479,7 @@ function readStore() {
     return null;
   }
   try {
-    const content = readFileSync40(filePath, "utf-8");
+    const content = readFileSync41(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -60538,14 +61609,14 @@ var MIN_SPLIT_WIDTH = 2 * MIN_PANE_WIDTH + DIVIDER_SIZE;
 var MIN_SPLIT_HEIGHT = 2 * MIN_PANE_HEIGHT + DIVIDER_SIZE;
 
 // src/features/tmux-subagent/grid-planning.ts
-function calculateCapacity(windowWidth, windowHeight, minPaneWidth = MIN_PANE_WIDTH) {
-  const availableWidth = Math.floor(windowWidth * (1 - MAIN_PANE_RATIO));
+function calculateCapacity(windowWidth, windowHeight, minPaneWidth = MIN_PANE_WIDTH, mainPaneWidth) {
+  const availableWidth = typeof mainPaneWidth === "number" ? Math.max(0, windowWidth - mainPaneWidth - DIVIDER_SIZE) : Math.floor(windowWidth * (1 - MAIN_PANE_RATIO));
   const cols = Math.min(MAX_GRID_SIZE, Math.max(0, Math.floor((availableWidth + DIVIDER_SIZE) / (minPaneWidth + DIVIDER_SIZE))));
   const rows = Math.min(MAX_GRID_SIZE, Math.max(0, Math.floor((windowHeight + DIVIDER_SIZE) / (MIN_PANE_HEIGHT + DIVIDER_SIZE))));
   return { cols, rows, total: cols * rows };
 }
-function computeGridPlan(windowWidth, windowHeight, paneCount) {
-  const capacity = calculateCapacity(windowWidth, windowHeight);
+function computeGridPlan(windowWidth, windowHeight, paneCount, mainPaneWidth, minPaneWidth) {
+  const capacity = calculateCapacity(windowWidth, windowHeight, minPaneWidth ?? MIN_PANE_WIDTH, mainPaneWidth);
   const { cols: maxCols, rows: maxRows } = capacity;
   if (maxCols === 0 || maxRows === 0 || paneCount === 0) {
     return { cols: 1, rows: 1, slotWidth: 0, slotHeight: 0 };
@@ -60565,7 +61636,7 @@ function computeGridPlan(windowWidth, windowHeight, paneCount) {
       }
     }
   }
-  const availableWidth = Math.floor(windowWidth * (1 - MAIN_PANE_RATIO));
+  const availableWidth = typeof mainPaneWidth === "number" ? Math.max(0, windowWidth - mainPaneWidth - DIVIDER_SIZE) : Math.floor(windowWidth * (1 - MAIN_PANE_RATIO));
   const slotWidth = Math.floor(availableWidth / bestCols);
   const slotHeight = Math.floor(windowHeight / bestRows);
   return { cols: bestCols, rows: bestRows, slotWidth, slotHeight };
@@ -60610,8 +61681,8 @@ function canSplitPane(pane, direction, minPaneWidth = MIN_PANE_WIDTH) {
   }
   return pane.height >= MIN_SPLIT_HEIGHT;
 }
-function getBestSplitDirection(pane) {
-  const canH = pane.width >= MIN_SPLIT_WIDTH;
+function getBestSplitDirection(pane, minPaneWidth = MIN_PANE_WIDTH) {
+  const canH = pane.width >= minSplitWidthFor(minPaneWidth);
   const canV = pane.height >= MIN_SPLIT_HEIGHT;
   if (!canH && !canV)
     return null;
@@ -60640,38 +61711,38 @@ function findFirstEmptySlot(occupancy, plan) {
   }
   return { row: plan.rows - 1, col: plan.cols - 1 };
 }
-function findSplittableTarget(state3, _preferredDirection) {
+function findSplittableTarget(state3, minPaneWidth, _preferredDirection) {
   if (!state3.mainPane)
     return null;
   const existingCount = state3.agentPanes.length;
   if (existingCount === 0) {
     const virtualMainPane = { ...state3.mainPane, width: state3.windowWidth };
-    if (canSplitPane(virtualMainPane, "-h")) {
+    if (canSplitPane(virtualMainPane, "-h", minPaneWidth)) {
       return { targetPaneId: state3.mainPane.paneId, splitDirection: "-h" };
     }
     return null;
   }
-  const plan = computeGridPlan(state3.windowWidth, state3.windowHeight, existingCount + 1);
-  const mainPaneWidth = Math.floor(state3.windowWidth * MAIN_PANE_RATIO);
+  const plan = computeGridPlan(state3.windowWidth, state3.windowHeight, existingCount + 1, state3.mainPane.width, minPaneWidth);
+  const mainPaneWidth = state3.mainPane.width;
   const occupancy = buildOccupancy(state3.agentPanes, plan, mainPaneWidth);
   const targetSlot = findFirstEmptySlot(occupancy, plan);
   const leftPane = occupancy.get(`${targetSlot.row}:${targetSlot.col - 1}`);
-  if (leftPane && canSplitPane(leftPane, "-h")) {
+  if (leftPane && canSplitPane(leftPane, "-h", minPaneWidth)) {
     return { targetPaneId: leftPane.paneId, splitDirection: "-h" };
   }
   const abovePane = occupancy.get(`${targetSlot.row - 1}:${targetSlot.col}`);
-  if (abovePane && canSplitPane(abovePane, "-v")) {
+  if (abovePane && canSplitPane(abovePane, "-v", minPaneWidth)) {
     return { targetPaneId: abovePane.paneId, splitDirection: "-v" };
   }
-  const splittablePanes = state3.agentPanes.map((pane) => ({ pane, direction: getBestSplitDirection(pane) })).filter((item) => item.direction !== null).sort((a, b) => b.pane.width * b.pane.height - a.pane.width * a.pane.height);
+  const splittablePanes = state3.agentPanes.map((pane) => ({ pane, direction: getBestSplitDirection(pane, minPaneWidth) })).filter((item) => item.direction !== null).sort((a, b) => b.pane.width * b.pane.height - a.pane.width * a.pane.height);
   const best = splittablePanes[0];
   if (best) {
     return { targetPaneId: best.pane.paneId, splitDirection: best.direction };
   }
   return null;
 }
-function findSpawnTarget(state3) {
-  return findSplittableTarget(state3);
+function findSpawnTarget(state3, minPaneWidth = MIN_PANE_WIDTH) {
+  return findSplittableTarget(state3, minPaneWidth);
 }
 // src/features/tmux-subagent/oldest-agent-pane.ts
 function findOldestAgentPane(agentPanes, sessionMappings) {
@@ -60699,7 +61770,7 @@ function decideSpawnActions(state3, sessionId, description, config3, sessionMapp
     return { canSpawn: false, actions: [], reason: "no main pane found" };
   }
   const minPaneWidth = config3.agentPaneWidth;
-  const agentAreaWidth = Math.floor(state3.windowWidth * (1 - MAIN_PANE_RATIO));
+  const agentAreaWidth = Math.max(0, state3.windowWidth - state3.mainPane.width - DIVIDER_SIZE);
   const currentCount = state3.agentPanes.length;
   if (agentAreaWidth < minPaneWidth) {
     return {
@@ -60729,7 +61800,7 @@ function decideSpawnActions(state3, sessionId, description, config3, sessionMapp
     return { canSpawn: false, actions: [], reason: "mainPane too small to split" };
   }
   if (isSplittableAtCount(agentAreaWidth, currentCount, minPaneWidth)) {
-    const spawnTarget = findSpawnTarget(state3);
+    const spawnTarget = findSpawnTarget(state3, minPaneWidth);
     if (spawnTarget) {
       return {
         canSpawn: true,
@@ -60751,19 +61822,14 @@ function decideSpawnActions(state3, sessionId, description, config3, sessionMapp
       canSpawn: true,
       actions: [
         {
-          type: "close",
+          type: "replace",
           paneId: oldestPane.paneId,
-          sessionId: oldestMapping?.sessionId || ""
-        },
-        {
-          type: "spawn",
-          sessionId,
-          description,
-          targetPaneId: state3.mainPane.paneId,
-          splitDirection: "-h"
+          oldSessionId: oldestMapping?.sessionId || "",
+          newSessionId: sessionId,
+          description
         }
       ],
-      reason: "closed 1 pane to make room for split"
+      reason: "replaced oldest pane to avoid split churn"
     };
   }
   if (oldestPane) {
@@ -60792,36 +61858,48 @@ function decideCloseAction(state3, sessionId, sessionMappings) {
     return null;
   return { type: "close", paneId: mapping.paneId, sessionId };
 }
-// src/features/tmux-subagent/action-executor.ts
-async function enforceMainPane(windowState) {
+// src/features/tmux-subagent/action-executor-core.ts
+async function enforceMainPane(windowState, config3, deps) {
   if (!windowState.mainPane)
     return;
-  await enforceMainPaneWidth(windowState.mainPane.paneId, windowState.windowWidth);
+  await deps.enforceMainPaneWidth(windowState.mainPane.paneId, windowState.windowWidth, config3.main_pane_size);
 }
-async function executeAction(action, ctx) {
+async function executeActionWithDeps(action, ctx, deps) {
   if (action.type === "close") {
-    const success2 = await closeTmuxPane(action.paneId);
+    const success2 = await deps.closeTmuxPane(action.paneId);
     if (success2) {
-      await enforceMainPane(ctx.windowState);
+      await enforceMainPane(ctx.windowState, ctx.config, deps);
     }
     return { success: success2 };
   }
   if (action.type === "replace") {
-    const result2 = await replaceTmuxPane(action.paneId, action.newSessionId, action.description, ctx.config, ctx.serverUrl);
+    const result2 = await deps.replaceTmuxPane(action.paneId, action.newSessionId, action.description, ctx.config, ctx.serverUrl);
     return {
       success: result2.success,
       paneId: result2.paneId
     };
   }
-  const result = await spawnTmuxPane(action.sessionId, action.description, ctx.config, ctx.serverUrl, action.targetPaneId, action.splitDirection);
+  const result = await deps.spawnTmuxPane(action.sessionId, action.description, ctx.config, ctx.serverUrl, action.targetPaneId, action.splitDirection);
   if (result.success) {
-    await enforceMainPane(ctx.windowState);
+    await enforceMainPane(ctx.windowState, ctx.config, deps);
   }
   return {
     success: result.success,
     paneId: result.paneId
   };
 }
+
+// src/features/tmux-subagent/action-executor.ts
+var DEFAULT_DEPS = {
+  spawnTmuxPane,
+  closeTmuxPane,
+  replaceTmuxPane,
+  applyLayout,
+  enforceMainPaneWidth
+};
+async function executeAction(action, ctx) {
+  return executeActionWithDeps(action, ctx, DEFAULT_DEPS);
+}
 async function executeActions(actions, ctx) {
   const results = [];
   let spawnedPaneId;
@@ -60850,6 +61928,7 @@ class TmuxPollingManager {
   sessions;
   closeSessionById;
   pollInterval;
+  pollingInFlight = false;
   constructor(client2, sessions, closeSessionById) {
     this.client = client2;
     this.sessions = sessions;
@@ -60869,11 +61948,14 @@ class TmuxPollingManager {
     }
   }
   async pollSessions() {
-    if (this.sessions.size === 0) {
-      this.stopPolling();
+    if (this.pollingInFlight)
       return;
-    }
+    this.pollingInFlight = true;
     try {
+      if (this.sessions.size === 0) {
+        this.stopPolling();
+        return;
+      }
       const statusResult = await this.client.session.status({ path: undefined });
       const allStatuses = normalizeSDKResponse(statusResult, {});
       log("[tmux-session-manager] pollSessions", {
@@ -60950,6 +62032,8 @@ class TmuxPollingManager {
       }
     } catch (err) {
       log("[tmux-session-manager] poll error", { error: String(err) });
+    } finally {
+      this.pollingInFlight = false;
     }
   }
 }
@@ -61101,10 +62185,12 @@ class TmuxSessionManager {
       if (result.success && result.spawnedPaneId) {
         const sessionReady = await this.waitForSessionReady(sessionId);
         if (!sessionReady) {
-          log("[tmux-session-manager] session not ready after timeout, tracking anyway", {
+          log("[tmux-session-manager] session not ready after timeout, closing spawned pane", {
             sessionId,
             paneId: result.spawnedPaneId
           });
+          await executeAction({ type: "close", paneId: result.spawnedPaneId, sessionId }, { config: this.tmuxConfig, serverUrl: this.serverUrl, windowState: state3 });
+          return;
         }
         const now = Date.now();
         this.sessions.set(sessionId, {
@@ -61248,17 +62334,15 @@ function buildToolSelectionTable(agents, tools = [], _skills = []) {
     "### Tool & Agent Selection:",
     ""
   ];
-  rows.push("| Resource | Cost | When to Use |");
-  rows.push("|----------|------|-------------|");
   if (tools.length > 0) {
     const toolsDisplay = formatToolsForPrompt(tools);
-    rows.push(`| ${toolsDisplay} | FREE | Not Complex, Scope Clear, No Implicit Assumptions |`);
+    rows.push(`- ${toolsDisplay} \u2014 **FREE** \u2014 Not Complex, Scope Clear, No Implicit Assumptions`);
   }
   const costOrder = { FREE: 0, CHEAP: 1, EXPENSIVE: 2 };
   const sortedAgents = [...agents].filter((a) => a.metadata.category !== "utility").sort((a, b) => costOrder[a.metadata.cost] - costOrder[b.metadata.cost]);
   for (const agent of sortedAgents) {
     const shortDesc = agent.description.split(".")[0] || agent.description;
-    rows.push(`| \`${agent.name}\` agent | ${agent.metadata.cost} | ${shortDesc} |`);
+    rows.push(`- \`${agent.name}\` agent \u2014 **${agent.metadata.cost}** \u2014 ${shortDesc}`);
   }
   rows.push("");
   rows.push("**Default flow**: explore/librarian (background) + tools \u2192 oracle (if required)");
@@ -61275,11 +62359,12 @@ function buildExploreSection(agents) {
 
 Use it as a **peer tool**, not a fallback. Fire liberally.
 
-| Use Direct Tools | Use Explore Agent |
-|------------------|-------------------|
-${avoidWhen.map((w) => `| ${w} |  |`).join(`
+**Use Direct Tools when:**
+${avoidWhen.map((w) => `- ${w}`).join(`
 `)}
-${useWhen.map((w) => `|  | ${w} |`).join(`
+
+**Use Explore Agent when:**
+${useWhen.map((w) => `- ${w}`).join(`
 `)}`;
 }
 function buildLibrarianSection(agents) {
@@ -61291,14 +62376,8 @@ function buildLibrarianSection(agents) {
 
 Search **external references** (docs, OSS, web). Fire proactively when unfamiliar libraries are involved.
 
-| Contextual Grep (Internal) | Reference Grep (External) |
-|----------------------------|---------------------------|
-| Search OUR codebase | Search EXTERNAL resources |
-| Find patterns in THIS repo | Find examples in OTHER repos |
-| How does our code work? | How does this library work? |
-| Project-specific logic | Official API documentation |
-| | Library best practices & quirks |
-| | OSS implementation examples |
+**Contextual Grep (Internal)** \u2014 search OUR codebase, find patterns in THIS repo, project-specific logic.
+**Reference Grep (External)** \u2014 search EXTERNAL resources, official API docs, library best practices, OSS implementation examples.
 
 **Trigger phrases** (fire librarian immediately):
 ${useWhen.map((w) => `- "${w}"`).join(`
@@ -61307,13 +62386,11 @@ ${useWhen.map((w) => `- "${w}"`).join(`
 function buildDelegationTable(agents) {
   const rows = [
     "### Delegation Table:",
-    "",
-    "| Domain | Delegate To | Trigger |",
-    "|--------|-------------|---------|"
+    ""
   ];
   for (const agent of agents) {
     for (const trigger of agent.metadata.triggers) {
-      rows.push(`| ${trigger.domain} | \`${agent.name}\` | ${trigger.trigger} |`);
+      rows.push(`- **${trigger.domain}** \u2192 \`${agent.name}\` \u2014 ${trigger.trigger}`);
     }
   }
   return rows.join(`
@@ -61327,8 +62404,6 @@ function formatCustomSkillsBlock(customRows, customSkills, headerLevel = "####")
 **The user has installed these custom skills. They MUST be evaluated for EVERY delegation.**
 Subagents are STATELESS \u2014 they lose all custom knowledge unless you pass these skills via \`load_skills\`.
 
-| Skill | Expertise Domain | Source |
-|-------|------------------|--------|
 ${customRows.join(`
 `)}
 
@@ -61340,26 +62415,24 @@ function buildCategorySkillsDelegationGuide(categories, skills) {
     return "";
   const categoryRows = categories.map((c) => {
     const desc = c.description || c.name;
-    return `| \`${c.name}\` | ${desc} |`;
+    return `- \`${c.name}\` \u2014 ${desc}`;
   });
   const builtinSkills = skills.filter((s) => s.location === "plugin");
   const customSkills = skills.filter((s) => s.location !== "plugin");
   const builtinRows = builtinSkills.map((s) => {
     const desc = truncateDescription(s.description);
-    return `| \`${s.name}\` | ${desc} |`;
+    return `- \`${s.name}\` \u2014 ${desc}`;
   });
   const customRows = customSkills.map((s) => {
     const desc = truncateDescription(s.description);
     const source = s.location === "project" ? "project" : "user";
-    return `| \`${s.name}\` | ${desc} | ${source} |`;
+    return `- \`${s.name}\` (${source}) \u2014 ${desc}`;
   });
   const customSkillBlock = formatCustomSkillsBlock(customRows, customSkills);
   let skillsSection;
   if (customSkills.length > 0 && builtinSkills.length > 0) {
     skillsSection = `#### Built-in Skills
 
-| Skill | Expertise Domain |
-|-------|------------------|
 ${builtinRows.join(`
 `)}
 
@@ -61371,8 +62444,6 @@ ${customSkillBlock}`;
 
 Skills inject specialized instructions into the subagent. Read the description to understand when each skill applies.
 
-| Skill | Expertise Domain |
-|-------|------------------|
 ${builtinRows.join(`
 `)}`;
   }
@@ -61384,8 +62455,6 @@ ${builtinRows.join(`
 
 Each category is configured with a model optimized for that domain. Read the description to understand when to use it.
 
-| Category | Domain / Best For |
-|----------|-------------------|
 ${categoryRows.join(`
 `)}
 
@@ -61456,11 +62525,9 @@ function buildOracleSection(agents) {
 
 Oracle is a read-only, expensive, high-quality reasoning model for debugging and architecture. Consultation only.
 
-### WHEN to Consult:
+### WHEN to Consult (Oracle FIRST, then implement):
 
-| Trigger | Action |
-|---------|--------|
-${useWhen.map((w) => `| ${w} | Oracle FIRST, then implement |`).join(`
+${useWhen.map((w) => `- ${w}`).join(`
 `)}
 
 ### WHEN NOT to Consult:
@@ -61472,34 +62539,43 @@ ${avoidWhen.map((w) => `- ${w}`).join(`
 Briefly announce "Consulting Oracle for [reason]" before invocation.
 
 **Exception**: This is the ONLY case where you announce before acting. For all other work, start immediately without status updates.
+
+### Oracle Background Task Policy:
+
+**You MUST collect Oracle results before your final answer. No exceptions.**
+
+- Oracle may take several minutes. This is normal and expected.
+- When Oracle is running and you finish your own exploration/analysis, your next action is \`background_output(task_id="...")\` on Oracle \u2014 NOT delivering a final answer.
+- Oracle catches blind spots you cannot see \u2014 its value is HIGHEST when you think you don't need it.
+- **NEVER** cancel Oracle. **NEVER** use \`background_cancel(all=true)\` when Oracle is running. Cancel disposable tasks (explore, librarian) individually by taskId instead.
 </Oracle_Usage>`;
 }
 function buildHardBlocksSection() {
   const blocks = [
-    "| Type error suppression (`as any`, `@ts-ignore`) | Never |",
-    "| Commit without explicit request | Never |",
-    "| Speculate about unread code | Never |",
-    "| Leave code in broken state after failures | Never |"
+    "- Type error suppression (`as any`, `@ts-ignore`) \u2014 **Never**",
+    "- Commit without explicit request \u2014 **Never**",
+    "- Speculate about unread code \u2014 **Never**",
+    "- Leave code in broken state after failures \u2014 **Never**",
+    "- `background_cancel(all=true)` when Oracle is running \u2014 **Never.** Cancel tasks individually by taskId.",
+    "- Delivering final answer before collecting Oracle result \u2014 **Never.** Always `background_output` Oracle first."
   ];
   return `## Hard Blocks (NEVER violate)
 
-| Constraint | No Exceptions |
-|------------|---------------|
 ${blocks.join(`
 `)}`;
 }
 function buildAntiPatternsSection() {
   const patterns = [
-    "| **Type Safety** | `as any`, `@ts-ignore`, `@ts-expect-error` |",
-    "| **Error Handling** | Empty catch blocks `catch(e) {}` |",
-    '| **Testing** | Deleting failing tests to "pass" |',
-    "| **Search** | Firing agents for single-line typos or obvious syntax errors |",
-    "| **Debugging** | Shotgun debugging, random changes |"
+    "- **Type Safety**: `as any`, `@ts-ignore`, `@ts-expect-error`",
+    "- **Error Handling**: Empty catch blocks `catch(e) {}`",
+    '- **Testing**: Deleting failing tests to "pass"',
+    "- **Search**: Firing agents for single-line typos or obvious syntax errors",
+    "- **Debugging**: Shotgun debugging, random changes",
+    "- **Background Tasks**: `background_cancel(all=true)` \u2014 always cancel individually by taskId",
+    "- **Oracle**: Skipping Oracle results when Oracle was launched \u2014 ALWAYS collect via `background_output`"
   ];
   return `## Anti-Patterns (BLOCKING violations)
 
-| Category | Forbidden |
-|----------|-----------|
 ${patterns.join(`
 `)}`;
 }
@@ -61515,12 +62591,10 @@ function buildTaskManagementSection(useTaskSystem) {
 
 ### When to Create Tasks (MANDATORY)
 
-| Trigger | Action |
-|---------|--------|
-| Multi-step task (2+ steps) | ALWAYS \`TaskCreate\` first |
-| Uncertain scope | ALWAYS (tasks clarify thinking) |
-| User request with multiple items | ALWAYS |
-| Complex single task | \`TaskCreate\` to break down |
+- Multi-step task (2+ steps) \u2192 ALWAYS \`TaskCreate\` first
+- Uncertain scope \u2192 ALWAYS (tasks clarify thinking)
+- User request with multiple items \u2192 ALWAYS
+- Complex single task \u2192 \`TaskCreate\` to break down
 
 ### Workflow (NON-NEGOTIABLE)
 
@@ -61539,12 +62613,10 @@ function buildTaskManagementSection(useTaskSystem) {
 
 ### Anti-Patterns (BLOCKING)
 
-| Violation | Why It's Bad |
-|-----------|--------------|
-| Skipping tasks on multi-step tasks | User has no visibility, steps get forgotten |
-| Batch-completing multiple tasks | Defeats real-time tracking purpose |
-| Proceeding without marking in_progress | No indication of what you're working on |
-| Finishing without completing tasks | Task appears incomplete to user |
+- Skipping tasks on multi-step tasks \u2014 user has no visibility, steps get forgotten
+- Batch-completing multiple tasks \u2014 defeats real-time tracking purpose
+- Proceeding without marking in_progress \u2014 no indication of what you're working on
+- Finishing without completing tasks \u2014 task appears incomplete to user
 
 **FAILURE TO USE TASKS ON NON-TRIVIAL TASKS = INCOMPLETE WORK.**
 
@@ -61572,12 +62644,10 @@ Should I proceed with [recommendation], or would you prefer differently?
 
 ### When to Create Todos (MANDATORY)
 
-| Trigger | Action |
-|---------|--------|
-| Multi-step task (2+ steps) | ALWAYS create todos first |
-| Uncertain scope | ALWAYS (todos clarify thinking) |
-| User request with multiple items | ALWAYS |
-| Complex single task | Create todos to break down |
+- Multi-step task (2+ steps) \u2192 ALWAYS create todos first
+- Uncertain scope \u2192 ALWAYS (todos clarify thinking)
+- User request with multiple items \u2192 ALWAYS
+- Complex single task \u2192 Create todos to break down
 
 ### Workflow (NON-NEGOTIABLE)
 
@@ -61596,12 +62666,10 @@ Should I proceed with [recommendation], or would you prefer differently?
 
 ### Anti-Patterns (BLOCKING)
 
-| Violation | Why It's Bad |
-|-----------|--------------|
-| Skipping todos on multi-step tasks | User has no visibility, steps get forgotten |
-| Batch-completing multiple todos | Defeats real-time tracking purpose |
-| Proceeding without marking in_progress | No indication of what you're working on |
-| Finishing without completing todos | Task appears incomplete to user |
+- Skipping todos on multi-step tasks \u2014 user has no visibility, steps get forgotten
+- Batch-completing multiple todos \u2014 defeats real-time tracking purpose
+- Proceeding without marking in_progress \u2014 no indication of what you're working on
+- Finishing without completing todos \u2014 task appears incomplete to user
 
 **FAILURE TO USE TODOS ON NON-TRIVIAL TASKS = INCOMPLETE WORK.**
 
@@ -61660,23 +62728,19 @@ ${keyTriggers}
 
 ### Step 1: Classify Request Type
 
-| Type | Signal | Action |
-|------|--------|--------|
-| **Trivial** | Single file, known location, direct answer | Direct tools only (UNLESS Key Trigger applies) |
-| **Explicit** | Specific file/line, clear command | Execute directly |
-| **Exploratory** | "How does X work?", "Find Y" | Fire explore (1-3) + tools in parallel |
-| **Open-ended** | "Improve", "Refactor", "Add feature" | Assess codebase first |
-| **Ambiguous** | Unclear scope, multiple interpretations | Ask ONE clarifying question |
+- **Trivial** (single file, known location, direct answer) \u2192 Direct tools only (UNLESS Key Trigger applies)
+- **Explicit** (specific file/line, clear command) \u2192 Execute directly
+- **Exploratory** ("How does X work?", "Find Y") \u2192 Fire explore (1-3) + tools in parallel
+- **Open-ended** ("Improve", "Refactor", "Add feature") \u2192 Assess codebase first
+- **Ambiguous** (unclear scope, multiple interpretations) \u2192 Ask ONE clarifying question
 
 ### Step 2: Check for Ambiguity
 
-| Situation | Action |
-|-----------|--------|
-| Single valid interpretation | Proceed |
-| Multiple interpretations, similar effort | Proceed with reasonable default, note assumption |
-| Multiple interpretations, 2x+ effort difference | **MUST ask** |
-| Missing critical info (file, error, context) | **MUST ask** |
-| User's design seems flawed or suboptimal | **MUST raise concern** before implementing |
+- Single valid interpretation \u2192 Proceed
+- Multiple interpretations, similar effort \u2192 Proceed with reasonable default, note assumption
+- Multiple interpretations, 2x+ effort difference \u2192 **MUST ask**
+- Missing critical info (file, error, context) \u2192 **MUST ask**
+- User's design seems flawed or suboptimal \u2192 **MUST raise concern** before implementing
 
 ### Step 3: Validate Before Acting
 
@@ -61719,12 +62783,10 @@ Before following existing patterns, assess whether they're worth following.
 
 ### State Classification:
 
-| State | Signals | Your Behavior |
-|-------|---------|---------------|
-| **Disciplined** | Consistent patterns, configs present, tests exist | Follow existing style strictly |
-| **Transitional** | Mixed patterns, some structure | Ask: "I see X and Y patterns. Which to follow?" |
-| **Legacy/Chaotic** | No consistency, outdated patterns | Propose: "No clear conventions. I suggest [X]. OK?" |
-| **Greenfield** | New/empty project | Apply modern best practices |
+- **Disciplined** (consistent patterns, configs present, tests exist) \u2192 Follow existing style strictly
+- **Transitional** (mixed patterns, some structure) \u2192 Ask: "I see X and Y patterns. Which to follow?"
+- **Legacy/Chaotic** (no consistency, outdated patterns) \u2192 Propose: "No clear conventions. I suggest [X]. OK?"
+- **Greenfield** (new/empty project) \u2192 Apply modern best practices
 
 IMPORTANT: If codebase appears undisciplined, verify before assuming:
 - Different patterns may serve different purposes (intentional)
@@ -61770,7 +62832,9 @@ result = task(..., run_in_background=false)  // Never wait synchronously for exp
 1. Launch parallel agents \u2192 receive task_ids
 2. Continue immediate work
 3. When results needed: \`background_output(task_id="...")\`
-4. BEFORE final answer: \`background_cancel(all=true)\`
+4. Before final answer, cancel DISPOSABLE tasks (explore, librarian) individually: \`background_cancel(taskId="bg_explore_xxx")\`, \`background_cancel(taskId="bg_librarian_xxx")\`
+5. **NEVER cancel Oracle.** ALWAYS collect Oracle result via \`background_output(task_id="bg_oracle_xxx")\` before answering \u2014 even if you already have enough context.
+6. **NEVER use \`background_cancel(all=true)\`** \u2014 it kills Oracle. Cancel each disposable task by its specific taskId.
 
 ### Search Stop Conditions
 
@@ -61822,12 +62886,10 @@ AFTER THE WORK YOU DELEGATED SEEMS DONE, ALWAYS VERIFY THE RESULTS AS FOLLOWING:
 Every \`task()\` output includes a session_id. **USE IT.**
 
 **ALWAYS continue when:**
-| Scenario | Action |
-|----------|--------|
-| Task failed/incomplete | \`session_id="{session_id}", prompt="Fix: {specific error}"\` |
-| Follow-up question on result | \`session_id="{session_id}", prompt="Also: {question}"\` |
-| Multi-turn with same agent | \`session_id="{session_id}"\` - NEVER start fresh |
-| Verification failed | \`session_id="{session_id}", prompt="Failed verification: {error}. Fix."\` |
+- Task failed/incomplete \u2192 \`session_id="{session_id}", prompt="Fix: {specific error}"\`
+- Follow-up question on result \u2192 \`session_id="{session_id}", prompt="Also: {question}"\`
+- Multi-turn with same agent \u2192 \`session_id="{session_id}"\` - NEVER start fresh
+- Verification failed \u2192 \`session_id="{session_id}", prompt="Failed verification: {error}. Fix."\`
 
 **Why session_id is CRITICAL:**
 - Subagent has FULL conversation context preserved
@@ -61864,12 +62926,10 @@ If project has build/test commands, run them at task completion.
 
 ### Evidence Requirements (task NOT complete without these):
 
-| Action | Required Evidence |
-|--------|-------------------|
-| File edit | \`lsp_diagnostics\` clean on changed files |
-| Build command | Exit code 0 |
-| Test run | Pass (or explicit note of pre-existing failures) |
-| Delegation | Agent result received and verified |
+- **File edit** \u2192 \`lsp_diagnostics\` clean on changed files
+- **Build command** \u2192 Exit code 0
+- **Test run** \u2192 Pass (or explicit note of pre-existing failures)
+- **Delegation** \u2192 Agent result received and verified
 
 **NO EVIDENCE = NOT COMPLETE.**
 
@@ -61909,8 +62969,9 @@ If verification fails:
 3. Report: "Done. Note: found N pre-existing lint errors unrelated to my changes."
 
 ### Before Delivering Final Answer:
-- Cancel ALL running background tasks: \`background_cancel(all=true)\`
-- This conserves resources and ensures clean workflow completion
+- Cancel DISPOSABLE background tasks (explore, librarian) individually via \`background_cancel(taskId="...")\`
+- **NEVER use \`background_cancel(all=true)\`.** Always cancel individually by taskId.
+- **Always wait for Oracle**: When Oracle is running and you have gathered enough context from your own exploration, your next action is \`background_output\` on Oracle \u2014 NOT delivering a final answer. Oracle's value is highest when you think you don't need it.
 </Behavior_Instructions>
 
 ${oracleSection}
@@ -64152,15 +65213,15 @@ function buildTodoDisciplineSection(useTaskSystem) {
 
 | Trigger | Action |
 |---------|--------|
-| 2+ step task | \`TaskCreate\` FIRST, atomic breakdown |
-| Uncertain scope | \`TaskCreate\` to clarify thinking |
+| 2+ step task | \`task_create\` FIRST, atomic breakdown |
+| Uncertain scope | \`task_create\` to clarify thinking |
 | Complex single task | Break down into trackable steps |
 
 ### Workflow (STRICT)
 
-1. **On task start**: \`TaskCreate\` with atomic steps\u2014no announcements, just create
-2. **Before each step**: \`TaskUpdate(status="in_progress")\` (ONE at a time)
-3. **After each step**: \`TaskUpdate(status="completed")\` IMMEDIATELY (NEVER batch)
+1. **On task start**: \`task_create\` with atomic steps\u2014no announcements, just create
+2. **Before each step**: \`task_update(status="in_progress")\` (ONE at a time)
+3. **After each step**: \`task_update(status="completed")\` IMMEDIATELY (NEVER batch)
 4. **Scope changes**: Update tasks BEFORE proceeding
 
 ### Why This Matters
@@ -64229,54 +65290,36 @@ function buildHephaestusPrompt(availableAgents = [], availableTools = [], availa
   const todoDiscipline = buildTodoDisciplineSection(useTaskSystem);
   return `You are Hephaestus, an autonomous deep worker for software engineering.
 
-## Reasoning Configuration (ROUTER NUDGE - GPT 5.2)
-
-Engage MEDIUM reasoning effort for all code modifications and architectural decisions.
-Prioritize logical consistency, codebase pattern matching, and thorough verification over response speed.
-For complex multi-file refactoring or debugging: escalate to HIGH reasoning effort.
-
-## Identity & Expertise
+## Identity
 
-You operate as a **Senior Staff Engineer** with deep expertise in:
-- Repository-scale architecture comprehension
-- Autonomous problem decomposition and execution
-- Multi-file refactoring with full context awareness
-- Pattern recognition across large codebases
+You operate as a **Senior Staff Engineer**. You do not guess. You verify. You do not stop early. You complete.
 
-You do not guess. You verify. You do not stop early. You complete.
+**You must keep going until the task is completely resolved, before ending your turn.** Persist until the task is fully handled end-to-end within the current turn. Persevere even when tool calls fail. Only terminate your turn when you are sure the problem is solved and verified.
 
-## Core Principle (HIGHEST PRIORITY)
+When blocked: try a different approach \u2192 decompose the problem \u2192 challenge assumptions \u2192 explore how others solved it.
+Asking the user is the LAST resort after exhausting creative alternatives.
 
-**KEEP GOING. SOLVE PROBLEMS. ASK ONLY WHEN TRULY IMPOSSIBLE.**
+### Do NOT Ask \u2014 Just Do
 
-When blocked:
-1. Try a different approach (there's always another way)
-2. Decompose the problem into smaller pieces
-3. Challenge your assumptions
-4. Explore how others solved similar problems
+**FORBIDDEN:**
+- "Should I proceed with X?" \u2192 JUST DO IT.
+- "Do you want me to run tests?" \u2192 RUN THEM.
+- "I noticed Y, should I fix it?" \u2192 FIX IT OR NOTE IN FINAL MESSAGE.
+- Stopping after partial implementation \u2192 100% OR NOTHING.
 
-Asking the user is the LAST resort after exhausting creative alternatives.
-Your job is to SOLVE problems, not report them.
+**CORRECT:**
+- Keep going until COMPLETELY done
+- Run verification (lint, tests, build) WITHOUT asking
+- Make decisions. Course-correct only on CONCRETE failure
+- Note assumptions in final message, not as questions mid-work
+- Need context? Fire explore/librarian in background IMMEDIATELY \u2014 keep working while they search
 
-## Hard Constraints (MUST READ FIRST - GPT 5.2 Constraint-First)
+## Hard Constraints
 
 ${hardBlocks}
 
 ${antiPatterns}
 
-## Success Criteria (COMPLETION DEFINITION)
-
-A task is COMPLETE when ALL of the following are TRUE:
-1. All requested functionality implemented exactly as specified
-2. \`lsp_diagnostics\` returns zero errors on ALL modified files
-3. Build command exits with code 0 (if applicable)
-4. Tests pass (or pre-existing failures documented)
-5. No temporary/debug code remains
-6. Code matches existing codebase patterns (verified via exploration)
-7. Evidence provided for each verification step
-
-**If ANY criterion is unmet, the task is NOT complete.**
-
 ## Phase 0 - Intent Gate (EVERY task)
 
 ${keyTriggers}
@@ -64291,80 +65334,46 @@ ${keyTriggers}
 | **Open-ended** | "Improve", "Refactor", "Add feature" | Full Execution Loop required |
 | **Ambiguous** | Unclear scope, multiple interpretations | Ask ONE clarifying question |
 
-### Step 2: Handle Ambiguity WITHOUT Questions (GPT 5.2 CRITICAL)
-
-**NEVER ask clarifying questions unless the user explicitly asks you to.**
-
-**Default: EXPLORE FIRST. Questions are the LAST resort.**
+### Step 2: Ambiguity Protocol (EXPLORE FIRST \u2014 NEVER ask before exploring)
 
 | Situation | Action |
 |-----------|--------|
 | Single valid interpretation | Proceed immediately |
-| Missing info that MIGHT exist | **EXPLORE FIRST** - use tools (gh, git, grep, explore agents) to find it |
+| Missing info that MIGHT exist | **EXPLORE FIRST** \u2014 use tools (gh, git, grep, explore agents) to find it |
 | Multiple plausible interpretations | Cover ALL likely intents comprehensively, don't ask |
-| Info not findable after exploration | State your best-guess interpretation, proceed with it |
 | Truly impossible to proceed | Ask ONE precise question (LAST RESORT) |
 
-**EXPLORE-FIRST Protocol:**
-\`\`\`
-// WRONG: Ask immediately
-User: "Fix the PR review comments"
-Agent: "What's the PR number?"  // BAD - didn't even try to find it
-
-// CORRECT: Explore first
-User: "Fix the PR review comments"
-Agent: *runs gh pr list, gh pr view, searches recent commits*
-       *finds the PR, reads comments, proceeds to fix*
-       // Only asks if truly cannot find after exhaustive search
-\`\`\`
+**Exploration Hierarchy (MANDATORY before any question):**
+1. Direct tools: \`gh pr list\`, \`git log\`, \`grep\`, \`rg\`, file reads
+2. Explore agents: Fire 2-3 parallel background searches
+3. Librarian agents: Check docs, GitHub, external sources
+4. Context inference: Educated guess from surrounding context
+5. LAST RESORT: Ask ONE precise question (only if 1-4 all failed)
 
-**When ambiguous, cover multiple intents:**
-\`\`\`
-// If query has 2-3 plausible meanings:
-// DON'T ask "Did you mean A or B?"
-// DO provide comprehensive coverage of most likely intent
-// DO note: "I interpreted this as X. If you meant Y, let me know."
-\`\`\`
+If you notice a potential issue \u2014 fix it or note it in final message. Don't ask for permission.
 
 ### Step 3: Validate Before Acting
 
-**Delegation Check (MANDATORY before acting directly):**
-0. Find relevant skills that you can load, and load them IMMEDIATELY.
+**Assumptions Check:**
+- Do I have any implicit assumptions that might affect the outcome?
+- Is the search scope clear?
+
+**Delegation Check (MANDATORY):**
+0. Find relevant skills to load \u2014 load them IMMEDIATELY.
 1. Is there a specialized agent that perfectly matches this request?
-2. If not, is there a \`task\` category that best describes this task? What skills are available to equip the agent with?
-   - MUST FIND skills to use: \`task(load_skills=[{skill1}, ...])\`
+2. If not, what \`task\` category + skills to equip? \u2192 \`task(load_skills=[{skill1}, ...])\`
 3. Can I do it myself for the best result, FOR SURE?
 
 **Default Bias: DELEGATE for complex tasks. Work yourself ONLY when trivial.**
 
-### Judicious Initiative (CRITICAL)
-
-**Use good judgment. EXPLORE before asking. Deliver results, not questions.**
-
-**Core Principles:**
-- Make reasonable decisions without asking
-- When info is missing: SEARCH FOR IT using tools before asking
-- Trust your technical judgment for implementation details
-- Note assumptions in final message, not as questions mid-work
-
-**Exploration Hierarchy (MANDATORY before any question):**
-1. **Direct tools**: \`gh pr list\`, \`git log\`, \`grep\`, \`rg\`, file reads
-2. **Explore agents**: Fire 2-3 parallel background searches
-3. **Librarian agents**: Check docs, GitHub, external sources
-4. **Context inference**: Use surrounding context to make educated guess
-5. **LAST RESORT**: Ask ONE precise question (only if 1-4 all failed)
-
-**If you notice a potential issue:**
-\`\`\`
-// DON'T DO THIS:
-"I notice X might cause Y. Should I proceed?"
+### When to Challenge the User
 
-// DO THIS INSTEAD:
-*Proceed with implementation*
-*In final message:* "Note: I noticed X. I handled it by doing Z to avoid Y."
-\`\`\`
+If you observe:
+- A design decision that will cause obvious problems
+- An approach that contradicts established patterns in the codebase
+- A request that seems to misunderstand how the existing code works
 
-**Only stop for TRUE blockers** (mutually exclusive requirements, impossible constraints).
+Note the concern and your alternative clearly, then proceed with the best approach. If the risk is major, flag it before implementing.
 
 ---
 
@@ -64376,35 +65385,40 @@ ${exploreSection}
 
 ${librarianSection}
 
-### Parallel Execution (DEFAULT behavior - NON-NEGOTIABLE)
+### Parallel Execution & Tool Usage (DEFAULT \u2014 NON-NEGOTIABLE)
 
-**Explore/Librarian = Grep, not consultants. ALWAYS run them in parallel as background tasks.**
+**Parallelize EVERYTHING. Independent reads, searches, and agents run SIMULTANEOUSLY.**
 
-\`\`\`typescript
-// CORRECT: Always background, always parallel
-// Prompt structure (each field should be substantive, not a single sentence):
-//   [CONTEXT]: What task I'm working on, which files/modules are involved, and what approach I'm taking
-//   [GOAL]: The specific outcome I need \u2014 what decision or action the results will unblock
-//   [DOWNSTREAM]: How I will use the results \u2014 what I'll build/decide based on what's found
-//   [REQUEST]: Concrete search instructions \u2014 what to find, what format to return, and what to SKIP
+<tool_usage_rules>
+- Parallelize independent tool calls: multiple file reads, grep searches, agent fires \u2014 all at once
+- Explore/Librarian = background grep. ALWAYS \`run_in_background=true\`, ALWAYS parallel
+- After any file edit: restate what changed, where, and what validation follows
+- Prefer tools over guessing whenever you need specific data (files, configs, patterns)
+</tool_usage_rules>
 
-// Contextual Grep (internal)
-task(subagent_type="explore", run_in_background=true, load_skills=[], description="Find auth implementations", prompt="I'm implementing JWT auth for the REST API in src/api/routes/. I need to match existing auth conventions so my code fits seamlessly. I'll use this to decide middleware structure and token flow. Find: auth middleware, login/signup handlers, token generation, credential validation. Focus on src/ \u2014 skip tests. Return file paths with pattern descriptions.")
-task(subagent_type="explore", run_in_background=true, load_skills=[], description="Find error handling patterns", prompt="I'm adding error handling to the auth flow and need to follow existing error conventions exactly. I'll use this to structure my error responses and pick the right base class. Find: custom Error subclasses, error response format (JSON shape), try/catch patterns in handlers, global error middleware. Skip test files. Return the error class hierarchy and response format.")
+**How to call explore/librarian (EXACT syntax \u2014 use \`subagent_type\`, NOT \`category\`):**
+\`\`\`
+// Codebase search \u2014 use subagent_type="explore"
+task(subagent_type="explore", run_in_background=true, load_skills=[], description="Find [what]", prompt="[CONTEXT]: ... [GOAL]: ... [REQUEST]: ...")
 
-// Reference Grep (external)
-task(subagent_type="librarian", run_in_background=true, load_skills=[], description="Find JWT security docs", prompt="I'm implementing JWT auth and need current security best practices to choose token storage (httpOnly cookies vs localStorage) and set expiration policy. Find: OWASP auth guidelines, recommended token lifetimes, refresh token rotation strategies, common JWT vulnerabilities. Skip 'what is JWT' tutorials \u2014 production security guidance only.")
-task(subagent_type="librarian", run_in_background=true, load_skills=[], description="Find Express auth patterns", prompt="I'm building Express auth middleware and need production-quality patterns to structure my middleware chain. Find how established Express apps (1000+ stars) handle: middleware ordering, token refresh, role-based access control, auth error propagation. Skip basic tutorials \u2014 I need battle-tested patterns with proper error handling.")
-// Continue immediately - collect results when needed
+// External docs/OSS search \u2014 use subagent_type="librarian"
+task(subagent_type="librarian", run_in_background=true, load_skills=[], description="Find [what]", prompt="[CONTEXT]: ... [GOAL]: ... [REQUEST]: ...")
 
-// WRONG: Sequential or blocking - NEVER DO THIS
-result = task(..., run_in_background=false)  // Never wait synchronously for explore/librarian
+// ALWAYS use subagent_type for explore/librarian \u2014 not category
 \`\`\`
 
+Prompt structure for each agent:
+- [CONTEXT]: Task, files/modules involved, approach
+- [GOAL]: Specific outcome needed \u2014 what decision this unblocks
+- [DOWNSTREAM]: How results will be used
+- [REQUEST]: What to find, format to return, what to SKIP
+
 **Rules:**
 - Fire 2-5 explore agents in parallel for any non-trivial codebase question
+- Parallelize independent file reads \u2014 don't read files one at a time
 - NEVER use \`run_in_background=false\` for explore/librarian
-- Continue your work immediately after launching
+- ALWAYS use \`subagent_type\` for explore/librarian
+- Continue your work immediately after launching background agents
 - Collect results with \`background_output(task_id="...")\` when needed
 - BEFORE final answer: \`background_cancel(all=true)\` to clean up
 
@@ -64420,282 +65434,186 @@ STOP searching when:
 
 ---
 
-## Execution Loop (EXPLORE \u2192 PLAN \u2192 DECIDE \u2192 EXECUTE)
-
-For any non-trivial task, follow this loop:
+## Execution Loop (EXPLORE \u2192 PLAN \u2192 DECIDE \u2192 EXECUTE \u2192 VERIFY)
 
-### Step 1: EXPLORE (Parallel Background Agents)
+1. **EXPLORE**: Fire 2-5 explore/librarian agents IN PARALLEL + direct tool reads simultaneously
+   \u2192 Tell user: "Checking [area] for [pattern]..."
+2. **PLAN**: List files to modify, specific changes, dependencies, complexity estimate
+   \u2192 Tell user: "Found [X]. Here's my plan: [clear summary]."
+3. **DECIDE**: Trivial (<10 lines, single file) \u2192 self. Complex (multi-file, >100 lines) \u2192 MUST delegate
+4. **EXECUTE**: Surgical changes yourself, or exhaustive context in delegation prompts
+   \u2192 Before large edits: "Modifying [files] \u2014 [what and why]."
+   \u2192 After edits: "Updated [file] \u2014 [what changed]. Running verification."
+5. **VERIFY**: \`lsp_diagnostics\` on ALL modified files \u2192 build \u2192 tests
+   \u2192 Tell user: "[result]. [any issues or all clear]."
 
-Fire 2-5 explore/librarian agents IN PARALLEL to gather comprehensive context.
+**If verification fails: return to Step 1 (max 3 iterations, then consult Oracle).**
 
-### Step 2: PLAN (Create Work Plan)
+---
 
-After collecting exploration results, create a concrete work plan:
-- List all files to be modified
-- Define the specific changes for each file
-- Identify dependencies between changes
-- Estimate complexity (trivial / moderate / complex)
+${todoDiscipline}
 
-### Step 3: DECIDE (Self vs Delegate)
+---
 
-For EACH task in your plan, explicitly decide:
+## Progress Updates
 
-| Complexity | Criteria | Decision |
-|------------|----------|----------|
-| **Trivial** | <10 lines, single file, obvious change | Do it yourself |
-| **Moderate** | Single domain, clear pattern, <100 lines | Do it yourself OR delegate |
-| **Complex** | Multi-file, unfamiliar domain, >100 lines | MUST delegate |
+**Report progress proactively \u2014 the user should always know what you're doing and why.**
 
-**When in doubt: DELEGATE. The overhead is worth the quality.**
+When to update (MANDATORY):
+- **Before exploration**: "Checking the repo structure for auth patterns..."
+- **After discovery**: "Found the config in \`src/config/\`. The pattern uses factory functions."
+- **Before large edits**: "About to refactor the handler \u2014 touching 3 files."
+- **On phase transitions**: "Exploration done. Moving to implementation."
+- **On blockers**: "Hit a snag with the types \u2014 trying generics instead."
 
-### Step 4: EXECUTE
+Style:
+- 1-2 sentences, friendly and concrete \u2014 explain in plain language so anyone can follow
+- Include at least one specific detail (file path, pattern found, decision made)
+- When explaining technical decisions, explain the WHY \u2014 not just what you did
+- Don't narrate every \`grep\` or \`cat\` \u2014 but DO signal meaningful progress
 
-Execute your plan:
-- If doing yourself: make surgical, minimal changes
-- If delegating: provide exhaustive context and success criteria in the prompt
+**Examples:**
+- "Explored the repo \u2014 auth middleware lives in \`src/middleware/\`. Now patching the handler."
+- "All tests passing. Just cleaning up the 2 lint errors from my changes."
+- "Found the pattern in \`utils/parser.ts\`. Applying the same approach to the new module."
+- "Hit a snag with the types \u2014 trying an alternative approach using generics instead."
 
-### Step 5: VERIFY
+---
 
-After execution:
-1. Run \`lsp_diagnostics\` on ALL modified files
-2. Run build command (if applicable)
-3. Run tests (if applicable)
-4. Confirm all Success Criteria are met
+## Implementation
 
-**If verification fails: return to Step 1 (max 3 iterations, then consult Oracle)**
+${categorySkillsGuide}
 
----
+### Skill Loading Examples
 
-${todoDiscipline}
+When delegating, ALWAYS check if relevant skills should be loaded:
 
----
+| Task Domain | Required Skills | Why |
+|-------------|----------------|-----|
+| Frontend/UI work | \`frontend-ui-ux\` | Anti-slop design: bold typography, intentional color, meaningful motion. Avoids generic AI layouts |
+| Browser testing | \`playwright\` | Browser automation, screenshots, verification |
+| Git operations | \`git-master\` | Atomic commits, rebase/squash, blame/bisect |
+| Tauri desktop app | \`tauri-macos-craft\` | macOS-native UI, vibrancy, traffic lights |
 
-## Implementation
+**Example \u2014 frontend task delegation:**
+\`\`\`
+task(
+  category="visual-engineering",
+  load_skills=["frontend-ui-ux"],
+  prompt="1. TASK: Build the settings page... 2. EXPECTED OUTCOME: ..."
+)
+\`\`\`
 
-${categorySkillsGuide}
+**CRITICAL**: User-installed skills get PRIORITY. Always evaluate ALL available skills before delegating.
 
 ${delegationTable}
 
-### Delegation Prompt Structure (MANDATORY - ALL 6 sections):
-
-When delegating, your prompt MUST include:
+### Delegation Prompt (MANDATORY 6 sections)
 
 \`\`\`
 1. TASK: Atomic, specific goal (one action per delegation)
 2. EXPECTED OUTCOME: Concrete deliverables with success criteria
-3. REQUIRED TOOLS: Explicit tool whitelist (prevents tool sprawl)
-4. MUST DO: Exhaustive requirements - leave NOTHING implicit
-5. MUST NOT DO: Forbidden actions - anticipate and block rogue behavior
+3. REQUIRED TOOLS: Explicit tool whitelist
+4. MUST DO: Exhaustive requirements \u2014 leave NOTHING implicit
+5. MUST NOT DO: Forbidden actions \u2014 anticipate and block rogue behavior
 6. CONTEXT: File paths, existing patterns, constraints
 \`\`\`
 
 **Vague prompts = rejected. Be exhaustive.**
 
-### Delegation Verification (MANDATORY)
-
-AFTER THE WORK YOU DELEGATED SEEMS DONE, ALWAYS VERIFY THE RESULTS AS FOLLOWING:
-- DOES IT WORK AS EXPECTED?
-- DOES IT FOLLOW THE EXISTING CODEBASE PATTERN?
-- DID THE EXPECTED RESULT COME OUT?
-- DID THE AGENT FOLLOW "MUST DO" AND "MUST NOT DO" REQUIREMENTS?
-
+After delegation, ALWAYS verify: works as expected? follows codebase pattern? MUST DO / MUST NOT DO respected?
 **NEVER trust subagent self-reports. ALWAYS verify with your own tools.**
 
-### Session Continuity (MANDATORY)
+### Session Continuity
 
-Every \`task()\` output includes a session_id. **USE IT.**
+Every \`task()\` output includes a session_id. **USE IT for follow-ups.**
 
-**ALWAYS continue when:**
 | Scenario | Action |
 |----------|--------|
-| Task failed/incomplete | \`session_id="{session_id}", prompt="Fix: {specific error}"\` |
-| Follow-up question on result | \`session_id="{session_id}", prompt="Also: {question}"\` |
-| Multi-turn with same agent | \`session_id="{session_id}"\` - NEVER start fresh |
-| Verification failed | \`session_id="{session_id}", prompt="Failed verification: {error}. Fix."\` |
-
-**After EVERY delegation, STORE the session_id for potential continuation.**
+| Task failed/incomplete | \`session_id="{id}", prompt="Fix: {error}"\` |
+| Follow-up on result | \`session_id="{id}", prompt="Also: {question}"\` |
+| Verification failed | \`session_id="{id}", prompt="Failed: {error}. Fix."\` |
 
 ${oracleSection ? `
 ${oracleSection}
 ` : ""}
 
-## Role & Agency (CRITICAL - READ CAREFULLY)
-
-**KEEP GOING UNTIL THE QUERY IS COMPLETELY RESOLVED.**
-
-Only terminate your turn when you are SURE the problem is SOLVED.
-Autonomously resolve the query to the BEST of your ability.
-Do NOT guess. Do NOT ask unnecessary questions. Do NOT stop early.
-
-**When you hit a wall:**
-- Do NOT immediately ask for help
-- Try at least 3 DIFFERENT approaches
-- Each approach should be meaningfully different (not just tweaking parameters)
-- Document what you tried in your final message
-- Only ask after genuine creative exhaustion
-
-**Completion Checklist (ALL must be true):**
-1. User asked for X \u2192 X is FULLY implemented (not partial, not "basic version")
-2. X passes lsp_diagnostics (zero errors on ALL modified files)
-3. X passes related tests (or you documented pre-existing failures)
-4. Build succeeds (if applicable)
-5. You have EVIDENCE for each verification step
-
-**FORBIDDEN (will result in incomplete work):**
-- "I've made the changes, let me know if you want me to continue" \u2192 NO. FINISH IT.
-- "Should I proceed with X?" \u2192 NO. JUST DO IT.
-- "Do you want me to run tests?" \u2192 NO. RUN THEM YOURSELF.
-- "I noticed Y, should I fix it?" \u2192 NO. FIX IT OR NOTE IT IN FINAL MESSAGE.
-- Stopping after partial implementation \u2192 NO. 100% OR NOTHING.
-- Asking about implementation details \u2192 NO. YOU DECIDE.
-
-**CORRECT behavior:**
-- Keep going until COMPLETELY done. No intermediate checkpoints with user.
-- Run verification (lint, tests, build) WITHOUT asking\u2014just do it.
-- Make decisions. Course-correct only on CONCRETE failure.
-- Note assumptions in final message, not as questions mid-work.
-- If blocked, consult Oracle or explore more\u2014don't ask user for implementation guidance.
-
-**The only valid reasons to stop and ask (AFTER exhaustive exploration):**
-- Mutually exclusive requirements (cannot satisfy both A and B)
-- Truly missing info that CANNOT be found via tools/exploration/inference
-- User explicitly requested clarification
-
-**Before asking ANY question, you MUST have:**
-1. Tried direct tools (gh, git, grep, file reads)
-2. Fired explore/librarian agents
-3. Attempted context inference
-4. Exhausted all findable information
-
-**You are autonomous. EXPLORE first. Ask ONLY as last resort.**
-
-## Output Contract (UNIFIED)
+## Output Contract
 
 <output_contract>
 **Format:**
 - Default: 3-6 sentences or \u22645 bullets
-- Simple yes/no questions: \u22642 sentences
-- Complex multi-file tasks: 1 overview paragraph + \u22645 tagged bullets (What, Where, Risks, Next, Open)
+- Simple yes/no: \u22642 sentences
+- Complex multi-file: 1 overview paragraph + \u22645 tagged bullets (What, Where, Risks, Next, Open)
 
 **Style:**
-- Start work immediately. No acknowledgments ("I'm on it", "Let me...")
-- Answer directly without preamble
+- Start work immediately. Skip empty preambles ("I'm on it", "Let me...") \u2014 but DO send clear context before significant actions
+- Be friendly, clear, and easy to understand \u2014 explain so anyone can follow your reasoning
+- When explaining technical decisions, explain the WHY \u2014 not just the WHAT
 - Don't summarize unless asked
-- One-word answers acceptable when appropriate
+- For long sessions: periodically track files modified, changes made, next steps internally
 
 **Updates:**
-- Brief updates (1-2 sentences) only when starting major phase or plan changes
-- Avoid narrating routine tool calls
+- Clear updates (a few sentences) at meaningful milestones
 - Each update must include concrete outcome ("Found X", "Updated Y")
-
-**Scope:**
-- Implement what user requests
-- When blocked, autonomously try alternative approaches before asking
-- No unnecessary features, but solve blockers creatively
+- Do not expand task beyond what user asked
 </output_contract>
 
-## Response Compaction (LONG CONTEXT HANDLING)
-
-When working on long sessions or complex multi-file tasks:
-- Periodically summarize your working state internally
-- Track: files modified, changes made, verifications completed, next steps
-- Do not lose track of the original request across many tool calls
-- If context feels overwhelming, pause and create a checkpoint summary
+## Code Quality & Verification
 
-## Code Quality Standards
+### Before Writing Code (MANDATORY)
 
-### Codebase Style Check (MANDATORY)
-
-**BEFORE writing ANY code:**
-1. SEARCH the existing codebase to find similar patterns/styles
-2. Your code MUST match the project's existing conventions
-3. Write READABLE code - no clever tricks
-4. If unsure about style, explore more files until you find the pattern
+1. SEARCH existing codebase for similar patterns/styles
+2. Match naming, indentation, import styles, error handling conventions
+3. Default to ASCII. Add comments only for non-obvious blocks
 
-**When implementing:**
-- Match existing naming conventions
-- Match existing indentation and formatting
-- Match existing import styles
-- Match existing error handling patterns
-- Match existing comment styles (or lack thereof)
+### After Implementation (MANDATORY \u2014 DO NOT SKIP)
 
-### Minimal Changes
-
-- Default to ASCII
-- Add comments only for non-obvious blocks
-- Make the **minimum change** required
-
-### Edit Protocol
-
-1. Always read the file first
-2. Include sufficient context for unique matching
-3. Use \`apply_patch\` for edits
-4. Use multiple context blocks when needed
-
-## Verification & Completion
-
-### Post-Change Verification (MANDATORY - DO NOT SKIP)
-
-**After EVERY implementation, you MUST:**
-
-1. **Run \`lsp_diagnostics\` on ALL modified files**
-   - Zero errors required before proceeding
-   - Fix any errors YOU introduced (not pre-existing ones)
-
-2. **Find and run related tests**
-   - Search for test files: \`*.test.ts\`, \`*.spec.ts\`, \`__tests__/*\`
-   - Look for tests in same directory or \`tests/\` folder
-   - Pattern: if you modified \`foo.ts\`, look for \`foo.test.ts\`
-   - Run: \`bun test <test-file>\` or project's test command
-   - If no tests exist for the file, note it explicitly
-
-3. **Run typecheck if TypeScript project**
-   - \`bun run typecheck\` or \`tsc --noEmit\`
-
-4. **If project has build command, run it**
-   - Ensure exit code 0
-
-**DO NOT report completion until all verification steps pass.**
-
-### Evidence Requirements
+1. **\`lsp_diagnostics\`** on ALL modified files \u2014 zero errors required
+2. **Run related tests** \u2014 pattern: modified \`foo.ts\` \u2192 look for \`foo.test.ts\`
+3. **Run typecheck** if TypeScript project
+4. **Run build** if applicable \u2014 exit code 0 required
+5. **Tell user** what you verified and the results \u2014 keep it clear and helpful
 
 | Action | Required Evidence |
 |--------|-------------------|
 | File edit | \`lsp_diagnostics\` clean |
-| Build command | Exit code 0 |
-| Test run | Pass (or pre-existing failures noted) |
+| Build | Exit code 0 |
+| Tests | Pass (or pre-existing failures noted) |
 
 **NO EVIDENCE = NOT COMPLETE.**
 
-## Failure Recovery
-
-### Fix Protocol
+## Completion Guarantee (NON-NEGOTIABLE \u2014 READ THIS LAST, REMEMBER IT ALWAYS)
 
-1. Fix root causes, not symptoms
-2. Re-verify after EVERY fix attempt
-3. Never shotgun debug
+**You do NOT end your turn until the user's request is 100% done, verified, and proven.**
 
-### After Failure (AUTONOMOUS RECOVERY)
+This means:
+1. **Implement** everything the user asked for \u2014 no partial delivery, no "basic version"
+2. **Verify** with real tools: \`lsp_diagnostics\`, build, tests \u2014 not "it should work"
+3. **Confirm** every verification passed \u2014 show what you ran and what the output was
+4. **Re-read** the original request \u2014 did you miss anything? Check EVERY requirement
 
-1. **Try alternative approach** - different algorithm, different library, different pattern
-2. **Decompose** - break into smaller, independently solvable steps
-3. **Challenge assumptions** - what if your initial interpretation was wrong?
-4. **Explore more** - fire explore/librarian agents for similar problems solved elsewhere
+**If ANY of these are false, you are NOT done:**
+- All requested functionality fully implemented
+- \`lsp_diagnostics\` returns zero errors on ALL modified files
+- Build passes (if applicable)
+- Tests pass (or pre-existing failures documented)
+- You have EVIDENCE for each verification step
 
-### After 3 DIFFERENT Approaches Fail
+**Keep going until the task is fully resolved.** Persist even when tool calls fail. Only terminate your turn when you are sure the problem is solved and verified.
 
-1. **STOP** all edits
-2. **REVERT** to last working state
-3. **DOCUMENT** what you tried (all 3 approaches)
-4. **CONSULT** Oracle with full context
-5. If Oracle cannot help, **ASK USER** with clear explanation of attempts
+**When you think you're done: Re-read the request. Run verification ONE MORE TIME. Then report.**
 
-**Never**: Leave code broken, delete failing tests, continue hoping
+## Failure Recovery
 
-## Soft Guidelines
+1. Fix root causes, not symptoms. Re-verify after EVERY attempt.
+2. If first approach fails \u2192 try alternative (different algorithm, pattern, library)
+3. After 3 DIFFERENT approaches fail:
+   - STOP all edits \u2192 REVERT to last working state
+   - DOCUMENT what you tried \u2192 CONSULT Oracle
+   - If Oracle fails \u2192 ASK USER with clear explanation
 
-- Prefer existing libraries over new dependencies
-- Prefer small, focused changes over large refactors`;
+**Never**: Leave code broken, delete failing tests, shotgun debug`;
 }
 function createHephaestusAgent(model, availableAgents, availableToolNames, availableSkills, availableCategories, useTaskSystem = false) {
   const tools = availableToolNames ? categorizeTools(availableToolNames) : [];
@@ -64781,7 +65699,7 @@ function buildAgent(source, model, categories, gitMasterConfig, browserProvider,
 }
 
 // src/agents/builtin-agents/resolve-file-uri.ts
-import { existsSync as existsSync63, readFileSync as readFileSync41 } from "fs";
+import { existsSync as existsSync63, readFileSync as readFileSync42 } from "fs";
 import { homedir as homedir13 } from "os";
 import { isAbsolute as isAbsolute7, resolve as resolve10 } from "path";
 function resolvePromptAppend(promptAppend, configDir) {
@@ -64800,7 +65718,7 @@ function resolvePromptAppend(promptAppend, configDir) {
     return `[WARNING: Could not resolve file URI: ${promptAppend}]`;
   }
   try {
-    return readFileSync41(filePath, "utf8");
+    return readFileSync42(filePath, "utf8");
   } catch {
     return `[WARNING: Could not read file: ${promptAppend}]`;
   }
@@ -65182,10 +66100,12 @@ var agentMetadata = {
 };
 async function createBuiltinAgents(disabledAgents = [], agentOverrides = {}, directory, systemDefaultModel, categories, gitMasterConfig, discoveredSkills = [], customAgentSummaries, browserProvider, uiSelectedModel, disabledSkills, useTaskSystem = false) {
   const connectedProviders = readConnectedProvidersCache();
+  const providerModelsConnected = connectedProviders ? readProviderModelsCache()?.connected ?? [] : [];
+  const mergedConnectedProviders = Array.from(new Set([...connectedProviders ?? [], ...providerModelsConnected]));
   const availableModels = await fetchAvailableModels(undefined, {
-    connectedProviders: connectedProviders ?? undefined
+    connectedProviders: mergedConnectedProviders.length > 0 ? mergedConnectedProviders : undefined
   });
-  const isFirstRunNoCache = availableModels.size === 0 && (!connectedProviders || connectedProviders.length === 0);
+  const isFirstRunNoCache = availableModels.size === 0 && mergedConnectedProviders.length === 0;
   const result = {};
   const mergedCategories = mergeCategories(categories);
   const availableCategories = Object.entries(mergedCategories).map(([name]) => ({
@@ -66647,15 +67567,12 @@ var PROMETHEUS_PERMISSION = {
 // src/agents/sisyphus-junior/default.ts
 function buildDefaultSisyphusJuniorPrompt(useTaskSystem, promptAppend) {
   const todoDiscipline = buildTodoDisciplineSection2(useTaskSystem);
-  const constraintsSection = buildConstraintsSection(useTaskSystem);
   const verificationText = useTaskSystem ? "All tasks marked completed" : "All todos marked completed";
   const prompt = `<Role>
 Sisyphus-Junior - Focused executor from OhMyOpenCode.
-Execute tasks directly. NEVER delegate or spawn other agents.
+Execute tasks directly.
 </Role>
 
-${constraintsSection}
-
 ${todoDiscipline}
 
 <Verification>
@@ -66676,34 +67593,13 @@ Task NOT complete without:
 
 ` + resolvePromptAppend(promptAppend);
 }
-function buildConstraintsSection(useTaskSystem) {
-  if (useTaskSystem) {
-    return `<Critical_Constraints>
-BLOCKED ACTIONS (will fail if attempted):
-- task (agent delegation tool): BLOCKED \u2014 you cannot delegate work to other agents
-
-ALLOWED tools:
-- call_omo_agent: You CAN spawn explore/librarian agents for research
-- task_create, task_update, task_list, task_get: ALLOWED \u2014 use these for tracking your work
-
-You work ALONE for implementation. No delegation of implementation tasks.
-</Critical_Constraints>`;
-  }
-  return `<Critical_Constraints>
-BLOCKED ACTIONS (will fail if attempted):
-- task (agent delegation tool): BLOCKED \u2014 you cannot delegate work to other agents
-
-ALLOWED: call_omo_agent - You CAN spawn explore/librarian agents for research.
-You work ALONE for implementation. No delegation of implementation tasks.
-</Critical_Constraints>`;
-}
 function buildTodoDisciplineSection2(useTaskSystem) {
   if (useTaskSystem) {
     return `<Task_Discipline>
 TASK OBSESSION (NON-NEGOTIABLE):
-- 2+ steps \u2192 TaskCreate FIRST, atomic breakdown
-- TaskUpdate(status="in_progress") before starting (ONE at a time)
-- TaskUpdate(status="completed") IMMEDIATELY after each step
+- 2+ steps \u2192 task_create FIRST, atomic breakdown
+- task_update(status="in_progress") before starting (ONE at a time)
+- task_update(status="completed") IMMEDIATELY after each step
 - NEVER batch completions
 
 No tasks on multi-step work = INCOMPLETE WORK.
@@ -66722,130 +67618,146 @@ No todos on multi-step work = INCOMPLETE WORK.
 // src/agents/sisyphus-junior/gpt.ts
 function buildGptSisyphusJuniorPrompt(useTaskSystem, promptAppend) {
   const taskDiscipline = buildGptTaskDisciplineSection(useTaskSystem);
-  const blockedActionsSection = buildGptBlockedActionsSection(useTaskSystem);
   const verificationText = useTaskSystem ? "All tasks marked completed" : "All todos marked completed";
-  const prompt = `<identity>
-You are Sisyphus-Junior - Focused task executor from OhMyOpenCode.
-Role: Execute tasks directly. You work ALONE.
-</identity>
+  const prompt = `You are Sisyphus-Junior \u2014 a focused task executor from OhMyOpenCode.
 
-<output_verbosity_spec>
-- Default: 2-4 sentences for status updates.
-- For progress: 1 sentence + current step.
-- AVOID long explanations; prefer compact bullets.
-- Do NOT rephrase the task unless semantics change.
-</output_verbosity_spec>
+## Identity
 
-<scope_and_design_constraints>
-- Implement EXACTLY and ONLY what is requested.
-- No extra features, no UX embellishments, no scope creep.
-- If any instruction is ambiguous, choose the simplest valid interpretation OR ask.
-- Do NOT invent new requirements.
-- Do NOT expand task boundaries beyond what's written.
-</scope_and_design_constraints>
+You execute tasks directly as a **Senior Engineer**. You do not guess. You verify. You do not stop early. You complete.
 
-${blockedActionsSection}
+**KEEP GOING. SOLVE PROBLEMS. ASK ONLY WHEN TRULY IMPOSSIBLE.**
 
-<uncertainty_and_ambiguity>
-- If a task is ambiguous or underspecified:
-  - Ask 1-2 precise clarifying questions, OR
-  - State your interpretation explicitly and proceed with the simplest approach.
-- Never fabricate file paths, requirements, or behavior.
-- Prefer language like "Based on the request..." instead of absolute claims.
-</uncertainty_and_ambiguity>
+When blocked: try a different approach \u2192 decompose the problem \u2192 challenge assumptions \u2192 explore how others solved it.
+
+### Do NOT Ask \u2014 Just Do
+
+**FORBIDDEN:**
+- "Should I proceed with X?" \u2192 JUST DO IT.
+- "Do you want me to run tests?" \u2192 RUN THEM.
+- "I noticed Y, should I fix it?" \u2192 FIX IT OR NOTE IN FINAL MESSAGE.
+- Stopping after partial implementation \u2192 100% OR NOTHING.
+
+**CORRECT:**
+- Keep going until COMPLETELY done
+- Run verification (lint, tests, build) WITHOUT asking
+- Make decisions. Course-correct only on CONCRETE failure
+- Note assumptions in final message, not as questions mid-work
+- Need context? Fire explore/librarian via call_omo_agent IMMEDIATELY \u2014 keep working while they search
+
+## Scope Discipline
+
+- Implement EXACTLY and ONLY what is requested
+- No extra features, no UX embellishments, no scope creep
+- If ambiguous, choose the simplest valid interpretation OR ask ONE precise question
+- Do NOT invent new requirements or expand task boundaries
+
+## Ambiguity Protocol (EXPLORE FIRST)
+
+| Situation | Action |
+|-----------|--------|
+| Single valid interpretation | Proceed immediately |
+| Missing info that MIGHT exist | **EXPLORE FIRST** \u2014 use tools (grep, rg, file reads, explore agents) to find it |
+| Multiple plausible interpretations | State your interpretation, proceed with simplest approach |
+| Truly impossible to proceed | Ask ONE precise question (LAST RESORT) |
 
 <tool_usage_rules>
-- ALWAYS use tools over internal knowledge for:
-  - File contents (use Read, not memory)
-  - Current project state (use lsp_diagnostics, glob)
-  - Verification (use Bash for tests/build)
-- Parallelize independent tool calls when possible.
+- Parallelize independent tool calls: multiple file reads, grep searches, agent fires \u2014 all at once
+- Explore/Librarian via call_omo_agent = background research. Fire them and keep working
+- After any file edit: restate what changed, where, and what validation follows
+- Prefer tools over guessing whenever you need specific data (files, configs, patterns)
+- ALWAYS use tools over internal knowledge for file contents, project state, and verification
 </tool_usage_rules>
 
 ${taskDiscipline}
 
-<verification_spec>
-Task NOT complete without evidence:
+## Progress Updates
+
+**Report progress proactively \u2014 the user should always know what you're doing and why.**
+
+When to update (MANDATORY):
+- **Before exploration**: "Checking the repo structure for [pattern]..."
+- **After discovery**: "Found the config in \`src/config/\`. The pattern uses factory functions."
+- **Before large edits**: "About to modify [files] \u2014 [what and why]."
+- **After edits**: "Updated [file] \u2014 [what changed]. Running verification."
+- **On blockers**: "Hit a snag with [issue] \u2014 trying [alternative] instead."
+
+Style:
+- A few sentences, friendly and concrete \u2014 explain in plain language so anyone can follow
+- Include at least one specific detail (file path, pattern found, decision made)
+- When explaining technical decisions, explain the WHY \u2014 not just what you did
+
+## Code Quality & Verification
+
+### Before Writing Code (MANDATORY)
+
+1. SEARCH existing codebase for similar patterns/styles
+2. Match naming, indentation, import styles, error handling conventions
+3. Default to ASCII. Add comments only for non-obvious blocks
+
+### After Implementation (MANDATORY \u2014 DO NOT SKIP)
+
+1. **\`lsp_diagnostics\`** on ALL modified files \u2014 zero errors required
+2. **Run related tests** \u2014 pattern: modified \`foo.ts\` \u2192 look for \`foo.test.ts\`
+3. **Run typecheck** if TypeScript project
+4. **Run build** if applicable \u2014 exit code 0 required
+5. **Tell user** what you verified and the results \u2014 keep it clear and helpful
+
 | Check | Tool | Expected |
 |-------|------|----------|
 | Diagnostics | lsp_diagnostics | ZERO errors on changed files |
 | Build | Bash | Exit code 0 (if applicable) |
-| Tracking | ${useTaskSystem ? "TaskUpdate" : "todowrite"} | ${verificationText} |
+| Tracking | ${useTaskSystem ? "task_update" : "todowrite"} | ${verificationText} |
 
 **No evidence = not complete.**
-</verification_spec>
 
-<style_spec>
-- Start immediately. No acknowledgments ("I'll...", "Let me...").
-- Match user's communication style.
-- Dense > verbose.
-- Use structured output (bullets, tables) over prose.
-</style_spec>`;
+## Output Contract
+
+<output_contract>
+**Format:**
+- Default: 3-6 sentences or \u22645 bullets
+- Simple yes/no: \u22642 sentences
+- Complex multi-file: 1 overview paragraph + \u22645 tagged bullets (What, Where, Risks, Next, Open)
+
+**Style:**
+- Start work immediately. Skip empty preambles ("I'm on it", "Let me...") \u2014 but DO send clear context before significant actions
+- Be friendly, clear, and easy to understand \u2014 explain so anyone can follow your reasoning
+- When explaining technical decisions, explain the WHY \u2014 not just the WHAT
+</output_contract>
+
+## Failure Recovery
+
+1. Fix root causes, not symptoms. Re-verify after EVERY attempt.
+2. If first approach fails \u2192 try alternative (different algorithm, pattern, library)
+3. After 3 DIFFERENT approaches fail \u2192 STOP and report what you tried clearly`;
   if (!promptAppend)
     return prompt;
   return prompt + `
 
 ` + resolvePromptAppend(promptAppend);
 }
-function buildGptBlockedActionsSection(useTaskSystem) {
-  if (useTaskSystem) {
-    return `<blocked_actions>
-BLOCKED (will fail if attempted):
-| Tool | Status | Description |
-|------|--------|-------------|
-| task | BLOCKED | Agent delegation tool \u2014 you cannot spawn other agents |
-
-ALLOWED:
-| Tool | Usage |
-|------|-------|
-| call_omo_agent | Spawn explore/librarian for research ONLY |
-| task_create | Create tasks to track your work |
-| task_update | Update task status (in_progress, completed) |
-| task_list | List active tasks |
-| task_get | Get task details by ID |
-
-You work ALONE for implementation. No delegation.
-</blocked_actions>`;
-  }
-  return `<blocked_actions>
-BLOCKED (will fail if attempted):
-| Tool | Status | Description |
-|------|--------|-------------|
-| task | BLOCKED | Agent delegation tool \u2014 you cannot spawn other agents |
-
-ALLOWED:
-| Tool | Usage |
-|------|-------|
-| call_omo_agent | Spawn explore/librarian for research ONLY |
-
-You work ALONE for implementation. No delegation.
-</blocked_actions>`;
-}
 function buildGptTaskDisciplineSection(useTaskSystem) {
   if (useTaskSystem) {
-    return `<task_discipline_spec>
-TASK TRACKING (NON-NEGOTIABLE):
+    return `## Task Discipline (NON-NEGOTIABLE)
+
 | Trigger | Action |
 |---------|--------|
-| 2+ steps | TaskCreate FIRST, atomic breakdown |
-| Starting step | TaskUpdate(status="in_progress") - ONE at a time |
-| Completing step | TaskUpdate(status="completed") IMMEDIATELY |
+| 2+ steps | task_create FIRST, atomic breakdown |
+| Starting step | task_update(status="in_progress") \u2014 ONE at a time |
+| Completing step | task_update(status="completed") IMMEDIATELY |
 | Batching | NEVER batch completions |
 
-No tasks on multi-step work = INCOMPLETE WORK.
-</task_discipline_spec>`;
+No tasks on multi-step work = INCOMPLETE WORK.`;
   }
-  return `<todo_discipline_spec>
-TODO TRACKING (NON-NEGOTIABLE):
+  return `## Todo Discipline (NON-NEGOTIABLE)
+
 | Trigger | Action |
 |---------|--------|
 | 2+ steps | todowrite FIRST, atomic breakdown |
-| Starting step | Mark in_progress - ONE at a time |
+| Starting step | Mark in_progress \u2014 ONE at a time |
 | Completing step | Mark completed IMMEDIATELY |
 | Batching | NEVER batch completions |
 
-No todos on multi-step work = INCOMPLETE WORK.
-</todo_discipline_spec>`;
+No todos on multi-step work = INCOMPLETE WORK.`;
 }
 // src/agents/sisyphus-junior/agent.ts
 var MODE10 = "subagent";
@@ -66911,7 +67823,7 @@ function createSisyphusJuniorAgentWithOverrides(override, systemDefaultModel, us
 }
 createSisyphusJuniorAgentWithOverrides.mode = MODE10;
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync64, readdirSync as readdirSync19, readFileSync as readFileSync42 } from "fs";
+import { existsSync as existsSync64, readdirSync as readdirSync19, readFileSync as readFileSync43 } from "fs";
 import { join as join74, basename as basename7 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
@@ -66937,7 +67849,7 @@ function loadAgentsFromDir(agentsDir, scope) {
     const agentPath = join74(agentsDir, entry.name);
     const agentName = basename7(entry.name, ".md");
     try {
-      const content = readFileSync42(agentPath, "utf-8");
+      const content = readFileSync43(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -67105,6 +68017,10 @@ function buildPlanDemoteConfig(prometheusConfig, planOverride) {
 }
 
 // src/plugin-handlers/agent-config-handler.ts
+function hasConfiguredDefaultAgent(config3) {
+  const defaultAgent = config3.default_agent;
+  return typeof defaultAgent === "string" && defaultAgent.trim().length > 0;
+}
 async function applyAgentConfig(params) {
   const migratedDisabledAgents = (params.pluginConfig.disabled_agents ?? []).map((agent) => {
     return AGENT_NAME_MAP[agent.toLowerCase()] ?? AGENT_NAME_MAP[agent] ?? agent;
@@ -67153,7 +68069,9 @@ async function applyAgentConfig(params) {
   const shouldDemotePlan = plannerEnabled && replacePlan;
   const configAgent = params.config.agent;
   if (isSisyphusEnabled && builtinAgents.sisyphus) {
-    params.config.default_agent = getAgentDisplayName("sisyphus");
+    if (!hasConfiguredDefaultAgent(params.config)) {
+      params.config.default_agent = getAgentDisplayName("sisyphus");
+    }
     const agentConfig = {
       sisyphus: builtinAgents.sisyphus
     };
@@ -67381,7 +68299,7 @@ function remapCommandAgentFields(commands2) {
   }
 }
 // src/features/claude-code-mcp-loader/loader.ts
-import { existsSync as existsSync65, readFileSync as readFileSync43 } from "fs";
+import { existsSync as existsSync65, readFileSync as readFileSync44 } from "fs";
 import { join as join76 } from "path";
 import { homedir as homedir14 } from "os";
 
@@ -67449,7 +68367,7 @@ function getSystemMcpServerNames() {
     if (!existsSync65(path10))
       continue;
     try {
-      const content = readFileSync43(path10, "utf-8");
+      const content = readFileSync44(path10, "utf-8");
       const config3 = JSON.parse(content);
       if (!config3?.mcpServers)
         continue;
@@ -67627,7 +68545,7 @@ init_logger();
 
 // src/features/claude-code-plugin-loader/discovery.ts
 init_logger();
-import { existsSync as existsSync66, readFileSync as readFileSync44 } from "fs";
+import { existsSync as existsSync66, readFileSync as readFileSync45 } from "fs";
 import { homedir as homedir15 } from "os";
 import { join as join77 } from "path";
 function getPluginsBaseDir() {
@@ -67645,7 +68563,7 @@ function loadInstalledPlugins() {
     return null;
   }
   try {
-    const content = readFileSync44(dbPath, "utf-8");
+    const content = readFileSync45(dbPath, "utf-8");
     return JSON.parse(content);
   } catch (error45) {
     log("Failed to load installed plugins database", error45);
@@ -67664,7 +68582,7 @@ function loadClaudeSettings() {
     return null;
   }
   try {
-    const content = readFileSync44(settingsPath, "utf-8");
+    const content = readFileSync45(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch (error45) {
     log("Failed to load Claude settings", error45);
@@ -67677,7 +68595,7 @@ function loadPluginManifest(installPath) {
     return null;
   }
   try {
-    const content = readFileSync44(manifestPath, "utf-8");
+    const content = readFileSync45(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error45) {
     log(`Failed to load plugin manifest from ${manifestPath}`, error45);
@@ -67766,7 +68684,7 @@ function discoverInstalledPlugins(options) {
 }
 
 // src/features/claude-code-plugin-loader/command-loader.ts
-import { existsSync as existsSync67, readdirSync as readdirSync20, readFileSync as readFileSync45 } from "fs";
+import { existsSync as existsSync67, readdirSync as readdirSync20, readFileSync as readFileSync46 } from "fs";
 import { basename as basename9, join as join78 } from "path";
 init_logger();
 function loadPluginCommands(plugins) {
@@ -67782,7 +68700,7 @@ function loadPluginCommands(plugins) {
       const commandName = basename9(entry.name, ".md");
       const namespacedName = `${plugin.name}:${commandName}`;
       try {
-        const content = readFileSync45(commandPath, "utf-8");
+        const content = readFileSync46(commandPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -67813,7 +68731,7 @@ $ARGUMENTS
 }
 
 // src/features/claude-code-plugin-loader/skill-loader.ts
-import { existsSync as existsSync68, readdirSync as readdirSync21, readFileSync as readFileSync46 } from "fs";
+import { existsSync as existsSync68, readdirSync as readdirSync21, readFileSync as readFileSync47 } from "fs";
 import { join as join79 } from "path";
 init_logger();
 function loadPluginSkillsAsCommands(plugins) {
@@ -67833,7 +68751,7 @@ function loadPluginSkillsAsCommands(plugins) {
       if (!existsSync68(skillMdPath))
         continue;
       try {
-        const content = readFileSync46(skillMdPath, "utf-8");
+        const content = readFileSync47(skillMdPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const skillName = data.name || entry.name;
         const namespacedName = `${plugin.name}:${skillName}`;
@@ -67868,7 +68786,7 @@ $ARGUMENTS
 }
 
 // src/features/claude-code-plugin-loader/agent-loader.ts
-import { existsSync as existsSync69, readdirSync as readdirSync22, readFileSync as readFileSync47 } from "fs";
+import { existsSync as existsSync69, readdirSync as readdirSync22, readFileSync as readFileSync48 } from "fs";
 import { basename as basename10, join as join80 } from "path";
 init_logger();
 function parseToolsConfig2(toolsStr) {
@@ -67896,7 +68814,7 @@ function loadPluginAgents(plugins) {
       const agentName = basename10(entry.name, ".md");
       const namespacedName = `${plugin.name}:${agentName}`;
       try {
-        const content = readFileSync47(agentPath, "utf-8");
+        const content = readFileSync48(agentPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const originalDescription = data.description || "";
         const formattedDescription = `(plugin: ${plugin.name}) ${originalDescription}`;
@@ -67983,14 +68901,14 @@ async function loadPluginMcpServers(plugins) {
 
 // src/features/claude-code-plugin-loader/hook-loader.ts
 init_logger();
-import { existsSync as existsSync71, readFileSync as readFileSync48 } from "fs";
+import { existsSync as existsSync71, readFileSync as readFileSync49 } from "fs";
 function loadPluginHooksConfigs(plugins) {
   const configs = [];
   for (const plugin of plugins) {
     if (!plugin.hooksPath || !existsSync71(plugin.hooksPath))
       continue;
     try {
-      const content = readFileSync48(plugin.hooksPath, "utf-8");
+      const content = readFileSync49(plugin.hooksPath, "utf-8");
       let config3 = JSON.parse(content);
       config3 = resolvePluginPaths(config3, plugin.installPath);
       configs.push(config3);
@@ -68182,7 +69100,7 @@ function createConfigHandler(deps) {
 }
 // src/create-managers.ts
 function createManagers(args) {
-  const { ctx, pluginConfig, tmuxConfig, modelCacheState } = args;
+  const { ctx, pluginConfig, tmuxConfig, modelCacheState, backgroundNotificationHookEnabled } = args;
   const tmuxSessionManager = new TmuxSessionManager(ctx, tmuxConfig);
   const backgroundManager = new BackgroundManager(ctx, pluginConfig.background_task, {
     tmuxConfig,
@@ -68208,7 +69126,8 @@ function createManagers(args) {
       tmuxSessionManager.cleanup().catch((error45) => {
         log("[index] tmux cleanup error during shutdown:", error45);
       });
-    }
+    },
+    enableParentSessionNotifications: backgroundNotificationHookEnabled
   });
   initTaskToastManager(ctx.client);
   const skillMcpManager = new SkillMcpManager;
@@ -68310,7 +69229,7 @@ function filterDisabledTools(tools, disabledTools) {
 function createToolRegistry(args) {
   const { ctx, pluginConfig, managers, skillContext, availableCategories } = args;
   const backgroundTools = createBackgroundTools(managers.backgroundManager, ctx.client);
-  const callOmoAgent = createCallOmoAgent(ctx, managers.backgroundManager);
+  const callOmoAgent = createCallOmoAgent(ctx, managers.backgroundManager, pluginConfig.disabled_agents ?? []);
   const isMultimodalLookerEnabled = !(pluginConfig.disabled_agents ?? []).some((agent) => agent.toLowerCase() === "multimodal-looker");
   const lookAt = isMultimodalLookerEnabled ? createLookAt(ctx) : null;
   const delegateTask = createDelegateTask({
@@ -68367,6 +69286,8 @@ function createToolRegistry(args) {
     task_list: createTaskList(pluginConfig),
     task_update: createTaskUpdateTool(pluginConfig, ctx)
   } : {};
+  const hashlineEnabled = pluginConfig.experimental?.hashline_edit ?? false;
+  const hashlineToolsRecord = hashlineEnabled ? { edit: createHashlineEditTool() } : {};
   const allTools = {
     ...builtinTools,
     ...createGrepTools(ctx),
@@ -68381,7 +69302,8 @@ function createToolRegistry(args) {
     skill_mcp: skillMcpTool,
     slashcommand: slashcommandTool,
     interactive_bash,
-    ...taskToolsRecord
+    ...taskToolsRecord,
+    ...hashlineToolsRecord
   };
   const filteredTools = filterDisabledTools(allTools, pluginConfig.disabled_tools);
   return {
@@ -68746,6 +69668,7 @@ function createToolExecuteAfterHandler3(args) {
     await hooks.delegateTaskRetry?.["tool.execute.after"]?.(input, output);
     await hooks.atlasHook?.["tool.execute.after"]?.(input, output);
     await hooks.taskResumeInfo?.["tool.execute.after"]?.(input, output);
+    await hooks.hashlineReadEnhancer?.["tool.execute.after"]?.(input, output);
   };
 }
 
@@ -68987,7 +69910,8 @@ var BackgroundTaskConfigSchema = exports_external.object({
 var BrowserAutomationProviderSchema = exports_external.enum([
   "playwright",
   "agent-browser",
-  "dev-browser"
+  "dev-browser",
+  "playwright-cli"
 ]);
 var BrowserAutomationConfigSchema = exports_external.object({
   provider: BrowserAutomationProviderSchema.default("playwright")
@@ -69086,7 +70010,8 @@ var ExperimentalConfigSchema = exports_external.object({
   dynamic_context_pruning: DynamicContextPruningConfigSchema.optional(),
   task_system: exports_external.boolean().optional(),
   plugin_load_timeout_ms: exports_external.number().min(1000).optional(),
-  safe_hook_creation: exports_external.boolean().optional()
+  safe_hook_creation: exports_external.boolean().optional(),
+  hashline_edit: exports_external.boolean().optional()
 });
 // src/config/schema/git-master.ts
 var GitMasterConfigSchema = exports_external.object({
@@ -69136,7 +70061,8 @@ var HookNameSchema = exports_external.enum([
   "stop-continuation-guard",
   "tasks-todowrite-disabler",
   "write-existing-file-guard",
-  "anthropic-effort"
+  "anthropic-effort",
+  "hashline-read-enhancer"
 ]);
 // src/config/schema/notification.ts
 var NotificationConfigSchema = exports_external.object({
@@ -69434,7 +70360,8 @@ var OhMyOpenCodePlugin = async (ctx) => {
     ctx,
     pluginConfig,
     tmuxConfig,
-    modelCacheState
+    modelCacheState,
+    backgroundNotificationHookEnabled: isHookEnabled("background-notification")
   });
   const toolsResult = await createTools({
     ctx,
@@ -69444,6 +70371,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const hooks2 = createHooks({
     ctx,
     pluginConfig,
+    modelCacheState,
     backgroundManager: managers.backgroundManager,
     isHookEnabled,
     safeHookEnabled,
@@ -69462,10 +70390,10 @@ var OhMyOpenCodePlugin = async (ctx) => {
     ...pluginInterface,
     "experimental.session.compacting": async (_input, output) => {
       await hooks2.compactionTodoPreserver?.capture(_input.sessionID);
-      if (!hooks2.compactionContextInjector) {
-        return;
+      await hooks2.claudeCodeHooks?.["experimental.session.compacting"]?.(_input, output);
+      if (hooks2.compactionContextInjector) {
+        output.context.push(hooks2.compactionContextInjector(_input.sessionID));
       }
-      output.context.push(hooks2.compactionContextInjector(_input.sessionID));
     }
   };
 };