@ordewell/core 0.4.17 → 0.4.19

package/dist/index.mjs

@@ -6281,19 +6281,29 @@ var VerdictEngine = class {
       for (const l of this.idleListeners) l(taskId, null);
     }
   }
+  /**
+   * Submit a synchronized resume token to the paused session. An interactive
+   * TUI only accepts the Enter keystroke (`\r`) — a `\n` types the token into
+   * its composer without sending it, leaving the agent paused until a human
+   * presses Enter. A line-oriented piped session has no composer; it reads a
+   * `\n`-terminated line, and the leading newline flushes a partial line.
+   */
+  resumeToken(session, line) {
+    return session.interactive ? `${line}\r` : `
+${line}
+`;
+  }
   approveCheckpoint(taskId) {
     const session = this.pausedSessions.get(taskId);
     if (session) {
-      session.write("\nORDEWELL_CONTINUE\n");
+      session.write(this.resumeToken(session, "ORDEWELL_CONTINUE"));
       this.pausedSessions.delete(taskId);
     }
   }
   rejectCheckpoint(taskId, reason) {
     const session = this.pausedSessions.get(taskId);
     if (session) {
-      session.write(`
-ORDEWELL_REJECT: ${reason}
-`);
+      session.write(this.resumeToken(session, `ORDEWELL_REJECT: ${reason}`));
       this.pausedSessions.delete(taskId);
     }
   }
@@ -9695,6 +9705,8 @@ ${item.text}` : item.text });
 var SERVER_READY_TIMEOUT_MS = 3e4;
 var STDERR_TAIL_CHARS2 = 4e3;
 var STREAM_CONNECT_TIMEOUT_MS = 5e3;
+var RECOVERY_POLL_INTERVAL_MS = 2e3;
+var RECOVERY_TIMEOUT_MS = 9e5;
 var DISABLED_TOOLS = {
   question: false,
   edit: false,
@@ -9707,6 +9719,33 @@ function splitModelId(id) {
   if (slash <= 0 || slash === id.length - 1) return null;
   return { providerID: id.slice(0, slash), modelID: id.slice(slash + 1) };
 }
+function describeError(err) {
+  const visited = /* @__PURE__ */ new Set();
+  const lines = [];
+  let current = err;
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    if (!(current instanceof Error)) {
+      lines.push(String(current));
+      break;
+    }
+    const code = current.code;
+    const suffix = typeof code === "string" && !current.message.includes(code) ? ` (${code})` : "";
+    lines.push(`${current.message}${suffix}`);
+    current = current.cause;
+  }
+  return lines.join(": ");
+}
+function delay(ms, signal) {
+  return new Promise((resolve4) => {
+    const timer = setTimeout(resolve4, ms);
+    timer.unref?.();
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      resolve4();
+    }, { once: true });
+  });
+}
 var OpenCodeAdapter = class {
   constructor(deps) {
     this.deps = deps;
@@ -9722,6 +9761,8 @@ var OpenCodeAdapter = class {
   opts = null;
   /** Whether this turn has already emitted reply text — see {@link emitPart}. */
   turnHasText = false;
+  /** The last assistant message already settled — the baseline {@link recoverReply} measures a new reply against. */
+  lastAssistantId = null;
   async start(opts) {
     this.opts = opts;
     assertWorkspaceExists(opts.cwd, { isDirectory: this.deps.isDirectory });
@@ -9775,6 +9816,8 @@ ${this.stderrTail.trim()}` : ""}`);
       const existing = await this.json("GET", `/session/${opts.resumeSessionId}`).catch(() => null);
       if (existing?.id) {
         this.sessionId = existing.id;
+        const history = await this.json("GET", `/session/${existing.id}/message`).catch(() => null);
+        this.lastAssistantId = this.newestAssistantId(history);
         return;
       }
     }
@@ -9825,29 +9868,76 @@ ${this.stderrTail.trim()}` : ""}`);
         this.dispose();
         return;
       }
-      const failure = typeof reply?.error === "string" ? reply.error : reply?.error?.message ?? reply?.info?.error?.data?.message;
-      if (failure) {
-        onEvent({ type: "error", message: failure });
-        return;
-      }
-      const assistantId = reply?.info?.id;
-      for (const part of reply?.parts ?? []) {
-        if (part.type !== "tool" && assistantId && part.messageID !== assistantId) continue;
-        this.emitPart(part, seen, onEvent);
-      }
-      onEvent({ type: "turn_end" });
+      this.settle(reply, seen, onEvent);
     } catch (err) {
       if (signal?.aborted) {
         this.dispose();
         return;
       }
-      onEvent({ type: "error", message: `The OpenCode planner turn failed: ${err instanceof Error ? err.message : String(err)}` });
+      const recovered = this.exited ? null : await this.recoverReply(signal, onActivity);
+      if (recovered) {
+        this.settle(recovered, seen, onEvent);
+        return;
+      }
+      onEvent({ type: "error", message: `The OpenCode planner turn failed: ${describeError(err)}` });
     } finally {
       streamAbort.abort();
       await live.catch(() => {
       });
     }
   }
+  /**
+   * Turn one settled assistant message into events. The settled response is
+   * authoritative: it names the assistant message, so its parts are the ones
+   * that make up the reply. Tool parts already seen live are deduplicated by
+   * call id; anything the stream missed (including a stream that never
+   * connected) arrives here.
+   */
+  settle(reply, seen, onEvent) {
+    const failure = typeof reply?.error === "string" ? reply.error : reply?.error?.message ?? reply?.info?.error?.data?.message;
+    if (failure) {
+      onEvent({ type: "error", message: failure });
+      return;
+    }
+    const assistantId = reply?.info?.id;
+    for (const part of reply?.parts ?? []) {
+      if (part.type !== "tool" && assistantId && part.messageID !== assistantId) continue;
+      this.emitPart(part, seen, onEvent);
+    }
+    if (assistantId) this.lastAssistantId = assistantId;
+    onEvent({ type: "turn_end" });
+  }
+  /**
+   * Poll the session for this turn's assistant message after the POST's socket
+   * died under it. Node's global `fetch` is undici, which aborts a request
+   * whose response headers have not arrived within 300s — and OpenCode sends
+   * none until the turn is done, so any turn past five minutes fails as
+   * `TypeError: fetch failed` while the server is still working. The message
+   * exists server-side either way, so it is waited for and read back.
+   *
+   * A message that exists but has not completed is progress, not an answer:
+   * it refreshes the watchdog and the poll continues.
+   */
+  async recoverReply(signal, onActivity) {
+    const deadline = Date.now() + RECOVERY_TIMEOUT_MS;
+    for (; ; ) {
+      if (signal?.aborted || this.exited || this.disposed || !this.sessionId) return null;
+      const messages = await this.json("GET", `/session/${this.sessionId}/message`).catch(() => null);
+      const pending = Array.isArray(messages) ? [...messages].reverse().find((m) => m.info?.role === "assistant" && m.info.id && m.info.id !== this.lastAssistantId) : void 0;
+      if (pending?.info?.time?.completed || pending?.info?.error) return pending;
+      if (pending) onActivity?.();
+      if (Date.now() >= deadline) return null;
+      await delay(RECOVERY_POLL_INTERVAL_MS, signal);
+    }
+  }
+  newestAssistantId(messages) {
+    if (!Array.isArray(messages)) return null;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const info = messages[i]?.info;
+      if (info?.role === "assistant" && info.id) return info.id;
+    }
+    return null;
+  }
   /**
    * Emit one message part, once. OpenCode reports a tool part repeatedly as it
    * moves through pending → running → completed, so parts are keyed by id and
@@ -12604,11 +12694,13 @@ function defaultHasScriptCmd() {
   }
 }
 var HeadlessSession = class extends AbstractTerminalSession {
-  constructor(id, taskId, spawnImpl) {
+  constructor(id, taskId, spawnImpl, interactive = false) {
     super(id, taskId);
     this.spawnImpl = spawnImpl;
+    this.interactive = interactive;
   }
   spawnImpl;
+  interactive;
   process = null;
   outputBuffer = "";
   controlStream = null;
@@ -12690,7 +12782,7 @@ var HeadlessRunner = class extends AbstractRunner {
     this.launchDeps = { resolvePath: this.resolvePath, ...deps.launchDeps };
   }
   createSession(id, taskId) {
-    return new HeadlessSession(id, taskId, this.spawnImpl);
+    return new HeadlessSession(id, taskId, this.spawnImpl, this.defaultInteractive);
   }
   /** Everything up to, but not including, spawning — so a surface that owns its own child reaches the same decisions. */
   async prepareLaunch(opts, ptyOptions) {
@@ -12807,6 +12899,8 @@ var TmuxSession = class extends AbstractTerminalSession {
   pollIntervalMs;
   logPath;
   socket;
+  /** A tmux window is a real TTY running the agent's TUI, so it submits on Enter. */
+  interactive = true;
   outputBuffer = "";
   offset = 0;
   timer = null;