@tea-agent/loop-agent 0.27.1 → 0.28.1-beta.1

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+## [0.28.0] - 2026-08-05
+
+### 重点更新
+
+- 新增客户端上下文溢出（Context Overflow）的自动压缩与恢复机制，支持 OpenCode 与 Pi 环境
+- DAG 总览面板全面隔离模拟运行，确保仅展示真实执行的任务状态
+- 修复多项 DAG 生命周期与状态恢复问题，提升任务执行稳定性
+
+### 新增
+
+- 新增内网/通用客户端上下文溢出恢复机制：支持精准识别中英文溢出提示，并为 OpenCode 和 Pi 环境自动生成压缩与恢复插件
+
+### 改进
+
+- DAG 总览面板全面隔离模拟运行（dry-run/init-only），确保其不再污染活跃任务视图，仅展示真实执行的任务状态
+
+### 修复
+
+- 修复 Playwright 浏览器执行未受限制的问题，恢复其有界执行机制
+- 修复结构化审查在遇到重复或无效 JSON 时无法正确收敛的问题，确保严格按规范完成或进入有界修复
+- 修复通用 writer 声明结果与实际改动不一致仍误判成功的问题，现强制要求结果与 diff 保持一致
+- 修复任务在审计或失败运行后无法正确恢复生命周期的问题，现支持在存在待审批写入集时安全恢复执行
+- 修复客户端上下文溢出恢复在压缩后未正确延迟恢复执行的问题
+
 ## [0.27.1] - 2026-08-04
 
 ### 重点更新

package/dist/application/task-lifecycle/observe.js

@@ -144,6 +144,11 @@ function deriveLifecycleState(input) {
     if (input.latestRun?.lifecycle === "completed") {
         if (input.latestRun.status === "finished")
             return "run-succeeded";
+        // A newly opened current writeSet gate supersedes an older failed run so
+        // operators can approve and start the next DAG run. Success stays terminal
+        // here so promote/closeout is not hijacked by a residual open gate.
+        if (input.gateOpen)
+            return "awaiting-write-set-approval";
         return "run-failed";
     }
     if (input.gateOpen)

package/dist/application/task-lifecycle/plan-transitions.js

@@ -116,9 +116,13 @@ export function planTransitions(input) {
     }
     // After validate, open write-set gate unless already approved/rejected for current digest.
     const gate = snapshot.gate ?? null;
+    // run-failed is terminal only when there is no current open gate. An open
+    // current writeSet gate supersedes an older failed run so recovery approve
+    // can start the next DAG run (observe may already report awaiting).
+    const failedRecoverable = snapshot.lifecycleState === "run-failed" && gate !== null;
     const postRunState = snapshot.lifecycleState === "running" ||
         snapshot.lifecycleState === "run-succeeded" ||
-        snapshot.lifecycleState === "run-failed" ||
+        (snapshot.lifecycleState === "run-failed" && !failedRecoverable) ||
         snapshot.lifecycleState === "evidence-closed" ||
         snapshot.lifecycleState === "needs-attention" ||
         snapshot.lifecycleState === "awaiting-decision";
@@ -149,8 +153,9 @@ export function planTransitions(input) {
         }
     }
     // Only start/monitor when not already in a terminal post-run state.
+    // Keep run-succeeded / evidence-closed terminal; allow run-failed + open gate.
     const alreadyTerminalRun = snapshot.lifecycleState === "run-succeeded" ||
-        snapshot.lifecycleState === "run-failed" ||
+        (snapshot.lifecycleState === "run-failed" && !failedRecoverable) ||
         snapshot.lifecycleState === "evidence-closed";
     if (!alreadyTerminalRun) {
         if (input.approveGate && !postRunState) {

package/dist/cli/program.js

@@ -594,7 +594,7 @@ export function buildLoopAgentProgram(options) {
                 .option("--markdown", "print Markdown")
                 .option("--bootstrap-surface", "write an inferred .harness/init-surface.json baseline")
                 .option("--apply-safe", "apply deterministic safe init updates")
-                .option("--client-recovery <mode>", "auto|project|user|off — OpenCode project plugin and optional Pi user retry config", "auto");
+                .option("--client-recovery <mode>", "auto|project|user|off — OpenCode transient+overflow plugins, Pi overflow extension, optional Pi user retry config", "auto");
             command.action(async (args, _options, actionCommand) => runInitCommand(args, actionCommand, options.defaultRepoRoot));
             addStandaloneSubcommands(command, entry.subcommands ?? [], (args, actionCommand) => runInitCommand(args, actionCommand, options.defaultRepoRoot));
             program.addCommand(command);

package/dist/commands/client-recovery.js

@@ -8,9 +8,13 @@ export const CLIENT_RECOVERY_MODES = [
     "off",
 ];
 export const OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH = ".opencode/plugins/loop-agent-transient-retry.js";
+export const OPENCODE_CONTEXT_OVERFLOW_COMPACT_PLUGIN_PATH = ".opencode/plugins/loop-agent-context-overflow-compact.js";
+export const PI_CONTEXT_OVERFLOW_EXTENSION_PATH = ".pi/extensions/loop-agent-context-overflow.js";
 export const PERMANENT_ERROR_INTERACTION = "plugin-ignore-permanent-error";
 export const BACKOFF_MS = [2000, 4000, 8000, 16000, 30000];
 export const MAX_SESSION_RETRIES = 5;
+/** Hard cap for OpenCode overflow compact+resume recoveries (≤ 2). */
+export const MAX_OVERFLOW_RECOVERIES = 1;
 export const PI_RECOMMENDED_RETRY = {
     enabled: true,
     maxRetries: 5,
@@ -20,6 +24,36 @@ export const PI_RECOMMENDED_RETRY = {
         maxRetryDelayMs: 60000,
     },
 };
+/**
+ * Shared overflow phrase sources used by isContextOverflow and generated plugins.
+ * Keep English + Chinese intranet gateway messages in one place to avoid drift.
+ */
+export const CONTEXT_OVERFLOW_PHRASES = [
+    "请求上下文过大",
+    "context_length_exceeded",
+    "context overflow",
+    "context length overflow",
+    "too many tokens",
+    "maximum context",
+    "prompt is too long",
+    "request_too_large",
+    "context window",
+];
+function escapeRegExpLiteral(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const CONTEXT_OVERFLOW_PATTERN = new RegExp(CONTEXT_OVERFLOW_PHRASES.map(escapeRegExpLiteral).join("|"), "i");
+function buildGeneratedContextOverflowPatternSource() {
+    return `const CONTEXT_OVERFLOW_PHRASES = ${JSON.stringify([
+        ...CONTEXT_OVERFLOW_PHRASES,
+    ])};
+const OVERFLOW_PATTERN = new RegExp(
+  CONTEXT_OVERFLOW_PHRASES.map((phrase) =>
+    phrase.replace(/[.*+?^\${}()|[\\]\\\\]/g, "\\\\$&"),
+  ).join("|"),
+  "i",
+);`;
+}
 const PERMANENT_MESSAGE_PATTERNS = [
     {
         reason: "auth",
@@ -35,7 +69,7 @@ const PERMANENT_MESSAGE_PATTERNS = [
     },
     {
         reason: "context-overflow",
-        pattern: /\b(context (length )?overflow|too many tokens|maximum context|context window)\b/i,
+        pattern: CONTEXT_OVERFLOW_PATTERN,
     },
     {
         reason: "cancelled",
@@ -156,6 +190,14 @@ function permanentReason(error) {
     }
     return undefined;
 }
+/**
+ * Shared context-overflow recognition for OpenCode overflow-compact plugin,
+ * Pi project extension, and pure tests. Does not treat 401/403, quota, cancel,
+ * business validation, or standard 502/LLMRequestError as overflow.
+ */
+export function isContextOverflow(error) {
+    return CONTEXT_OVERFLOW_PATTERN.test(collectErrorText(error));
+}
 function looksTransient(error) {
     const text = collectErrorText(error);
     if (TRANSIENT_MESSAGE_PATTERNS.some((pattern) => pattern.test(text)))
@@ -471,6 +513,7 @@ const PLUGIN_PATH = ${JSON.stringify(OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH)};
 const PERMANENT_INTERACTION = ${JSON.stringify(PERMANENT_ERROR_INTERACTION)};
 const BACKOFF_MS = ${JSON.stringify([...BACKOFF_MS])};
 const MAX_RETRIES = ${MAX_SESSION_RETRIES};
+${buildGeneratedContextOverflowPatternSource()}
 
 const sessionState = new Map();
 const sessionStatus = new Map();
@@ -502,8 +545,9 @@ function isPermanent(error) {
     if (/^APIError$/i.test(error.name)) return true;
     if (/^(AuthError|PermissionError)$/i.test(error.name)) return true;
   }
-  return /\\b(401|403|unauthorized|forbidden|quota|rate.?limit|context (length )?overflow|too many tokens|cancelled|canceled|business validation|invalid task|schema validation)\\b/i.test(
-    text,
+  return (
+    OVERFLOW_PATTERN.test(text) ||
+    /\\b(401|403|unauthorized|forbidden|quota|rate.?limit|cancelled|canceled|business validation|invalid task|schema validation)\\b/i.test(text)
   );
 }
 
@@ -718,22 +762,390 @@ export default async function loopAgentTransientRetryPlugin({ client, $ }) {
 }
 `;
 }
-export async function installProjectOpenCodePlugin(input) {
-    const relativePath = OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH;
-    const target = path.join(input.repoRoot, relativePath);
-    const content = buildOpenCodeTransientRetryPluginSource();
+async function installGeneratedProjectFile(input) {
+    const target = path.join(input.repoRoot, input.relativePath);
     if (input.onlyIfMissing) {
         try {
             await readFile(target, "utf-8");
-            return { path: relativePath, written: false, reason: "unchanged" };
+            return {
+                path: input.relativePath,
+                written: false,
+                reason: "unchanged",
+            };
         }
         catch {
             // missing → write
         }
     }
     await mkdir(path.dirname(target), { recursive: true });
-    await writeFile(target, content, "utf-8");
-    return { path: relativePath, written: true, reason: "written" };
+    await writeFile(target, input.content, "utf-8");
+    return { path: input.relativePath, written: true, reason: "written" };
+}
+export async function installProjectOpenCodePlugin(input) {
+    return installGeneratedProjectFile({
+        repoRoot: input.repoRoot,
+        relativePath: OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH,
+        content: buildOpenCodeTransientRetryPluginSource(),
+        onlyIfMissing: input.onlyIfMissing,
+    });
+}
+/**
+ * Stable generated source for the OpenCode context-overflow compact plugin.
+ * Separate from transient-retry: only overflow → compact/summarize + limited resume.
+ */
+export function buildOpenCodeContextOverflowCompactPluginSource() {
+    return `/**
+ * loop-agent OpenCode context overflow compact plugin
+ * Path: ${OPENCODE_CONTEXT_OVERFLOW_COMPACT_PLUGIN_PATH}
+ *
+ * On context overflow (including Chinese "请求上下文过大"), compact/summarize
+ * then resume the same session a limited number of times. Does NOT handle
+ * provider transport / 502 recovery (that is loop-agent-transient-retry.js).
+ */
+const PLUGIN_PATH = ${JSON.stringify(OPENCODE_CONTEXT_OVERFLOW_COMPACT_PLUGIN_PATH)};
+const MAX_OVERFLOW_RECOVERIES = ${MAX_OVERFLOW_RECOVERIES};
+${buildGeneratedContextOverflowPatternSource()}
+
+const sessionState = new Map();
+const sessionStatus = new Map();
+const pendingOverflow = new Map();
+const deferredResume = new Map();
+const recoveryWorkers = new Map();
+
+function getState(sessionId) {
+  let state = sessionState.get(sessionId);
+  if (!state) {
+    state = {
+      attempt: 0,
+      locked: false,
+      rerunRequested: false,
+      deferredIdleConfirmed: false,
+    };
+    sessionState.set(sessionId, state);
+  }
+  return state;
+}
+
+function textOf(error) {
+  if (!error) return "";
+  if (typeof error === "string") return error;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+
+function isContextOverflow(error) {
+  return OVERFLOW_PATTERN.test(textOf(error));
+}
+
+function buildOverflowResumePrompt(sessionId, error, attempt) {
+  return [
+    "[loop-agent context overflow recovery] session=" + sessionId + " attempt=" + attempt,
+    "Previous model turn failed because the request context was too large: " + textOf(error),
+    "Session history was compacted/summarized before this resume.",
+    "Before continuing any work, first inspect already completed tool calls and existing file modifications in this session.",
+    "Do not re-run side-effecting tools or rewrite files that already reflect successful prior work.",
+    "Resume only the remaining unfinished work after that check.",
+    "续接前请先检查本 session 已有工具调用与文件改动，避免重复执行有副作用的操作。",
+  ].join("\\n");
+}
+
+function statusType(status) {
+  const type = status && typeof status.type === "string" ? status.type : undefined;
+  return type === "idle" || type === "retry" || type === "busy" ? type : undefined;
+}
+
+async function readSessionStatus(client, sessionId) {
+  const cached = sessionStatus.get(sessionId);
+  if (cached === "retry" || cached === "busy") {
+    return { ok: true, type: cached };
+  }
+  try {
+    const response = await client.session.status({ throwOnError: true });
+    if (!response || typeof response !== "object" || response.error != null) {
+      return { ok: false };
+    }
+    const current = statusType(response?.data?.[sessionId]);
+    if (!current) return { ok: false };
+    sessionStatus.set(sessionId, current);
+    return { ok: true, type: current };
+  } catch {
+    return { ok: false };
+  }
+}
+
+function promptWasAccepted(response) {
+  return Boolean(
+    response &&
+      typeof response === "object" &&
+      response.error == null &&
+      Object.prototype.hasOwnProperty.call(response, "data") &&
+      response.data !== null &&
+      typeof response.data === "object",
+  );
+}
+
+async function compactOrSummarize(client, sessionId) {
+  const body = { path: { id: sessionId }, throwOnError: true };
+  if (typeof client.session.compact === "function") {
+    await client.session.compact(body);
+    return "compact";
+  }
+  if (typeof client.session.summarize === "function") {
+    await client.session.summarize(body);
+    return "summarize";
+  }
+  throw new Error("session.compact and session.summarize are unavailable");
+}
+
+export default async function loopAgentContextOverflowCompactPlugin({ client, $ }) {
+  void $;
+  void PLUGIN_PATH;
+
+  async function promptDeferredResume(sessionId, idleConfirmed = false) {
+    const deferred = deferredResume.get(sessionId);
+    if (!deferred) return;
+
+    if (!idleConfirmed) {
+      const status = await readSessionStatus(client, sessionId);
+      if (deferredResume.get(sessionId) !== deferred) return;
+      if (!status.ok || status.type !== "idle") return;
+    }
+
+    // An explicit idle event is authoritative even if the SDK status snapshot
+    // still lags at busy. Keep deferred facts until promptAsync is accepted so
+    // later idle can retry without another compact/summarize.
+    const prompt = buildOverflowResumePrompt(sessionId, deferred.error, deferred.attempt);
+    let response;
+    try {
+      response = await client.session.promptAsync({
+        path: { id: sessionId },
+        body: { parts: [{ type: "text", text: prompt }] },
+        throwOnError: true,
+      });
+    } catch {
+      return;
+    }
+    if (deferredResume.get(sessionId) !== deferred) return;
+    if (!promptWasAccepted(response)) return;
+    deferredResume.delete(sessionId);
+    getState(sessionId).deferredIdleConfirmed = false;
+  }
+
+  async function drainPendingOverflow(sessionId) {
+    const state = getState(sessionId);
+    // Deferred resume path: only promptAsync, never compact/summarize again.
+    if (deferredResume.has(sessionId)) {
+      const idleConfirmed = state.deferredIdleConfirmed;
+      state.deferredIdleConfirmed = false;
+      await promptDeferredResume(sessionId, idleConfirmed);
+      return;
+    }
+
+    const pending = pendingOverflow.get(sessionId);
+    if (!pending) return;
+    if (state.attempt >= MAX_OVERFLOW_RECOVERIES) {
+      pendingOverflow.delete(sessionId);
+      return;
+    }
+
+    const before = await readSessionStatus(client, sessionId);
+    if (pendingOverflow.get(sessionId) !== pending) return;
+    if (!before.ok || before.type !== "idle") return;
+
+    try {
+      await compactOrSummarize(client, sessionId);
+    } catch {
+      // Compact itself failed: do not consume budget (no compact side-effect yet).
+      return;
+    }
+    // Session cleanup may remove this work while compact is in flight. Do not
+    // let that stale worker consume the reset budget or recreate deferred state.
+    // Concurrent overflow cannot replace pending because session.error preserves
+    // the first in-flight recovery facts below.
+    if (pendingOverflow.get(sessionId) !== pending) return;
+
+    // Consume budget immediately and exactly once after an active recovery's
+    // successful compact/summarize.
+    const nextAttempt = Math.min(state.attempt + 1, MAX_OVERFLOW_RECOVERIES);
+    state.attempt = nextAttempt;
+    pendingOverflow.delete(sessionId);
+    // Keep resume facts across temporary post-compact busy/unknown status.
+    deferredResume.set(sessionId, { error: pending.error, attempt: nextAttempt });
+    await promptDeferredResume(sessionId);
+  }
+
+  function startRecoveryWorker(sessionId, deferredIdleConfirmed = false) {
+    const state = getState(sessionId);
+    if (deferredIdleConfirmed && deferredResume.has(sessionId)) {
+      state.deferredIdleConfirmed = true;
+    }
+    if (recoveryWorkers.has(sessionId)) {
+      state.rerunRequested = true;
+      return;
+    }
+    state.locked = true;
+    state.rerunRequested = false;
+    const worker = drainPendingOverflow(sessionId)
+      .catch(() => {})
+      .finally(() => {
+        recoveryWorkers.delete(sessionId);
+        const rerun = state.rerunRequested;
+        state.rerunRequested = false;
+        state.locked = false;
+        if (rerun && (pendingOverflow.has(sessionId) || deferredResume.has(sessionId))) {
+          startRecoveryWorker(sessionId);
+        }
+      });
+    recoveryWorkers.set(sessionId, worker);
+  }
+
+  function clearSession(sessionId) {
+    pendingOverflow.delete(sessionId);
+    deferredResume.delete(sessionId);
+    sessionStatus.delete(sessionId);
+    const state = sessionState.get(sessionId);
+    if (state) {
+      state.attempt = 0;
+      state.rerunRequested = false;
+      state.deferredIdleConfirmed = false;
+      if (!recoveryWorkers.has(sessionId)) state.locked = false;
+    }
+  }
+
+  function hasWork(sessionId) {
+    return pendingOverflow.has(sessionId) || deferredResume.has(sessionId);
+  }
+
+  return {
+    event: async ({ event }) => {
+      if (!event || typeof event !== "object") return;
+      const properties = event.properties || {};
+      const sessionId =
+        properties.sessionID || properties.sessionId || properties.id || properties.info?.id;
+
+      if (event.type === "session.status") {
+        const current = statusType(properties.status);
+        if (sessionId && current) sessionStatus.set(sessionId, current);
+        if (sessionId && current === "idle" && hasWork(sessionId)) {
+          startRecoveryWorker(sessionId, deferredResume.has(sessionId));
+        }
+        return;
+      }
+
+      if (event.type === "session.idle") {
+        if (sessionId) {
+          sessionStatus.set(sessionId, "idle");
+          if (hasWork(sessionId)) {
+            startRecoveryWorker(sessionId, deferredResume.has(sessionId));
+          }
+        }
+        return;
+      }
+
+      if (event.type === "session.deleted") {
+        if (sessionId) clearSession(sessionId);
+        return;
+      }
+
+      if (event.type === "message.updated") {
+        const info = properties.info;
+        if (
+          info?.role === "assistant" &&
+          info.sessionID &&
+          (info.status === undefined || info.status === "completed") &&
+          info.time?.completed != null &&
+          info.error == null
+        ) {
+          clearSession(info.sessionID);
+        }
+        return;
+      }
+
+      if (event.type === "session.error") {
+        if (!sessionId) return;
+        const error = properties.error || properties;
+        if (!isContextOverflow(error)) {
+          return;
+        }
+        if (getState(sessionId).attempt >= MAX_OVERFLOW_RECOVERIES) {
+          pendingOverflow.delete(sessionId);
+          return { interaction: "plugin-ignore-overflow-cap", reason: "plugin-ignore-overflow-cap" };
+        }
+        // Preserve the first overflow facts while compact or deferred resume is
+        // in flight. Concurrent overflow must not replace them or queue compact.
+        if (pendingOverflow.has(sessionId) || deferredResume.has(sessionId)) {
+          return { pending: true };
+        }
+        pendingOverflow.set(sessionId, { error });
+        startRecoveryWorker(sessionId);
+        return { pending: true };
+      }
+    },
+  };
+}
+`;
+}
+export async function installProjectOpenCodeOverflowCompactPlugin(input) {
+    return installGeneratedProjectFile({
+        repoRoot: input.repoRoot,
+        relativePath: OPENCODE_CONTEXT_OVERFLOW_COMPACT_PLUGIN_PATH,
+        content: buildOpenCodeContextOverflowCompactPluginSource(),
+        onlyIfMissing: input.onlyIfMissing,
+    });
+}
+/**
+ * Project-level Pi extension: normalize overflow errorMessage so native Pi
+ * overflow → compact → retry can fire. Does not touch settings or model windows.
+ */
+export function buildPiContextOverflowExtensionSource() {
+    return `/**
+ * loop-agent Pi context overflow extension
+ * Path: ${PI_CONTEXT_OVERFLOW_EXTENSION_PATH}
+ *
+ * On assistant message_end, rewrite overflow errorMessage to start with
+ * "context_length_exceeded:" so Pi's native overflow recovery can run.
+ * Idempotent. Does not write user settings or model context windows.
+ */
+const EXTENSION_PATH = ${JSON.stringify(PI_CONTEXT_OVERFLOW_EXTENSION_PATH)};
+${buildGeneratedContextOverflowPatternSource()}
+const NORMALIZED_PREFIX = "context_length_exceeded:";
+
+function isOverflowMessage(text) {
+  if (typeof text !== "string" || !text) return false;
+  return OVERFLOW_PATTERN.test(text);
+}
+
+export default function loopAgentContextOverflowExtension(pi) {
+  void EXTENSION_PATH;
+  pi.on("message_end", (event) => {
+    const message = event && event.message;
+    if (!message || message.role !== "assistant") return;
+    const current = message.errorMessage;
+    if (typeof current !== "string" || !current) return;
+    if (current.startsWith(NORMALIZED_PREFIX) || /context_length_exceeded/i.test(current)) {
+      return;
+    }
+    if (!isOverflowMessage(current)) return;
+    return {
+      message: {
+        ...message,
+        errorMessage: NORMALIZED_PREFIX + " " + current,
+      },
+    };
+  });
+}
+`;
+}
+export async function installProjectPiContextOverflowExtension(input) {
+    return installGeneratedProjectFile({
+        repoRoot: input.repoRoot,
+        relativePath: PI_CONTEXT_OVERFLOW_EXTENSION_PATH,
+        content: buildPiContextOverflowExtensionSource(),
+        onlyIfMissing: input.onlyIfMissing,
+    });
 }
 export async function inspectPiRetryConfig(input) {
     const homeDir = input.homeDir ?? os.homedir();
@@ -774,10 +1186,13 @@ export async function inspectPiRetryConfig(input) {
         };
     }
 }
+function skippedInstall(relativePath) {
+    return { path: relativePath, written: false, reason: "skipped" };
+}
 /**
- * Install project OpenCode plugin and optionally merge Pi user settings.
- * - auto/project: project plugin only (no home writes)
- * - user: project plugin + explicit Pi merge
+ * Install project recovery artifacts and optionally merge Pi user settings.
+ * - auto/project: transient plugin + overflow-compact plugin + Pi project extension (no home writes)
+ * - user: the three project files + explicit Pi retry merge
  * - off: skip all
  */
 export async function runClientRecovery(input) {
@@ -785,20 +1200,24 @@ export async function runClientRecovery(input) {
     if (mode === "off") {
         return {
             mode,
-            plugin: {
-                path: OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH,
-                written: false,
-                reason: "skipped",
-            },
+            plugin: skippedInstall(OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH),
+            overflowPlugin: skippedInstall(OPENCODE_CONTEXT_OVERFLOW_COMPACT_PLUGIN_PATH),
+            piExtension: skippedInstall(PI_CONTEXT_OVERFLOW_EXTENSION_PATH),
         };
     }
     const plugin = await installProjectOpenCodePlugin({
         repoRoot: input.repoRoot,
     });
+    const overflowPlugin = await installProjectOpenCodeOverflowCompactPlugin({
+        repoRoot: input.repoRoot,
+    });
+    const piExtension = await installProjectPiContextOverflowExtension({
+        repoRoot: input.repoRoot,
+    });
     if (mode !== "user") {
-        return { mode, plugin };
+        return { mode, plugin, overflowPlugin, piExtension };
     }
     const homeDir = input.homeDir ?? os.homedir();
     const pi = await applyPiRetryMerge({ homeDir });
-    return { mode, plugin, pi };
+    return { mode, plugin, overflowPlugin, piExtension, pi };
 }