@ordewell/core 0.4.16 → 0.4.18

package/dist/index.d.mts

@@ -2255,9 +2255,32 @@ declare class OpenCodeAdapter implements AgentAdapter {
     private opts;
     /** Whether this turn has already emitted reply text — see {@link emitPart}. */
     private turnHasText;
+    /** The last assistant message already settled — the baseline {@link recoverReply} measures a new reply against. */
+    private lastAssistantId;
     constructor(deps: AgentProcessDeps);
     start(opts: AgentStartOptions): Promise<void>;
     send(message: string, onEvent: (event: AgentEvent) => void, signal?: AbortSignal, onActivity?: () => void): Promise<void>;
+    /**
+     * 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.
+     */
+    private settle;
+    /**
+     * 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.
+     */
+    private recoverReply;
+    private newestAssistantId;
     /**
      * 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
@@ -2302,7 +2325,7 @@ declare function mapAgentTool(name: string): MappedTool;
  */
 declare function normalizeAgentArgs(tool: ResearchToolType, args: Record<string, unknown>): Record<string, unknown>;
 
-declare const BUILTIN_SKILL_NAMES: readonly ["grilling", "to-spec"];
+declare const BUILTIN_SKILL_NAMES: readonly ["grilling", "to-spec", "improve-codebase-architecture"];
 interface SkillMetadata {
     name: string;
     description: string;

package/dist/index.d.ts

@@ -2255,9 +2255,32 @@ declare class OpenCodeAdapter implements AgentAdapter {
     private opts;
     /** Whether this turn has already emitted reply text — see {@link emitPart}. */
     private turnHasText;
+    /** The last assistant message already settled — the baseline {@link recoverReply} measures a new reply against. */
+    private lastAssistantId;
     constructor(deps: AgentProcessDeps);
     start(opts: AgentStartOptions): Promise<void>;
     send(message: string, onEvent: (event: AgentEvent) => void, signal?: AbortSignal, onActivity?: () => void): Promise<void>;
+    /**
+     * 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.
+     */
+    private settle;
+    /**
+     * 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.
+     */
+    private recoverReply;
+    private newestAssistantId;
     /**
      * 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
@@ -2302,7 +2325,7 @@ declare function mapAgentTool(name: string): MappedTool;
  */
 declare function normalizeAgentArgs(tool: ResearchToolType, args: Record<string, unknown>): Record<string, unknown>;
 
-declare const BUILTIN_SKILL_NAMES: readonly ["grilling", "to-spec"];
+declare const BUILTIN_SKILL_NAMES: readonly ["grilling", "to-spec", "improve-codebase-architecture"];
 interface SkillMetadata {
     name: string;
     description: string;

package/dist/index.js

@@ -11528,6 +11528,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,
@@ -11540,6 +11542,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;
@@ -11555,6 +11584,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 });
@@ -11608,6 +11639,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;
       }
     }
@@ -11658,29 +11691,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
@@ -12586,7 +12666,7 @@ function builtinSkillsDir() {
 }
 
 // src/services/SkillsService.ts
-var BUILTIN_SKILL_NAMES = ["grilling", "to-spec"];
+var BUILTIN_SKILL_NAMES = ["grilling", "to-spec", "improve-codebase-architecture"];
 var RETIRED_BUILTIN_SKILL_NAMES = ["grill-me"];
 function parseSkillFile(filePath, name, source) {
   const raw = fs4.readFileSync(filePath, "utf8");