oh-my-opencode 2.5.3 → 2.5.4

package/dist/index.js

@@ -3216,7 +3216,7 @@ async function getContextWindowUsage(ctx, sessionID) {
       return null;
     const lastAssistant = assistantMessages[assistantMessages.length - 1];
     const lastTokens = lastAssistant.tokens;
-    const usedTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0);
+    const usedTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0) + (lastTokens?.output ?? 0);
     const remainingTokens = ANTHROPIC_ACTUAL_LIMIT - usedTokens;
     return {
       usedTokens,
@@ -3663,6 +3663,24 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
           errorSessions.delete(sessionID);
           return;
         }
+        let freshTodos = [];
+        try {
+          log(`[${HOOK_NAME}] Re-verifying todos after countdown`, { sessionID });
+          const response = await ctx.client.session.todo({
+            path: { id: sessionID }
+          });
+          freshTodos = response.data ?? response;
+          log(`[${HOOK_NAME}] Fresh todo count`, { sessionID, todosCount: freshTodos?.length ?? 0 });
+        } catch (err) {
+          log(`[${HOOK_NAME}] Failed to re-verify todos`, { sessionID, error: String(err) });
+          return;
+        }
+        const freshIncomplete = freshTodos.filter((t) => t.status !== "completed" && t.status !== "cancelled");
+        if (freshIncomplete.length === 0) {
+          log(`[${HOOK_NAME}] Abort: no incomplete todos after countdown`, { sessionID, total: freshTodos.length });
+          return;
+        }
+        log(`[${HOOK_NAME}] Confirmed incomplete todos, proceeding with injection`, { sessionID, incomplete: freshIncomplete.length, total: freshTodos.length });
         remindedSessions.add(sessionID);
         try {
           const messageDir = getMessageDir(sessionID);
@@ -3683,7 +3701,7 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
                   type: "text",
                   text: `${CONTINUATION_PROMPT}
 
-[Status: ${todos.length - incomplete.length}/${todos.length} completed, ${incomplete.length} remaining]`
+[Status: ${freshTodos.length - freshIncomplete.length}/${freshTodos.length} completed, ${freshIncomplete.length} remaining]`
                 }
               ]
             },
@@ -5082,6 +5100,7 @@ function clearInjectedPaths(sessionID) {
 function createDirectoryAgentsInjectorHook(ctx) {
   const sessionCaches = new Map;
   const pendingBatchReads = new Map;
+  const truncator = createDynamicTruncator(ctx);
   function getSessionCache(sessionID) {
     if (!sessionCaches.has(sessionID)) {
       sessionCaches.set(sessionID, loadInjectedPaths(sessionID));
@@ -5114,7 +5133,7 @@ function createDirectoryAgentsInjectorHook(ctx) {
     }
     return found.reverse();
   }
-  function processFilePathForInjection(filePath, sessionID, output) {
+  async function processFilePathForInjection(filePath, sessionID, output) {
     const resolved = resolveFilePath2(filePath);
     if (!resolved)
       return;
@@ -5127,10 +5146,14 @@ function createDirectoryAgentsInjectorHook(ctx) {
         continue;
       try {
         const content = readFileSync5(agentsPath, "utf-8");
+        const { result, truncated } = await truncator.truncate(sessionID, content);
+        const truncationNotice = truncated ? `
+
+[Note: Content was truncated to save context window space. For full context, please read the file directly: ${agentsPath}]` : "";
         output.output += `
 
 [Directory Context: ${agentsPath}]
-${content}`;
+${result}${truncationNotice}`;
         cache.add(agentsDir);
       } catch {}
     }
@@ -5155,14 +5178,14 @@ ${content}`;
   const toolExecuteAfter = async (input, output) => {
     const toolName = input.tool.toLowerCase();
     if (toolName === "read") {
-      processFilePathForInjection(output.title, input.sessionID, output);
+      await processFilePathForInjection(output.title, input.sessionID, output);
       return;
     }
     if (toolName === "batch") {
       const filePaths = pendingBatchReads.get(input.callID);
       if (filePaths) {
         for (const filePath of filePaths) {
-          processFilePathForInjection(filePath, input.sessionID, output);
+          await processFilePathForInjection(filePath, input.sessionID, output);
         }
         pendingBatchReads.delete(input.callID);
       }
@@ -5249,6 +5272,7 @@ function clearInjectedPaths2(sessionID) {
 function createDirectoryReadmeInjectorHook(ctx) {
   const sessionCaches = new Map;
   const pendingBatchReads = new Map;
+  const truncator = createDynamicTruncator(ctx);
   function getSessionCache(sessionID) {
     if (!sessionCaches.has(sessionID)) {
       sessionCaches.set(sessionID, loadInjectedPaths2(sessionID));
@@ -5281,7 +5305,7 @@ function createDirectoryReadmeInjectorHook(ctx) {
     }
     return found.reverse();
   }
-  function processFilePathForInjection(filePath, sessionID, output) {
+  async function processFilePathForInjection(filePath, sessionID, output) {
     const resolved = resolveFilePath2(filePath);
     if (!resolved)
       return;
@@ -5294,10 +5318,14 @@ function createDirectoryReadmeInjectorHook(ctx) {
         continue;
       try {
         const content = readFileSync7(readmePath, "utf-8");
+        const { result, truncated } = await truncator.truncate(sessionID, content);
+        const truncationNotice = truncated ? `
+
+[Note: Content was truncated to save context window space. For full context, please read the file directly: ${readmePath}]` : "";
         output.output += `
 
 [Project README: ${readmePath}]
-${content}`;
+${result}${truncationNotice}`;
         cache.add(readmeDir);
       } catch {}
     }
@@ -5322,14 +5350,14 @@ ${content}`;
   const toolExecuteAfter = async (input, output) => {
     const toolName = input.tool.toLowerCase();
     if (toolName === "read") {
-      processFilePathForInjection(output.title, input.sessionID, output);
+      await processFilePathForInjection(output.title, input.sessionID, output);
       return;
     }
     if (toolName === "batch") {
       const filePaths = pendingBatchReads.get(input.callID);
       if (filePaths) {
         for (const filePath of filePaths) {
-          processFilePathForInjection(filePath, input.sessionID, output);
+          await processFilePathForInjection(filePath, input.sessionID, output);
         }
         pendingBatchReads.delete(input.callID);
       }
@@ -5875,244 +5903,250 @@ async function fixEmptyMessages(sessionID, autoCompactState, client, messageInde
 }
 async function executeCompact(sessionID, msg, autoCompactState, client, directory, experimental) {
   if (autoCompactState.compactionInProgress.has(sessionID)) {
+    await client.tui.showToast({
+      body: {
+        title: "Compact In Progress",
+        message: "Recovery already running. Please wait or start new session if stuck.",
+        variant: "warning",
+        duration: 5000
+      }
+    }).catch(() => {});
     return;
   }
   autoCompactState.compactionInProgress.add(sessionID);
-  const errorData = autoCompactState.errorDataBySession.get(sessionID);
-  const truncateState = getOrCreateTruncateState(autoCompactState, sessionID);
-  if (experimental?.aggressive_truncation && errorData?.currentTokens && errorData?.maxTokens && errorData.currentTokens > errorData.maxTokens && truncateState.truncateAttempt < TRUNCATE_CONFIG.maxTruncateAttempts) {
-    log("[auto-compact] aggressive truncation triggered (experimental)", {
-      currentTokens: errorData.currentTokens,
-      maxTokens: errorData.maxTokens,
-      targetRatio: TRUNCATE_CONFIG.targetTokenRatio
-    });
-    const aggressiveResult = truncateUntilTargetTokens(sessionID, errorData.currentTokens, errorData.maxTokens, TRUNCATE_CONFIG.targetTokenRatio, TRUNCATE_CONFIG.charsPerToken);
-    if (aggressiveResult.truncatedCount > 0) {
-      truncateState.truncateAttempt += aggressiveResult.truncatedCount;
-      const toolNames = aggressiveResult.truncatedTools.map((t) => t.toolName).join(", ");
-      const statusMsg = aggressiveResult.sufficient ? `Truncated ${aggressiveResult.truncatedCount} outputs (${formatBytes(aggressiveResult.totalBytesRemoved)})` : `Truncated ${aggressiveResult.truncatedCount} outputs (${formatBytes(aggressiveResult.totalBytesRemoved)}) but need ${formatBytes(aggressiveResult.targetBytesToRemove)}. Falling back to summarize/revert...`;
-      await client.tui.showToast({
-        body: {
-          title: aggressiveResult.sufficient ? "Aggressive Truncation" : "Partial Truncation",
-          message: `${statusMsg}: ${toolNames}`,
-          variant: "warning",
-          duration: 4000
-        }
-      }).catch(() => {});
-      log("[auto-compact] aggressive truncation completed", aggressiveResult);
-      if (aggressiveResult.sufficient) {
-        autoCompactState.compactionInProgress.delete(sessionID);
-        setTimeout(async () => {
-          try {
-            await client.session.prompt_async({
-              path: { sessionID },
-              body: { parts: [{ type: "text", text: "Continue" }] },
-              query: { directory }
-            });
-          } catch {}
-        }, 500);
-        return;
-      }
-    } else {
-      await client.tui.showToast({
-        body: {
-          title: "Truncation Skipped",
-          message: "No tool outputs found to truncate.",
-          variant: "warning",
-          duration: 3000
+  try {
+    const errorData = autoCompactState.errorDataBySession.get(sessionID);
+    const truncateState = getOrCreateTruncateState(autoCompactState, sessionID);
+    if (experimental?.aggressive_truncation && errorData?.currentTokens && errorData?.maxTokens && errorData.currentTokens > errorData.maxTokens && truncateState.truncateAttempt < TRUNCATE_CONFIG.maxTruncateAttempts) {
+      log("[auto-compact] aggressive truncation triggered (experimental)", {
+        currentTokens: errorData.currentTokens,
+        maxTokens: errorData.maxTokens,
+        targetRatio: TRUNCATE_CONFIG.targetTokenRatio
+      });
+      const aggressiveResult = truncateUntilTargetTokens(sessionID, errorData.currentTokens, errorData.maxTokens, TRUNCATE_CONFIG.targetTokenRatio, TRUNCATE_CONFIG.charsPerToken);
+      if (aggressiveResult.truncatedCount > 0) {
+        truncateState.truncateAttempt += aggressiveResult.truncatedCount;
+        const toolNames = aggressiveResult.truncatedTools.map((t) => t.toolName).join(", ");
+        const statusMsg = aggressiveResult.sufficient ? `Truncated ${aggressiveResult.truncatedCount} outputs (${formatBytes(aggressiveResult.totalBytesRemoved)})` : `Truncated ${aggressiveResult.truncatedCount} outputs (${formatBytes(aggressiveResult.totalBytesRemoved)}) but need ${formatBytes(aggressiveResult.targetBytesToRemove)}. Falling back to summarize/revert...`;
+        await client.tui.showToast({
+          body: {
+            title: aggressiveResult.sufficient ? "Aggressive Truncation" : "Partial Truncation",
+            message: `${statusMsg}: ${toolNames}`,
+            variant: "warning",
+            duration: 4000
+          }
+        }).catch(() => {});
+        log("[auto-compact] aggressive truncation completed", aggressiveResult);
+        if (aggressiveResult.sufficient) {
+          setTimeout(async () => {
+            try {
+              await client.session.prompt_async({
+                path: { sessionID },
+                body: { parts: [{ type: "text", text: "Continue" }] },
+                query: { directory }
+              });
+            } catch {}
+          }, 500);
+          return;
         }
-      }).catch(() => {});
-    }
-  }
-  let skipSummarize = false;
-  if (truncateState.truncateAttempt < TRUNCATE_CONFIG.maxTruncateAttempts) {
-    const largest = findLargestToolResult(sessionID);
-    if (largest && largest.outputSize >= TRUNCATE_CONFIG.minOutputSizeToTruncate) {
-      const result = truncateToolResult(largest.partPath);
-      if (result.success) {
-        truncateState.truncateAttempt++;
-        truncateState.lastTruncatedPartId = largest.partId;
+      } else {
         await client.tui.showToast({
           body: {
-            title: "Truncating Large Output",
-            message: `Truncated ${result.toolName} (${formatBytes(result.originalSize ?? 0)}). Retrying...`,
+            title: "Truncation Skipped",
+            message: "No tool outputs found to truncate.",
             variant: "warning",
             duration: 3000
           }
         }).catch(() => {});
-        autoCompactState.compactionInProgress.delete(sessionID);
-        setTimeout(async () => {
-          try {
-            await client.session.prompt_async({
-              path: { sessionID },
-              body: { parts: [{ type: "text", text: "Continue" }] },
-              query: { directory }
-            });
-          } catch {}
-        }, 500);
-        return;
       }
-    } else if (errorData?.currentTokens && errorData?.maxTokens && errorData.currentTokens > errorData.maxTokens) {
-      skipSummarize = true;
-      await client.tui.showToast({
-        body: {
-          title: "Summarize Skipped",
-          message: `Over token limit (${errorData.currentTokens}/${errorData.maxTokens}) with nothing to truncate. Going to revert...`,
-          variant: "warning",
-          duration: 3000
-        }
-      }).catch(() => {});
-    } else if (!errorData?.currentTokens) {
-      await client.tui.showToast({
-        body: {
-          title: "Truncation Skipped",
-          message: "No large tool outputs found.",
-          variant: "warning",
-          duration: 3000
-        }
-      }).catch(() => {});
     }
-  }
-  const retryState = getOrCreateRetryState(autoCompactState, sessionID);
-  if (errorData?.errorType?.includes("non-empty content")) {
-    const attempt = getOrCreateEmptyContentAttempt(autoCompactState, sessionID);
-    if (attempt < 3) {
-      const fixed = await fixEmptyMessages(sessionID, autoCompactState, client, errorData.messageIndex);
-      if (fixed) {
-        autoCompactState.compactionInProgress.delete(sessionID);
-        setTimeout(() => {
-          executeCompact(sessionID, msg, autoCompactState, client, directory, experimental);
-        }, 500);
-        return;
-      }
-    } else {
-      await client.tui.showToast({
-        body: {
-          title: "Recovery Failed",
-          message: "Max recovery attempts (3) reached for empty content error. Please start a new session.",
-          variant: "error",
-          duration: 1e4
+    let skipSummarize = false;
+    if (truncateState.truncateAttempt < TRUNCATE_CONFIG.maxTruncateAttempts) {
+      const largest = findLargestToolResult(sessionID);
+      if (largest && largest.outputSize >= TRUNCATE_CONFIG.minOutputSizeToTruncate) {
+        const result = truncateToolResult(largest.partPath);
+        if (result.success) {
+          truncateState.truncateAttempt++;
+          truncateState.lastTruncatedPartId = largest.partId;
+          await client.tui.showToast({
+            body: {
+              title: "Truncating Large Output",
+              message: `Truncated ${result.toolName} (${formatBytes(result.originalSize ?? 0)}). Retrying...`,
+              variant: "warning",
+              duration: 3000
+            }
+          }).catch(() => {});
+          setTimeout(async () => {
+            try {
+              await client.session.prompt_async({
+                path: { sessionID },
+                body: { parts: [{ type: "text", text: "Continue" }] },
+                query: { directory }
+              });
+            } catch {}
+          }, 500);
+          return;
         }
-      }).catch(() => {});
-      autoCompactState.compactionInProgress.delete(sessionID);
-      return;
-    }
-  }
-  if (Date.now() - retryState.lastAttemptTime > 300000) {
-    retryState.attempt = 0;
-    autoCompactState.fallbackStateBySession.delete(sessionID);
-    autoCompactState.truncateStateBySession.delete(sessionID);
-  }
-  if (!skipSummarize && retryState.attempt < RETRY_CONFIG.maxAttempts) {
-    retryState.attempt++;
-    retryState.lastAttemptTime = Date.now();
-    const providerID = msg.providerID;
-    const modelID = msg.modelID;
-    if (providerID && modelID) {
-      try {
+      } else if (errorData?.currentTokens && errorData?.maxTokens && errorData.currentTokens > errorData.maxTokens) {
+        skipSummarize = true;
         await client.tui.showToast({
           body: {
-            title: "Auto Compact",
-            message: `Summarizing session (attempt ${retryState.attempt}/${RETRY_CONFIG.maxAttempts})...`,
+            title: "Summarize Skipped",
+            message: `Over token limit (${errorData.currentTokens}/${errorData.maxTokens}) with nothing to truncate. Going to revert...`,
+            variant: "warning",
+            duration: 3000
+          }
+        }).catch(() => {});
+      } else if (!errorData?.currentTokens) {
+        await client.tui.showToast({
+          body: {
+            title: "Truncation Skipped",
+            message: "No large tool outputs found.",
             variant: "warning",
             duration: 3000
           }
         }).catch(() => {});
-        await client.session.summarize({
-          path: { id: sessionID },
-          body: { providerID, modelID },
-          query: { directory }
-        });
-        autoCompactState.compactionInProgress.delete(sessionID);
-        setTimeout(async () => {
-          try {
-            await client.session.prompt_async({
-              path: { sessionID },
-              body: { parts: [{ type: "text", text: "Continue" }] },
-              query: { directory }
-            });
-          } catch {}
-        }, 500);
-        return;
-      } catch {
-        autoCompactState.compactionInProgress.delete(sessionID);
-        const delay = RETRY_CONFIG.initialDelayMs * Math.pow(RETRY_CONFIG.backoffFactor, retryState.attempt - 1);
-        const cappedDelay = Math.min(delay, RETRY_CONFIG.maxDelayMs);
-        setTimeout(() => {
-          executeCompact(sessionID, msg, autoCompactState, client, directory, experimental);
-        }, cappedDelay);
-        return;
       }
-    } else {
-      await client.tui.showToast({
-        body: {
-          title: "Summarize Skipped",
-          message: "Missing providerID or modelID. Skipping to revert...",
-          variant: "warning",
-          duration: 3000
+    }
+    const retryState = getOrCreateRetryState(autoCompactState, sessionID);
+    if (errorData?.errorType?.includes("non-empty content")) {
+      const attempt = getOrCreateEmptyContentAttempt(autoCompactState, sessionID);
+      if (attempt < 3) {
+        const fixed = await fixEmptyMessages(sessionID, autoCompactState, client, errorData.messageIndex);
+        if (fixed) {
+          setTimeout(() => {
+            executeCompact(sessionID, msg, autoCompactState, client, directory, experimental);
+          }, 500);
+          return;
         }
-      }).catch(() => {});
+      } else {
+        await client.tui.showToast({
+          body: {
+            title: "Recovery Failed",
+            message: "Max recovery attempts (3) reached for empty content error. Please start a new session.",
+            variant: "error",
+            duration: 1e4
+          }
+        }).catch(() => {});
+        return;
+      }
     }
-  }
-  const fallbackState = getOrCreateFallbackState(autoCompactState, sessionID);
-  if (fallbackState.revertAttempt < FALLBACK_CONFIG.maxRevertAttempts) {
-    const pair = await getLastMessagePair(sessionID, client, directory);
-    if (pair) {
-      try {
+    if (Date.now() - retryState.lastAttemptTime > 300000) {
+      retryState.attempt = 0;
+      autoCompactState.fallbackStateBySession.delete(sessionID);
+      autoCompactState.truncateStateBySession.delete(sessionID);
+    }
+    if (!skipSummarize && retryState.attempt < RETRY_CONFIG.maxAttempts) {
+      retryState.attempt++;
+      retryState.lastAttemptTime = Date.now();
+      const providerID = msg.providerID;
+      const modelID = msg.modelID;
+      if (providerID && modelID) {
+        try {
+          await client.tui.showToast({
+            body: {
+              title: "Auto Compact",
+              message: `Summarizing session (attempt ${retryState.attempt}/${RETRY_CONFIG.maxAttempts})...`,
+              variant: "warning",
+              duration: 3000
+            }
+          }).catch(() => {});
+          await client.session.summarize({
+            path: { id: sessionID },
+            body: { providerID, modelID },
+            query: { directory }
+          });
+          setTimeout(async () => {
+            try {
+              await client.session.prompt_async({
+                path: { sessionID },
+                body: { parts: [{ type: "text", text: "Continue" }] },
+                query: { directory }
+              });
+            } catch {}
+          }, 500);
+          return;
+        } catch {
+          const delay = RETRY_CONFIG.initialDelayMs * Math.pow(RETRY_CONFIG.backoffFactor, retryState.attempt - 1);
+          const cappedDelay = Math.min(delay, RETRY_CONFIG.maxDelayMs);
+          setTimeout(() => {
+            executeCompact(sessionID, msg, autoCompactState, client, directory, experimental);
+          }, cappedDelay);
+          return;
+        }
+      } else {
         await client.tui.showToast({
           body: {
-            title: "Emergency Recovery",
-            message: "Removing last message pair...",
+            title: "Summarize Skipped",
+            message: "Missing providerID or modelID. Skipping to revert...",
             variant: "warning",
             duration: 3000
           }
         }).catch(() => {});
-        if (pair.assistantMessageID) {
+      }
+    }
+    const fallbackState = getOrCreateFallbackState(autoCompactState, sessionID);
+    if (fallbackState.revertAttempt < FALLBACK_CONFIG.maxRevertAttempts) {
+      const pair = await getLastMessagePair(sessionID, client, directory);
+      if (pair) {
+        try {
+          await client.tui.showToast({
+            body: {
+              title: "Emergency Recovery",
+              message: "Removing last message pair...",
+              variant: "warning",
+              duration: 3000
+            }
+          }).catch(() => {});
+          if (pair.assistantMessageID) {
+            await client.session.revert({
+              path: { id: sessionID },
+              body: { messageID: pair.assistantMessageID },
+              query: { directory }
+            });
+          }
           await client.session.revert({
             path: { id: sessionID },
-            body: { messageID: pair.assistantMessageID },
+            body: { messageID: pair.userMessageID },
             query: { directory }
           });
-        }
-        await client.session.revert({
-          path: { id: sessionID },
-          body: { messageID: pair.userMessageID },
-          query: { directory }
-        });
-        fallbackState.revertAttempt++;
-        fallbackState.lastRevertedMessageID = pair.userMessageID;
-        clearSessionState(autoCompactState, sessionID);
-        setTimeout(async () => {
-          try {
-            await client.session.prompt_async({
-              path: { sessionID },
-              body: { parts: [{ type: "text", text: "Continue" }] },
-              query: { directory }
-            });
-          } catch {}
-        }, 500);
-        return;
-      } catch {}
-    } else {
-      await client.tui.showToast({
-        body: {
-          title: "Revert Skipped",
-          message: "Could not find last message pair to revert.",
-          variant: "warning",
-          duration: 3000
-        }
-      }).catch(() => {});
+          fallbackState.revertAttempt++;
+          fallbackState.lastRevertedMessageID = pair.userMessageID;
+          clearSessionState(autoCompactState, sessionID);
+          setTimeout(async () => {
+            try {
+              await client.session.prompt_async({
+                path: { sessionID },
+                body: { parts: [{ type: "text", text: "Continue" }] },
+                query: { directory }
+              });
+            } catch {}
+          }, 500);
+          return;
+        } catch {}
+      } else {
+        await client.tui.showToast({
+          body: {
+            title: "Revert Skipped",
+            message: "Could not find last message pair to revert.",
+            variant: "warning",
+            duration: 3000
+          }
+        }).catch(() => {});
+      }
     }
+    clearSessionState(autoCompactState, sessionID);
+    await client.tui.showToast({
+      body: {
+        title: "Auto Compact Failed",
+        message: "All recovery attempts failed. Please start a new session.",
+        variant: "error",
+        duration: 5000
+      }
+    }).catch(() => {});
+  } finally {
+    autoCompactState.compactionInProgress.delete(sessionID);
   }
-  clearSessionState(autoCompactState, sessionID);
-  await client.tui.showToast({
-    body: {
-      title: "Auto Compact Failed",
-      message: "All recovery attempts failed. Please start a new session.",
-      variant: "error",
-      duration: 5000
-    }
-  }).catch(() => {});
 }
 
 // src/hooks/anthropic-auto-compact/index.ts
@@ -8094,6 +8128,7 @@ var TRACKED_TOOLS = ["read", "write", "edit", "multiedit"];
 function createRulesInjectorHook(ctx) {
   const sessionCaches = new Map;
   const pendingBatchFiles = new Map;
+  const truncator = createDynamicTruncator(ctx);
   function getSessionCache(sessionID) {
     if (!sessionCaches.has(sessionID)) {
       sessionCaches.set(sessionID, loadInjectedRules(sessionID));
@@ -8107,7 +8142,7 @@ function createRulesInjectorHook(ctx) {
       return path5;
     return resolve4(ctx.directory, path5);
   }
-  function processFilePathForInjection(filePath, sessionID, output) {
+  async function processFilePathForInjection(filePath, sessionID, output) {
     const resolved = resolveFilePath2(filePath);
     if (!resolved)
       return;
@@ -8143,11 +8178,15 @@ function createRulesInjectorHook(ctx) {
       return;
     toInject.sort((a, b) => a.distance - b.distance);
     for (const rule of toInject) {
+      const { result, truncated } = await truncator.truncate(sessionID, rule.content);
+      const truncationNotice = truncated ? `
+
+[Note: Content was truncated to save context window space. For full context, please read the file directly: ${rule.relativePath}]` : "";
       output.output += `
 
 [Rule: ${rule.relativePath}]
 [Match: ${rule.matchReason}]
-${rule.content}`;
+${result}${truncationNotice}`;
     }
     saveInjectedRules(sessionID, cache2);
   }
@@ -8177,14 +8216,14 @@ ${rule.content}`;
   const toolExecuteAfter = async (input, output) => {
     const toolName = input.tool.toLowerCase();
     if (TRACKED_TOOLS.includes(toolName)) {
-      processFilePathForInjection(output.title, input.sessionID, output);
+      await processFilePathForInjection(output.title, input.sessionID, output);
       return;
     }
     if (toolName === "batch") {
       const filePaths = pendingBatchFiles.get(input.callID);
       if (filePaths) {
         for (const filePath of filePaths) {
-          processFilePathForInjection(filePath, input.sessionID, output);
+          await processFilePathForInjection(filePath, input.sessionID, output);
         }
         pendingBatchFiles.delete(input.callID);
       }
@@ -8836,6 +8875,7 @@ TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
 
 ## ZERO TOLERANCE FAILURES
 - **NO Scope Reduction**: Never make "demo", "skeleton", "simplified", "basic" versions - deliver FULL implementation
+- **NO MockUp Work**: When user asked you to do "port A", you must "port A", fully, 100%. No Extra feature, No reduced feature, no mock data, fully working 100% port.
 - **NO Partial Completion**: Never stop at 60-80% saying "you can extend this..." - finish 100%
 - **NO Assumed Shortcuts**: Never skip requirements you deem "optional" or "can be added later"
 - **NO Premature Stopping**: Never declare done until ALL TODOs are completed and verified
@@ -27085,6 +27125,10 @@ var interactive_bash = tool({
     }
   }
 });
+// src/tools/background-task/tools.ts
+import { existsSync as existsSync38, readdirSync as readdirSync13 } from "fs";
+import { join as join47 } from "path";
+
 // src/tools/background-task/constants.ts
 var BACKGROUND_TASK_DESCRIPTION = `Run agent task in background. Returns task_id immediately; notifies on completion.
 
@@ -27093,6 +27137,19 @@ var BACKGROUND_OUTPUT_DESCRIPTION = `Get output from background task. System not
 var BACKGROUND_CANCEL_DESCRIPTION = `Cancel running background task(s). Use all=true to cancel ALL before final answer.`;
 
 // src/tools/background-task/tools.ts
+function getMessageDir6(sessionID) {
+  if (!existsSync38(MESSAGE_STORAGE))
+    return null;
+  const directPath = join47(MESSAGE_STORAGE, sessionID);
+  if (existsSync38(directPath))
+    return directPath;
+  for (const dir of readdirSync13(MESSAGE_STORAGE)) {
+    const sessionPath = join47(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync38(sessionPath))
+      return sessionPath;
+  }
+  return null;
+}
 function formatDuration(start, end) {
   const duration3 = (end ?? new Date).getTime() - start.getTime();
   const seconds = Math.floor(duration3 / 1000);
@@ -27119,12 +27176,16 @@ function createBackgroundTask(manager) {
         return `\u274C Agent parameter is required. Please specify which agent to use (e.g., "explore", "librarian", "build", etc.)`;
       }
       try {
+        const messageDir = getMessageDir6(toolContext.sessionID);
+        const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
+        const parentModel = prevMessage?.model?.providerID && prevMessage?.model?.modelID ? { providerID: prevMessage.model.providerID, modelID: prevMessage.model.modelID } : undefined;
         const task = await manager.launch({
           description: args.description,
           prompt: args.prompt,
           agent: args.agent.trim(),
           parentSessionID: toolContext.sessionID,
-          parentMessageID: toolContext.messageID
+          parentMessageID: toolContext.messageID,
+          parentModel
         });
         return `Background task launched successfully.
 
@@ -27641,17 +27702,17 @@ var builtinTools = {
   session_info
 };
 // src/features/background-agent/manager.ts
-import { existsSync as existsSync38, readdirSync as readdirSync13 } from "fs";
-import { join as join47 } from "path";
-function getMessageDir6(sessionID) {
-  if (!existsSync38(MESSAGE_STORAGE))
+import { existsSync as existsSync39, readdirSync as readdirSync14 } from "fs";
+import { join as join48 } from "path";
+function getMessageDir7(sessionID) {
+  if (!existsSync39(MESSAGE_STORAGE))
     return null;
-  const directPath = join47(MESSAGE_STORAGE, sessionID);
-  if (existsSync38(directPath))
+  const directPath = join48(MESSAGE_STORAGE, sessionID);
+  if (existsSync39(directPath))
     return directPath;
-  for (const dir of readdirSync13(MESSAGE_STORAGE)) {
-    const sessionPath = join47(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync38(sessionPath))
+  for (const dir of readdirSync14(MESSAGE_STORAGE)) {
+    const sessionPath = join48(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync39(sessionPath))
       return sessionPath;
   }
   return null;
@@ -27697,7 +27758,8 @@ class BackgroundManager {
       progress: {
         toolCalls: 0,
         lastUpdate: new Date
-      }
+      },
+      parentModel: input.parentModel
     };
     this.tasks.set(task.id, task);
     this.startPolling();
@@ -27887,12 +27949,15 @@ class BackgroundManager {
     log("[background-agent] Sending notification to parent session:", { parentSessionID: task.parentSessionID });
     setTimeout(async () => {
       try {
-        const messageDir = getMessageDir6(task.parentSessionID);
+        const messageDir = getMessageDir7(task.parentSessionID);
         const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
+        const modelContext = task.parentModel ?? prevMessage?.model;
+        const modelField = modelContext?.providerID && modelContext?.modelID ? { providerID: modelContext.providerID, modelID: modelContext.modelID } : undefined;
         await this.client.session.prompt({
           path: { id: task.parentSessionID },
           body: {
             agent: prevMessage?.agent,
+            model: modelField,
             parts: [{ type: "text", text: message }]
           },
           query: { directory: this.directory }
@@ -28055,7 +28120,7 @@ var OverridableAgentNameSchema = exports_external.enum([
   "build",
   "plan",
   "Sisyphus",
-  "Builder-Sisyphus",
+  "OpenCode-Builder",
   "Planner-Sisyphus",
   "oracle",
   "librarian",
@@ -28104,7 +28169,7 @@ var AgentOverridesSchema = exports_external.object({
   build: AgentOverrideConfigSchema.optional(),
   plan: AgentOverrideConfigSchema.optional(),
   Sisyphus: AgentOverrideConfigSchema.optional(),
-  "Builder-Sisyphus": AgentOverrideConfigSchema.optional(),
+  "OpenCode-Builder": AgentOverrideConfigSchema.optional(),
   "Planner-Sisyphus": AgentOverrideConfigSchema.optional(),
   oracle: AgentOverrideConfigSchema.optional(),
   librarian: AgentOverrideConfigSchema.optional(),
@@ -28122,9 +28187,8 @@ var ClaudeCodeConfigSchema = exports_external.object({
 });
 var SisyphusAgentConfigSchema = exports_external.object({
   disabled: exports_external.boolean().optional(),
-  builder_enabled: exports_external.boolean().optional(),
+  default_builder_enabled: exports_external.boolean().optional(),
   planner_enabled: exports_external.boolean().optional(),
-  replace_build: exports_external.boolean().optional(),
   replace_plan: exports_external.boolean().optional()
 });
 var ExperimentalConfigSchema = exports_external.object({
@@ -28217,50 +28281,6 @@ var PLAN_PERMISSION = {
   webfetch: "allow"
 };
 
-// src/agents/build-prompt.ts
-var BUILD_SYSTEM_PROMPT = `<system-reminder>
-# Build Mode - System Reminder
-
-BUILD MODE ACTIVE - you are in EXECUTION phase. Your responsibility is to:
-- Implement features and make code changes
-- Execute commands and run tests
-- Fix bugs and refactor code
-- Deploy and build systems
-- Make all necessary file modifications
-
-You have FULL permissions to edit files, run commands, and make system changes.
-This is the implementation phase - execute decisively and thoroughly.
-
----
-
-## Responsibility
-
-Your current responsibility is to implement, build, and execute. You should:
-- Write and modify code to accomplish the user's goals
-- Run tests and builds to verify your changes
-- Fix errors and issues that arise
-- Use all available tools to complete the task efficiently
-- Delegate to specialized agents when appropriate for better results
-
-**NOTE:** You should ask the user for clarification when requirements are ambiguous,
-but once the path is clear, execute confidently. The goal is to deliver working,
-tested, production-ready solutions.
-
----
-
-## Important
-
-The user wants you to execute and implement. You SHOULD make edits, run necessary
-tools, and make changes to accomplish the task. Use your full capabilities to
-deliver excellent results.
-</system-reminder>
-`;
-var BUILD_PERMISSION = {
-  edit: "ask",
-  bash: "ask",
-  webfetch: "allow"
-};
-
 // src/index.ts
 import * as fs7 from "fs";
 import * as path8 from "path";
@@ -28316,7 +28336,7 @@ function migrateConfigFile(configPath, rawConfig) {
   }
   return needsWrite;
 }
-function loadConfigFromPath2(configPath) {
+function loadConfigFromPath2(configPath, ctx) {
   try {
     if (fs7.existsSync(configPath)) {
       const content = fs7.readFileSync(configPath, "utf-8");
@@ -28327,6 +28347,21 @@ function loadConfigFromPath2(configPath) {
         const errorMsg = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
         log(`Config validation error in ${configPath}:`, result.error.issues);
         addConfigLoadError({ path: configPath, error: `Validation error: ${errorMsg}` });
+        const errorList = result.error.issues.map((issue2) => `\u2022 ${issue2.path.join(".")}: ${issue2.message}`).join(`
+`);
+        ctx.client.tui.showToast({
+          body: {
+            title: "\u274C OhMyOpenCode: Config Validation Failed",
+            message: `Failed to load ${configPath}
+
+Validation errors:
+${errorList}
+
+Config will be ignored. Please fix the errors above.`,
+            variant: "error",
+            duration: 1e4
+          }
+        }).catch(() => {});
         return null;
       }
       log(`Config loaded from ${configPath}`, { agents: result.data.agents });
@@ -28336,6 +28371,21 @@ function loadConfigFromPath2(configPath) {
     const errorMsg = err instanceof Error ? err.message : String(err);
     log(`Error loading config from ${configPath}:`, err);
     addConfigLoadError({ path: configPath, error: errorMsg });
+    const hint = err instanceof SyntaxError ? `
+
+Hint: Check for syntax errors in your JSON file (missing commas, quotes, brackets, etc.)` : "";
+    ctx.client.tui.showToast({
+      body: {
+        title: "\u274C OhMyOpenCode: Config Load Failed",
+        message: `Failed to load ${configPath}
+
+Error: ${errorMsg}${hint}
+
+Config will be ignored. Please fix the error above.`,
+        variant: "error",
+        duration: 1e4
+      }
+    }).catch(() => {});
   }
   return null;
 }
@@ -28365,11 +28415,11 @@ function mergeConfigs(base, override) {
     claude_code: deepMerge(base.claude_code, override.claude_code)
   };
 }
-function loadPluginConfig(directory) {
+function loadPluginConfig(directory, ctx) {
   const userConfigPath = path8.join(getUserConfigDir(), "opencode", "oh-my-opencode.json");
   const projectConfigPath = path8.join(directory, ".opencode", "oh-my-opencode.json");
-  let config3 = loadConfigFromPath2(userConfigPath) ?? {};
-  const projectConfig = loadConfigFromPath2(projectConfigPath);
+  let config3 = loadConfigFromPath2(userConfigPath, ctx) ?? {};
+  const projectConfig = loadConfigFromPath2(projectConfigPath, ctx);
   if (projectConfig) {
     config3 = mergeConfigs(config3, projectConfig);
   }
@@ -28383,7 +28433,7 @@ function loadPluginConfig(directory) {
   return config3;
 }
 var OhMyOpenCodePlugin = async (ctx) => {
-  const pluginConfig = loadPluginConfig(ctx.directory);
+  const pluginConfig = loadPluginConfig(ctx.directory, ctx);
   const disabledHooks = new Set(pluginConfig.disabled_hooks ?? []);
   const isHookEnabled = (hookName) => !disabledHooks.has(hookName);
   const modelContextLimitsCache = new Map;
@@ -28477,9 +28527,8 @@ var OhMyOpenCodePlugin = async (ctx) => {
       const userAgents = pluginConfig.claude_code?.agents ?? true ? loadUserAgents() : {};
       const projectAgents = pluginConfig.claude_code?.agents ?? true ? loadProjectAgents() : {};
       const isSisyphusEnabled = pluginConfig.sisyphus_agent?.disabled !== true;
-      const builderEnabled = pluginConfig.sisyphus_agent?.builder_enabled ?? false;
+      const builderEnabled = pluginConfig.sisyphus_agent?.default_builder_enabled ?? false;
       const plannerEnabled = pluginConfig.sisyphus_agent?.planner_enabled ?? true;
-      const replaceBuild = pluginConfig.sisyphus_agent?.replace_build ?? true;
       const replacePlan = pluginConfig.sisyphus_agent?.replace_plan ?? true;
       if (isSisyphusEnabled && builtinAgents.Sisyphus) {
         const agentConfig = {
@@ -28487,15 +28536,12 @@ var OhMyOpenCodePlugin = async (ctx) => {
         };
         if (builderEnabled) {
           const { name: _buildName, ...buildConfigWithoutName } = config3.agent?.build ?? {};
-          const builderSisyphusOverride = pluginConfig.agents?.["Builder-Sisyphus"];
-          const builderSisyphusBase = {
+          const openCodeBuilderOverride = pluginConfig.agents?.["OpenCode-Builder"];
+          const openCodeBuilderBase = {
             ...buildConfigWithoutName,
-            prompt: BUILD_SYSTEM_PROMPT,
-            permission: BUILD_PERMISSION,
-            description: `${config3.agent?.build?.description ?? "Build agent"} (OhMyOpenCode version)`,
-            color: config3.agent?.build?.color ?? "#32CD32"
+            description: `${config3.agent?.build?.description ?? "Build agent"} (OpenCode default)`
           };
-          agentConfig["Builder-Sisyphus"] = builderSisyphusOverride ? { ...builderSisyphusBase, ...builderSisyphusOverride } : builderSisyphusBase;
+          agentConfig["OpenCode-Builder"] = openCodeBuilderOverride ? { ...openCodeBuilderBase, ...openCodeBuilderOverride } : openCodeBuilderBase;
         }
         if (plannerEnabled) {
           const { name: _planName, ...planConfigWithoutName } = config3.agent?.plan ?? {};
@@ -28509,13 +28555,20 @@ var OhMyOpenCodePlugin = async (ctx) => {
           };
           agentConfig["Planner-Sisyphus"] = plannerSisyphusOverride ? { ...plannerSisyphusBase, ...plannerSisyphusOverride } : plannerSisyphusBase;
         }
+        const filteredConfigAgents = config3.agent ? Object.fromEntries(Object.entries(config3.agent).filter(([key]) => {
+          if (key === "build")
+            return false;
+          if (key === "plan" && replacePlan)
+            return false;
+          return true;
+        })) : {};
         config3.agent = {
           ...agentConfig,
           ...Object.fromEntries(Object.entries(builtinAgents).filter(([k]) => k !== "Sisyphus")),
           ...userAgents,
           ...projectAgents,
-          ...config3.agent,
-          ...replaceBuild ? { build: { ...config3.agent?.build, mode: "subagent" } } : {},
+          ...filteredConfigAgents,
+          build: { ...config3.agent?.build, mode: "subagent" },
           ...replacePlan ? { plan: { ...config3.agent?.plan, mode: "subagent" } } : {}
         };
       } else {