oh-my-opencode 5.0.0-beta.25 → 5.0.0-beta.26

package/dist/skills/debugging/references/tools/dap.md

@@ -0,0 +1,103 @@
+# DAP Client (`dap.mjs`) — Drive the Debugger's Protocol, Not Its Text
+
+**Design modeled on the `debug` tool of oh-my-pi (https://github.com/can1357/oh-my-pi, branch omp2).** Their harness proved the shape: one structured debug surface with bounded output, stop snapshots, and classified errors. This script brings the same discipline to any agent with a shell — no harness tool registration required.
+
+Debuggers already speak the Debug Adapter Protocol (DAP), a machine-readable JSON protocol. Driving DAP beats screen-scraping a PTY for the same reason an API beats OCR: structured stops, structured variables, structured errors. **If the debugger speaks DAP, use this script instead of parsing `gdb`/`pdb` output.**
+
+The script is at `references/scripts/dap.mjs` — zero dependencies, runs under Bun or Node.
+
+---
+
+## When to use which interface
+
+| Situation | Use |
+|---|---|
+| Source-level debugging of Python / Go / Node / native code, and you need breakpoints, stepping, variables | `dap.mjs` (this file) |
+| Browser-served JS, or anything already in Chrome | Scripted CDP — see `references/runtimes/node.md` |
+| Stripped binary, no source, no symbols | Ghidra (static) + Frida (live) — see `references/tools/` |
+| The debugger has no DAP mode (plain gdb on an exotic target) | pwndbg, with the output-budget rule from `references/methodology/00-setup.md` |
+
+---
+
+## How to drive it
+
+`dap.mjs` is a **REPL**, not a one-shot command: a debug session is long-lived, so the script runs as a persistent process reading one command per line on stdin and writing bounded text on stdout. Run it as a background shell session, send commands to its stdin, and subscribe to its output.
+
+```
+bun references/scripts/dap.mjs
+```
+
+Every execution-control answer prints a single snapshot line beginning with `STOP:` — subscribe your watcher to that exact prefix so a breakpoint hit wakes you instead of you polling.
+
+### Commands
+
+| Command | Effect |
+|---|---|
+| `launch <adapter> <program> [args...]` | Spawn a stdio adapter (path to executable or `.mjs` adapter) and launch the program under it |
+| `attach <host:port>` | Connect to a listening adapter over TCP and attach |
+| `break <file>:<line>` / `rmbreak <file>:<line>` | Set / remove a source breakpoint |
+| `continue` / `step` / `next` / `stepin` / `stepout` / `pause` | Execution control; each prints a `STOP:` snapshot when the debuggee next stops |
+| `stack [limit]` | TSV backtrace, bounded |
+| `scopes` | Scopes of the top frame with their variablesReferences |
+| `vars <ref>` | Variables under a variablesReference from `scopes` — refs are session-scoped; always chain `scopes` first |
+| `eval <expr>` | Evaluate in the top frame |
+| `threads` / `sessions` | Thread list / session state |
+| `terminate` / `quit` | End the debuggee / exit the REPL |
+
+### Output contract (what keeps your context alive)
+
+- Tabular results are TSV with a header row.
+- Hard caps: `MAX_ROWS = 100`, `MAX_OUTPUT_BYTES = 32 KB`. Overflow prints an explicit `TRUNCATED: rows dropped=N bytes dropped=M` line — never a silent cut.
+- After every continue/step: `STOP: stopped reason=<why> threadId=<id> <frame> at <file>:<line>:<col>`. On debuggee exit: `EXIT: terminated`.
+- Errors are one line, classified: `ERR: invalid-args | no-session | adapter-failed | unverified-breakpoint | timeout | terminated | adapter-error`. The token tells you the recovery — see the failure taxonomy in `references/methodology/02-investigate.md`.
+- Every request times out after 15 s (override with `DAP_TIMEOUT_MS`) and the session stays alive.
+- `DAP_DEBUG=1` logs raw protocol traffic to stderr for diagnosing a misbehaving adapter.
+
+### Adapter quirks this client already handles
+
+- **debugpy** requires `console: "internalConsole"` in the launch request, and withholds the `initialized` event for unrecognized `adapterID`s — the client sends both correctly. It also flushes `initialized` lazily, so the client launches first and awaits the event after.
+- **lldb-dap** reports the launch response's `success` unreliably (`false` even when the process started and stopped) and reports `threadId: 0` on the entry stop. The events are the real signal; the client tolerates the response flag.
+
+---
+
+## Adapter matrix
+
+Translated from oh-my-pi's `builtin_adapters()` (omp2 `crates/docserver/src/dap_adapter.rs`). Install the one matching your runtime; the client speaks to all of them the same way.
+
+| Runtime | Adapter | Install | Launch mode |
+|---|---|---|---|
+| Python | debugpy | `pip install debugpy` | `python -m debugpy.adapter` (stdio) |
+| Go | dlv | `go install github.com/go-delve/delve/cmd/dlv@latest` | `dlv dap` (stdio) |
+| C/C++/Swift/Rust/Zig | lldb-dap | ships with Xcode CLT / LLVM | `lldb-dap` (stdio) |
+| C/C++/Rust/Zig | codelldb | VS Code extension binary | stdio |
+| C/C++/Rust | gdb | `brew install gdb` / apt | via gdb's DAP mode where available |
+| JS/TS | js-debug | `npm i -g @vscode/js-debug` | stdio |
+| .NET | netcoredbg | GitHub releases | stdio |
+| Ruby | rdbg | `gem install debug` | stdio |
+| Kotlin | kotlin-debug-adapter | GitHub releases | stdio |
+| PHP | php-debug-adapter | composer | stdio |
+| Bash | bash-debug-adapter | GitHub releases | stdio |
+| Dart/Flutter | dart debug adapter | ships with Dart SDK | `dart` (stdio) |
+| Elixir | elixir-ls debugger | GitHub releases | stdio |
+
+If an adapter is missing, the install line is the fix — do not fall back to scraping a REPL.
+
+---
+
+## Worked example (Python)
+
+```
+launch /path/to/python -m debugpy.adapter myscript.py   # or a wrapper script path
+break myscript.py:12
+continue
+STOP: stopped reason=breakpoint threadId=1 compute at myscript.py:12:1
+stack
+scopes
+vars 6          # the variablesReference scopes just printed for Locals
+eval total
+continue
+terminate
+quit
+```
+
+Cleanup is part of the session: `terminate` the debuggee, `quit` the REPL, and journal any wrapper scripts you created per the skill's cleanup phase.

package/dist/skills/debugging/references/tools/frida.md

@@ -0,0 +1,193 @@
+# Frida — Hook a Live Process and See Real Values at Runtime
+
+**https://frida.re**
+
+Frida injects a JavaScript engine into a running process and lets you intercept function calls, read arguments, patch return values, and trace execution without touching the binary on disk. **When static analysis in Ghidra shows you *what* a function does, Frida shows you what it does *right now*, with real inputs.** The two compose naturally: use Ghidra to find the target function and its offset, then use Frida to hook it and watch live traffic.
+
+Choose Frida over Ghidra when you need runtime values (actual arguments, return codes, heap contents) or when the binary's control flow is too obfuscated for static analysis to resolve.
+
+---
+
+## Install
+
+```bash
+pip install frida-tools            # Python 3 required
+frida --version                    # verify
+```
+
+On macOS, attaching to another user's process needs root (`sudo frida ...`). SIP-protected system binaries (`/usr/bin/*`, `/usr/sbin/*`) are off-limits entirely. On Linux, you may need `ptrace` permissions: run as root or set `kernel.yama.ptrace_scope=0`.
+
+---
+
+## Target discovery with `frida-ps`
+
+```bash
+frida-ps                         # list local processes
+frida-ps -U                      # USB-connected device (iOS/Android)
+frida-ps | grep -i target        # find your target by name
+```
+
+---
+
+## `frida-trace` — zero-code entry point
+
+`frida-trace` auto-generates JavaScript handler stubs for every matched function. You don't write any code to start.
+
+```bash
+frida-trace -p <pid> -i "recv*"                               # trace exported functions by glob
+frida-trace -p <pid> -m "-[NSURLSession dataTaskWithRequest:*]"  # Objective-C method
+frida-trace -U -p <pid> -j "com.example.App!login*"             # Java method (Android)
+frida-trace -f ./target -i "open"                               # spawn + trace from start
+```
+
+Generated handler files land in `__handlers__/`. Each looks like:
+
+```js
+// __handlers__/libSystem.B.dylib/open.js
+{
+  onEnter(log, args, state) {
+    // args[0] is the first argument (a pointer)
+    log(`open("${args[0].readUtf8String()}")`);
+  },
+  onLeave(log, retval, state) {
+    log(`  => ${retval}`);
+  }
+}
+```
+
+Edit that file, save, and `frida-trace` hot-reloads it. This is the fastest path from "I wonder what this function receives" to a concrete answer.
+
+---
+
+## The JS agent API
+
+When `frida-trace` isn't enough, you write a JS agent and load it with `frida` or from a Python host script. These are the building blocks.
+
+### Find a function
+
+```js
+// By exported symbol name
+const openPtr = Module.getExportByName(null, "open");  // null = any module
+const sslWritePtr = Module.getExportByName("libssl.so", "SSL_write");
+
+// By offset in a stripped binary (get the offset from Ghidra)
+const base = Module.getBaseAddress("target");
+const funcPtr = base.add(0x1a3c);
+```
+
+### Intercept calls
+
+```js
+Interceptor.attach(openPtr, {
+  onEnter(args) {
+    // args[0], args[1], ... are NativePointer objects
+    const path = args[0].readUtf8String();
+    const flags = args[1].toInt32();
+    send({ event: "open", path: path, flags: flags });
+  },
+  onLeave(retval) {
+    // retval is the return value as a NativePointer
+    send({ event: "open_ret", fd: retval.toInt32() });
+  }
+});
+```
+
+### Read memory
+
+```js
+args[0].readUtf8String()          // read a UTF-8 C string from a pointer
+args[0].readCString()             // read a raw C string (stops at null)
+args[1].readByteArray(len)        // read len raw bytes (returns ArrayBuffer)
+```
+
+### Replace / stub a function
+
+```js
+// Force a function to always return 0 (e.g. bypass a license check)
+Interceptor.replace(checkLicensePtr, new NativeCallback(function () {
+  return 0;
+}, 'int', []));
+```
+
+Use `Interceptor.replace` sparingly. It changes program behavior, so always note in your journal that you patched something and why.
+
+---
+
+## Python host script
+
+A host script lets you load a JS agent, receive `send()` messages, and post-process results from the Python side.
+
+```python
+import frida, sys
+
+with open("agent.js") as f:
+    agent_source = f.read()
+
+def on_message(message, data):
+    if message["type"] == "send":
+        print(f"[*] {message['payload']}")
+    else:
+        print(f"[!] {message}")
+
+session = frida.attach(int(sys.argv[1]))
+script = session.create_script(agent_source)
+script.on("message", on_message)
+script.load()
+
+try:
+    sys.stdin.read()                 # block until Ctrl+C
+except KeyboardInterrupt:
+    session.detach()
+```
+
+The agent runs inside the target; the host script stays in your terminal and prints structured output.
+
+---
+
+## Output-budget discipline
+
+**Hooking a hot function (e.g. `malloc`, `read`) will flood your context with thousands of lines.** Don't print every call. Aggregate in the agent and report a summary.
+
+```js
+// Count calls, report every 1000
+let callCount = 0;
+Interceptor.attach(mallocPtr, {
+  onEnter(args) {
+    callCount++;
+    if (callCount % 1000 === 0) {
+      send({ event: "malloc_summary", total_calls: callCount });
+    }
+  }
+});
+```
+
+Alternatives: filter by argument value, only log calls from a specific caller module, or batch into an array and `send()` on a timer.
+
+---
+
+## ⚠️ Gotchas
+
+**Attach vs. spawn.** `frida -p <pid>` attaches to an already-running process. If you need to catch early initialization (constructors, `main` entry), spawn the process with `frida -f ./target`. Frida pauses it at startup. Resume with `%resume` in the REPL or by calling `device.resume(pid)` from Python.
+
+**Stripped binaries have no symbol names.** `Module.getExportByName` returns null for internal functions. You must find the function offset in Ghidra, then compute the address at runtime:
+
+```js
+const addr = Module.getBaseAddress("target").add(0x4a20);
+Interceptor.attach(addr, { /* ... */ });
+```
+
+**A crashing target kills your session.** If the target segfaults or aborts, Frida's agent dies with it. Script a respawn loop on the Python side if you expect crashes.
+
+**Thread safety.** `onEnter`/`onLeave` fire on multiple threads. Keep shared state to simple counters.
+
+---
+
+## Cleanup
+
+```bash
+kill <pid>                         # kill any process you spawned with -f
+rm -rf __handlers__/               # remove generated handler stubs
+rm -f agent.js host.py             # remove session-specific scripts
+```
+
+Always note in your journal which processes you attached to and whether you replaced any functions. A forgotten `Interceptor.replace` in a long-running target will cause confusing behavior later.

package/dist/tools/delegate-task/types.d.ts

@@ -1,4 +1,5 @@
 import type { BackgroundManager } from "../../features/background-agent";
+import type { OhMyOpenCodeConfig } from "../../config";
 import type { CategoriesConfig, GitMasterConfig, BrowserAutomationProvider, AgentOverrides, SisyphusAgentConfig } from "../../config/schema";
 import type { ModelFallbackControllerAccessor } from "../../hooks/model-fallback";
 import type { LoadedSkill } from "../../features/opencode-skill-loader/types";
@@ -119,6 +120,8 @@ export interface DelegateTaskToolOptions {
     availableCategories?: AvailableCategory[];
     availableSkills?: AvailableSkill[];
     agentOverrides?: AgentOverrides;
+    /** Reload model-bearing config at task invocation time so edits are honored without rebuilding tools. */
+    loadCurrentModelConfig?: () => Pick<OhMyOpenCodeConfig, "agents" | "categories">;
     sisyphusAgentConfig?: SisyphusAgentConfig;
     modelFallbackControllerAccessor?: ModelFallbackControllerAccessor;
     onSyncSessionCreated?: (event: SyncSessionCreatedEvent) => Promise<void>;

package/dist/tui.js

@@ -17499,6 +17499,25 @@ var init_telemetry = __esm(() => {
   }).strict();
 });
 
+// packages/omo-config-core/src/schema/format-on-mutation.ts
+var mode, languages, OmoFormatOnMutationLayerSchema, OmoFormatOnMutationSchema;
+var init_format_on_mutation = __esm(() => {
+  init_zod();
+  mode = _enum2(["off", "best-effort", "required"]);
+  languages = record(string2(), boolean2()).optional();
+  OmoFormatOnMutationLayerSchema = object({
+    mode: mode.optional(),
+    languages,
+    maxFileBytes: number2().int().positive().optional(),
+    timeoutMs: number2().int().positive().optional()
+  }).strict();
+  OmoFormatOnMutationSchema = OmoFormatOnMutationLayerSchema.extend({
+    mode: mode.default("best-effort"),
+    maxFileBytes: number2().int().positive().default(1048576),
+    timeoutMs: number2().int().positive().default(3000)
+  }).strict();
+});
+
 // packages/omo-config-core/src/schema/config.ts
 var OmoOpenCodeHarnessConfigSchema, OmoTypedHarnessConfigSchema, OmoConfigProfileSchema, OmoConfigSchema, OmoConfigLayerSchema;
 var init_config = __esm(() => {
@@ -17512,8 +17531,10 @@ var init_config = __esm(() => {
   init_task();
   init_team();
   init_telemetry();
+  init_format_on_mutation();
   OmoOpenCodeHarnessConfigSchema = record(string2(), unknown());
   OmoTypedHarnessConfigSchema = object({
+    formatOnMutation: OmoFormatOnMutationLayerSchema.optional(),
     categories: OmoCategoriesConfigSchema.optional(),
     agents: OmoAgentsConfigSchema.optional(),
     codegraph: OmoCodegraphSettingsLayerSchema.optional(),
@@ -17525,6 +17546,7 @@ var init_config = __esm(() => {
     telemetry: OmoTelemetrySettingsLayerSchema.optional()
   }).strict();
   OmoConfigProfileSchema = object({
+    formatOnMutation: OmoFormatOnMutationLayerSchema.optional(),
     categories: OmoCategoriesConfigSchema.optional(),
     agents: OmoAgentsConfigSchema.optional(),
     codegraph: OmoCodegraphSettingsLayerSchema.optional(),
@@ -17539,6 +17561,7 @@ var init_config = __esm(() => {
     "[codex]": OmoTypedHarnessConfigSchema.optional()
   }).strict();
   OmoConfigSchema = object({
+    formatOnMutation: OmoFormatOnMutationSchema.optional(),
     $schema: string2().optional(),
     categories: OmoCategoriesConfigSchema.optional(),
     agents: OmoAgentsConfigSchema.optional(),
@@ -17557,6 +17580,7 @@ var init_config = __esm(() => {
     legacy_migrations: record(string2(), unknown()).optional()
   }).strict();
   OmoConfigLayerSchema = object({
+    formatOnMutation: OmoFormatOnMutationLayerSchema.optional(),
     $schema: string2().optional(),
     categories: OmoCategoriesConfigSchema.optional(),
     agents: OmoAgentsConfigSchema.optional(),
@@ -17583,6 +17607,7 @@ var init_schema = __esm(() => {
   init_codegraph();
   init_config();
   init_fallback_models();
+  init_format_on_mutation();
   init_git_master();
   init_harness();
   init_memory();
@@ -18651,6 +18676,9 @@ var init_message_inspection_error = () => {};
 function getPromptGateMessagesFetchTimeoutMs() {
   return promptGateMessagesFetchTimeoutMsForTesting ?? DEFAULT_PROMPT_GATE_MESSAGES_FETCH_TIMEOUT_MS;
 }
+function getPromptGateRevalidationTimeoutMs() {
+  return promptGateRevalidationTimeoutMsForTesting ?? DEFAULT_PROMPT_REVALIDATION_TIMEOUT_MS;
+}
 async function withDispatchTimeout(operation, dispatchTimeoutMs, operationName) {
   if (dispatchTimeoutMs <= 0) {
     return operation;
@@ -18669,7 +18697,7 @@ async function withDispatchTimeout(operation, dispatchTimeoutMs, operationName)
     }
   }
 }
-var DEFAULT_PROMPT_GATE_MESSAGES_FETCH_TIMEOUT_MS = 5000, promptGateMessagesFetchTimeoutMsForTesting;
+var DEFAULT_PROMPT_GATE_MESSAGES_FETCH_TIMEOUT_MS = 5000, DEFAULT_PROMPT_REVALIDATION_TIMEOUT_MS = 5000, promptGateMessagesFetchTimeoutMsForTesting, promptGateRevalidationTimeoutMsForTesting;
 
 // packages/utils/src/prompt-async-gate/pending-tool-turn.ts
 function getPromptQuery(input) {
@@ -18866,6 +18894,7 @@ async function dispatchAfterSessionIdle(args) {
     checkStatus,
     checkToolState,
     shouldDispatch,
+    retryDispatchFailure,
     dispatch
   } = args;
   const existing = getActiveReservation(sessionID);
@@ -18920,7 +18949,9 @@ async function dispatchAfterSessionIdle(args) {
       });
       return { status: "active" };
     }
-    if (shouldDispatch?.() === false) {
+    const dispatchDecision = shouldDispatch?.();
+    const resolvedDispatchDecision = dispatchDecision !== undefined && typeof dispatchDecision !== "boolean" ? await withDispatchTimeout(dispatchDecision, Math.min(dispatchTimeoutMs, getPromptGateRevalidationTimeoutMs()), `[prompt-async-gate] ${sessionName} shouldDispatch`) : dispatchDecision;
+    if (resolvedDispatchDecision === false) {
       log(`[prompt-async-gate] ${sessionName} cancelled before dispatch`, { sessionID, source });
       return { status: "cancelled" };
     }
@@ -18936,6 +18967,7 @@ async function dispatchAfterSessionIdle(args) {
     log(`[prompt-async-gate] ${sessionName} dispatched`, { sessionID, source });
     return { status: "dispatched", response };
   } catch (error51) {
+    const queueRetryable = dispatchAttempted && retryDispatchFailure?.(error51) === true;
     if (dispatchAttempted) {
       rememberRecentPromptDispatch({
         sessionID,
@@ -18946,7 +18978,12 @@ async function dispatchAfterSessionIdle(args) {
     }
     const errorText = error51 instanceof Error ? `${error51.name}: ${error51.message}` : String(error51);
     log(`[prompt-async-gate] ${sessionName} failed`, { sessionID, source, error: errorText });
-    return { status: "failed", error: error51, dispatchAttempted };
+    return {
+      status: "failed",
+      error: error51,
+      dispatchAttempted,
+      ...queueRetryable ? { queueRetryable: true } : {}
+    };
   } finally {
     finishPromptReservation(sessionID, reservation, dispatchAttempted, postDispatchHoldMs);
   }
@@ -18999,6 +19036,7 @@ function schedulePromptQueueDrain(sessionID, delayMs) {
   promptQueueTimers.set(sessionID, timer);
 }
 function removePromptQueueEntry(sessionID, entry) {
+  promptQueueRetryStates.delete(entry.id);
   const queue = promptQueues.get(sessionID);
   if (!queue) {
     return;
@@ -19013,6 +19051,7 @@ async function drainPromptQueue(sessionID, awaitedEntry) {
   promptQueueDraining.add(sessionID);
   clearPromptQueueTimer(sessionID);
   let awaitedResult;
+  const deferredRetryIds = new Set;
   try {
     while (true) {
       const queue = promptQueues.get(sessionID);
@@ -19020,6 +19059,20 @@ async function drainPromptQueue(sessionID, awaitedEntry) {
       if (!entry) {
         break;
       }
+      const retryState = promptQueueRetryStates.get(entry.id);
+      if (entry.durableRetry && retryState?.retryAfter !== undefined && retryState.retryAfter > Date.now()) {
+        if (deferredRetryIds.has(entry.id)) {
+          const nextRetryAt = Math.min(...queue.flatMap((queued) => {
+            const retryAfter = promptQueueRetryStates.get(queued.id)?.retryAfter;
+            return retryAfter === undefined ? [] : [retryAfter];
+          }));
+          schedulePromptQueueDrain(sessionID, nextRetryAt - Date.now());
+          break;
+        }
+        deferredRetryIds.add(entry.id);
+        setPromptQueue(sessionID, [...queue.slice(1), entry]);
+        continue;
+      }
       promptQueueInFlight.set(sessionID, entry);
       const result = await dispatchAfterSessionIdle({
         sessionName: entry.sessionName,
@@ -19035,12 +19088,45 @@ async function drainPromptQueue(sessionID, awaitedEntry) {
         checkStatus: entry.checkStatus,
         checkToolState: entry.checkToolState,
         shouldDispatch: entry.shouldDispatch,
+        retryDispatchFailure: entry.retryDispatchFailure,
         dispatch: entry.dispatch
       });
       if (promptQueueInFlight.get(sessionID)?.id === entry.id) {
         promptQueueInFlight.delete(sessionID);
       }
-      if (result.status === "active" || result.status === "reserved") {
+      const retryableQueuedFailure = result.status === "failed" && (!result.dispatchAttempted || result.queueRetryable === true);
+      if (retryableQueuedFailure) {
+        const failureCount = (promptQueueRetryStates.get(entry.id)?.failureCount ?? 0) + 1;
+        if (entry.durableRetry) {
+          const exponentialBackoffMs = entry.queueRetryMs * 2 ** Math.min(failureCount, 7);
+          const retryDelayMs = Math.max(entry.postDispatchHoldMs, Math.min(exponentialBackoffMs, MAX_DURABLE_RETRY_BACKOFF_MS));
+          promptQueueRetryStates.set(entry.id, {
+            failureCount,
+            retryAfter: Date.now() + retryDelayMs
+          });
+          const currentQueue = promptQueues.get(sessionID);
+          if (currentQueue && currentQueue.length > 1) {
+            setPromptQueue(sessionID, [...currentQueue.slice(1), entry]);
+            continue;
+          }
+          schedulePromptQueueDrain(sessionID, retryDelayMs);
+          break;
+        }
+        if (failureCount >= MAX_QUEUED_RETRYABLE_FAILURES) {
+          log("[prompt-async-gate] dropping queued prompt after repeated retryable failures", {
+            sessionID,
+            source: entry.source,
+            failureCount
+          });
+          removePromptQueueEntry(sessionID, entry);
+          if (awaitedEntry?.id === entry.id) {
+            awaitedResult = result;
+          }
+          continue;
+        }
+        promptQueueRetryStates.set(entry.id, { failureCount });
+      }
+      if (result.status === "active" || result.status === "reserved" || retryableQueuedFailure) {
         const queued = queuedResult(entry, 1, result.status === "reserved" ? result.reservedBy : entry.source);
         if (awaitedEntry?.id === entry.id) {
           awaitedResult = queued;
@@ -19064,7 +19150,7 @@ async function drainPromptQueue(sessionID, awaitedEntry) {
   }
   return awaitedResult;
 }
-var promptQueues, promptQueueDraining, promptQueueInFlight, promptQueueTimers;
+var promptQueues, promptQueueDraining, promptQueueInFlight, promptQueueTimers, promptQueueRetryStates, MAX_QUEUED_RETRYABLE_FAILURES = 3, MAX_DURABLE_RETRY_BACKOFF_MS = 30000;
 var init_queue = __esm(() => {
   init_session_idle_dispatch();
   init_reservations();
@@ -19072,6 +19158,7 @@ var init_queue = __esm(() => {
   promptQueueDraining = new Set;
   promptQueueInFlight = new Map;
   promptQueueTimers = new Map;
+  promptQueueRetryStates = new Map;
   setExpiredReservationHandler((sessionID) => {
     schedulePromptQueueDrain(sessionID, 0);
   });
@@ -78070,7 +78157,17 @@ function isPreSendConnectionFailure(error51) {
   if (error51.name === "AbortError") {
     return false;
   }
-  const CONNECTION_CODES = new Set(["ECONNREFUSED", "ENOTFOUND", "EAI_AGAIN"]);
+  const CONNECTION_CODES = new Set([
+    "ECONNREFUSED",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "ENETUNREACH",
+    "EHOSTUNREACH",
+    "ENETDOWN",
+    "EHOSTDOWN",
+    "EADDRNOTAVAIL",
+    "UND_ERR_CONNECT_TIMEOUT"
+  ]);
   const self = error51;
   if (self.code && CONNECTION_CODES.has(self.code)) {
     return true;
@@ -78082,12 +78179,6 @@ function isPreSendConnectionFailure(error51) {
       return true;
     }
   }
-  if (error51 instanceof TypeError) {
-    const msg = error51.message;
-    if (msg.includes("fetch failed") || msg.includes("Unable to connect")) {
-      return true;
-    }
-  }
   return false;
 }
 function markLiveRouteUnavailable(reason) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "5.0.0-beta.25",
+  "version": "5.0.0-beta.26",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
@@ -181,7 +181,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@code-yeongyu/senpi": "2026.8.26-2",
+    "@code-yeongyu/senpi": "2026.8.28-2",
     "@oh-my-opencode/agents-md-core": "workspace:*",
     "@oh-my-opencode/ast-grep-mcp": "workspace:*",
     "@oh-my-opencode/boulder-state": "workspace:*",
@@ -222,18 +222,18 @@
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "5.0.0-beta.25",
-    "oh-my-opencode-darwin-x64": "5.0.0-beta.25",
-    "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.25",
-    "oh-my-opencode-linux-arm64": "5.0.0-beta.25",
-    "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.25",
-    "oh-my-opencode-linux-x64": "5.0.0-beta.25",
-    "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.25",
-    "oh-my-opencode-linux-x64-musl": "5.0.0-beta.25",
-    "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.25",
-    "oh-my-opencode-windows-arm64": "5.0.0-beta.25",
-    "oh-my-opencode-windows-x64": "5.0.0-beta.25",
-    "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.25"
+    "oh-my-opencode-darwin-arm64": "5.0.0-beta.26",
+    "oh-my-opencode-darwin-x64": "5.0.0-beta.26",
+    "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.26",
+    "oh-my-opencode-linux-arm64": "5.0.0-beta.26",
+    "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.26",
+    "oh-my-opencode-linux-x64": "5.0.0-beta.26",
+    "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.26",
+    "oh-my-opencode-linux-x64-musl": "5.0.0-beta.26",
+    "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.26",
+    "oh-my-opencode-windows-arm64": "5.0.0-beta.26",
+    "oh-my-opencode-windows-x64": "5.0.0-beta.26",
+    "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.26"
   },
   "overrides": {
     "@earendil-works/pi-agent-core": "0.84.2",
@@ -249,5 +249,8 @@
   },
   "trustedDependencies": [
     "@code-yeongyu/comment-checker"
-  ]
+  ],
+  "patchedDependencies": {
+    "@code-yeongyu/senpi@2026.8.28-2": "patches/@code-yeongyu%2Fsenpi@2026.8.28-2.patch"
+  }
 }

package/packages/lsp-core/src/index.ts

@@ -7,6 +7,7 @@ export * from "./lsp/constants.js";
 export * from "./lsp/directory-diagnostics.js";
 export * from "./lsp/effective-extension.js";
 export * from "./lsp/errors.js";
+export * from "./lsp/format-document.js";
 export * from "./lsp/formatters.js";
 export * from "./lsp/infer-extension.js";
 export * from "./lsp/json-rpc-connection.js";