@diologue/local-agent 0.1.5 → 0.3.0

package/dist/cli.mjs

@@ -81,9 +81,11 @@ var init_engine_release = __esm({
 
 // src/lib/engine-bundle.ts
 import { access as access2, constants } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
 import path3 from "node:path";
 import { fileURLToPath } from "node:url";
-var engineRelease, __filename, __dirname, LOCAL_AGENT_ROOT, REPO_ROOT, BUNDLE_DIR_INSTALLED, BUNDLE_DIR_LOCAL_BUILD, ENGINE_BUNDLE_ENV, exists2, bundleFilename, findEngineBundle;
+var engineRelease, __filename, __dirname, LOCAL_AGENT_ROOT, REPO_ROOT, BUNDLE_DIR_INSTALLED, BUNDLE_DIR_LOCAL_BUILD, ENGINE_BUNDLE_ENV, exists2, resolveOpencodeAiBinary, bundleFilename, findEngineBundle;
 var init_engine_bundle = __esm({
   "src/lib/engine-bundle.ts"() {
     "use strict";
@@ -111,6 +113,19 @@ var init_engine_bundle = __esm({
         return false;
       }
     };
+    resolveOpencodeAiBinary = () => {
+      try {
+        const require2 = createRequire(import.meta.url);
+        const pkgJsonPath = require2.resolve("opencode-ai/package.json");
+        const pkgDir = path3.dirname(pkgJsonPath);
+        const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+        const binRel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.opencode;
+        if (!binRel) return null;
+        return path3.join(pkgDir, binRel);
+      } catch {
+        return null;
+      }
+    };
     bundleFilename = (platform = process.platform, arch = process.arch) => {
       const target = engineRelease.targets.find(
         (t) => t.platform === platform && t.arch === arch
@@ -125,6 +140,10 @@ var init_engine_bundle = __esm({
           return { path: fromEnv, source: "env" };
         }
       }
+      const opencodeAi = resolveOpencodeAiBinary();
+      if (opencodeAi && await exists2(opencodeAi)) {
+        return { path: opencodeAi, source: "opencode-ai" };
+      }
       const filename = bundleFilename();
       const installed = path3.join(BUNDLE_DIR_INSTALLED, filename);
       if (await exists2(installed)) {
@@ -148,7 +167,7 @@ import { access as access3, constants as constants2 } from "node:fs/promises";
 import { spawn as spawn2 } from "node:child_process";
 import path4 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var __filename2, __dirname2, REPO_ROOT2, DEFAULT_ENGINE_DIR, ENTRY_REL, DEFAULT_STARTUP_TIMEOUT_MS, LISTENING_REGEX, defaultRuntimeCheck, exists3, defaultClientFactory, LocalEngineLocator, truncate;
+var __filename2, __dirname2, REPO_ROOT2, DEFAULT_ENGINE_DIR, ENTRY_REL, DEFAULT_STARTUP_TIMEOUT_MS, LISTENING_REGEX, defaultRuntimeCheck, exists3, isRecord, parseExistingInlineConfig, mergeInlineConfig, buildEngineEnv, defaultClientFactory, LocalEngineLocator, truncate;
 var init_engine_locator_local = __esm({
   "src/adapters/engine-locator-local.ts"() {
     "use strict";
@@ -173,6 +192,37 @@ var init_engine_locator_local = __esm({
         return false;
       }
     };
+    isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+    parseExistingInlineConfig = (existing) => {
+      if (!existing) return {};
+      try {
+        const parsed = JSON.parse(existing);
+        return isRecord(parsed) ? parsed : {};
+      } catch {
+        return {};
+      }
+    };
+    mergeInlineConfig = (existing, injected) => {
+      if (!injected) return existing;
+      const base = parseExistingInlineConfig(existing);
+      const baseProvider = isRecord(base.provider) ? base.provider : {};
+      return JSON.stringify({
+        ...base,
+        ...injected,
+        provider: {
+          ...baseProvider,
+          ...injected.provider ?? {}
+        }
+      });
+    };
+    buildEngineEnv = (config) => {
+      const env = { ...process.env };
+      const content = mergeInlineConfig(env.OPENCODE_CONFIG_CONTENT, config);
+      if (content) {
+        env.OPENCODE_CONFIG_CONTENT = content;
+      }
+      return env;
+    };
     defaultClientFactory = async (baseUrl) => {
       const sdk = await import("@opencode-ai/sdk");
       return sdk.createOpencodeClient({ baseUrl });
@@ -262,13 +312,12 @@ var init_engine_locator_local = __esm({
         const child = spawn2(command, args, {
           cwd,
           stdio: ["ignore", "pipe", "pipe"],
-          // Inherit env so the engine sees any LOCAL_AGENT_* / Provider
-          // credentials the parent has, plus inject the shim config via
-          // OPENCODE_CONFIG-style env once V2.5 wires that. (For now the
-          // config flows through createOpencodeServer in the npm path
-          // and is wired post-spawn here — TODO once we cut the npm
-          // SDK entirely, we'll pipe the config in via stdin or args.)
-          env: process.env
+          // Inherit env so the engine sees any LOCAL_AGENT_* / provider
+          // credentials the parent has, then inject the brokered provider as
+          // inline opencode config. Without this, the default local engine path
+          // does not know the diologue/diologue-routed model, so the prompt
+          // fails before edit tools can create files in the selected repo.
+          env: buildEngineEnv(options.config)
         });
         let url;
         try {
@@ -485,6 +534,9 @@ var createCorsMiddleware = (options) => {
         `Content-Type, ${LOCAL_AGENT_TOKEN_HEADER}`
       );
       res.setHeader("Access-Control-Max-Age", "300");
+      if (req.header("access-control-request-private-network") === "true") {
+        res.setHeader("Access-Control-Allow-Private-Network", "true");
+      }
     }
     if (req.method === "OPTIONS") {
       res.status(204).end();
@@ -622,8 +674,56 @@ var getStatusShort = async (cwd) => {
   const out = await runGit(cwd, ["status", "--short", "-uall"]);
   return parseShortStatus(out);
 };
+var runGitAllowingExit = (cwd, args, allowedExitCodes) => new Promise((resolve, reject) => {
+  execFile(
+    "git",
+    args,
+    {
+      cwd,
+      maxBuffer: 16 * 1024 * 1024,
+      env: { ...process.env, GIT_PAGER: "cat", PAGER: "cat" }
+    },
+    (err, stdout, stderr) => {
+      if (!err) {
+        resolve(stdout);
+        return;
+      }
+      const e = err;
+      const exitCode = e.code ?? -1;
+      if (allowedExitCodes.has(exitCode)) {
+        resolve(stdout);
+        return;
+      }
+      reject(new GitCommandError(args, exitCode, stderr));
+    }
+  );
+});
+var getUntrackedFiles = async (cwd) => {
+  const out = await runGit(cwd, [
+    "ls-files",
+    "--others",
+    "--exclude-standard",
+    "-z"
+  ]);
+  return out.split("\0").filter(Boolean);
+};
+var getUntrackedFileDiff = async (cwd, file) => {
+  const diff = await runGitAllowingExit(
+    cwd,
+    ["diff", "--no-index", "--", "/dev/null", file],
+    /* @__PURE__ */ new Set([1])
+  );
+  return diff.replace(/^diff --git a\/dev\/null b\/(.+)$/m, "diff --git a/$1 b/$1").replace(/^--- \/dev\/null$/m, "--- /dev/null");
+};
 var getDiff = async (cwd) => {
-  return runGit(cwd, ["diff", "HEAD"]);
+  const [trackedDiff, untrackedFiles] = await Promise.all([
+    runGit(cwd, ["diff", "HEAD"]),
+    getUntrackedFiles(cwd)
+  ]);
+  const untrackedDiffs = await Promise.all(
+    untrackedFiles.map((file) => getUntrackedFileDiff(cwd, file))
+  );
+  return [trackedDiff, ...untrackedDiffs].filter((part) => part.trim().length > 0).join("\n");
 };
 var runGitWithStdin = async (cwd, args, input) => {
   const { execFile: execFile2 } = await import("node:child_process");
@@ -663,6 +763,20 @@ var canApplyDiff = async (cwd, unified) => {
 var applyDiff = async (cwd, unified) => {
   await runGitWithStdin(cwd, ["apply"], unified);
 };
+var canRevertDiff = async (cwd, unified) => {
+  try {
+    await runGitWithStdin(cwd, ["apply", "--reverse", "--check"], unified);
+    return { ok: true };
+  } catch (err) {
+    if (err instanceof GitCommandError) {
+      return { ok: false, stderr: err.stderr };
+    }
+    throw err;
+  }
+};
+var revertDiff = async (cwd, unified) => {
+  await runGitWithStdin(cwd, ["apply", "--reverse"], unified);
+};
 var parseDiffPaths = (unified) => {
   const paths = [];
   for (const line of unified.split("\n")) {
@@ -742,6 +856,9 @@ var applyPatchSchema = z.object({
   unified: z.string().min(1).max(8 * 1024 * 1024),
   baselineHash: z.string().optional()
 });
+var revertPatchSchema = z.object({
+  unified: z.string().min(1).max(8 * 1024 * 1024)
+});
 var buildRepoStatus = async (resolvedPath) => {
   const [branch, head, dirty] = await Promise.all([
     getBranch(resolvedPath),
@@ -891,6 +1008,40 @@ var createRepoRouter = (state) => {
       throw err;
     }
   });
+  router.post("/revert", async (req, res) => {
+    const repo = requireSelectedRepo(state, res);
+    if (!repo) return;
+    const parsed = revertPatchSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: "invalid_body", issues: parsed.error.issues });
+      return;
+    }
+    try {
+      const check = await canRevertDiff(repo.path, parsed.data.unified);
+      if (!check.ok) {
+        res.status(409).json({
+          error: "diff_does_not_revert",
+          message: "These changes can't be reverted cleanly. The working tree may have changed since the agent wrote them, or they were already reverted.",
+          stderr: check.stderr
+        });
+        return;
+      }
+      await revertDiff(repo.path, parsed.data.unified);
+      const paths = parseDiffPaths(parsed.data.unified);
+      const body = {
+        ok: true,
+        filesChanged: paths.length,
+        paths
+      };
+      res.json(body);
+    } catch (err) {
+      if (err instanceof GitCommandError) {
+        sendGitError(res, err);
+        return;
+      }
+      throw err;
+    }
+  });
   return router;
 };
 
@@ -900,6 +1051,9 @@ import { z as z2 } from "zod";
 
 // src/broker.ts
 import { randomUUID } from "node:crypto";
+var logBroker = (message) => {
+  console.error(`[llm-broker] ${message}`);
+};
 var LlmBroker = class {
   pending = /* @__PURE__ */ new Map();
   emit;
@@ -929,13 +1083,18 @@ var LlmBroker = class {
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(requestId);
+        logBroker(
+          `timeout request=${requestId.slice(0, 8)} pending=${this.pending.size} after=${this.timeoutMs}ms`
+        );
         reject(
           new Error(
             `llm_broker_timeout: no response within ${this.timeoutMs}ms`
           )
         );
       }, this.timeoutMs);
-      timer.unref?.();
+      if (this.timeoutMs >= 1e3) {
+        timer.unref?.();
+      }
       this.pending.set(requestId, { resolve, reject, timer, observer });
       const effectiveProvider = this.overrideProvider ?? payload.provider;
       const effectiveModel = this.overrideModel ?? payload.model;
@@ -952,6 +1111,9 @@ var LlmBroker = class {
         }
       };
       try {
+        logBroker(
+          `emit request=${requestId.slice(0, 8)} provider=${effectiveProvider ?? "(default)"} model=${effectiveModel ?? "(default)"} messages=${payload.messages.length} tools=${payload.tools?.length ?? 0}`
+        );
         this.emit(envelope);
       } catch (err) {
         clearTimeout(timer);
@@ -976,7 +1138,14 @@ var LlmBroker = class {
    *  route (e.g. for providers that don't support streaming). */
   fulfill(requestId, response) {
     const entry = this.pending.get(requestId);
-    if (!entry) return false;
+    if (!entry) {
+      logBroker(`fulfill_miss request=${requestId.slice(0, 8)}`);
+      return false;
+    }
+    const toolNames = (response.toolCalls ?? []).map((tc) => tc.function?.name ?? "?").join(",");
+    logBroker(
+      `fulfill request=${requestId.slice(0, 8)} text=${response.text.length} toolCalls=${response.toolCalls?.length ?? 0}${toolNames ? ` tools=[${toolNames}]` : ""} finish=${response.finishReason ?? "(none)"}`
+    );
     clearTimeout(entry.timer);
     this.pending.delete(requestId);
     if (entry.observer) {
@@ -1005,7 +1174,15 @@ var LlmBroker = class {
    *  invoked; a `complete` chunk also resolves the pending Promise. */
   pushChunk(requestId, chunk) {
     const entry = this.pending.get(requestId);
-    if (!entry) return false;
+    if (!entry) {
+      logBroker(
+        `chunk_miss request=${requestId.slice(0, 8)} type=${chunk.type}`
+      );
+      return false;
+    }
+    logBroker(
+      `chunk request=${requestId.slice(0, 8)} type=${chunk.type}${chunk.type === "text_delta" ? ` chars=${chunk.text.length}` : ""}${chunk.type === "tool_call_delta" ? ` index=${chunk.index} name=${chunk.name ?? "(delta)"} argsDelta=${chunk.argumentsDelta?.length ?? 0}` : ""}`
+    );
     if (entry.observer) {
       try {
         entry.observer(chunk);
@@ -1027,7 +1204,11 @@ var LlmBroker = class {
    *  failure rather than a completion. */
   fail(requestId, message) {
     const entry = this.pending.get(requestId);
-    if (!entry) return false;
+    if (!entry) {
+      logBroker(`fail_miss request=${requestId.slice(0, 8)}`);
+      return false;
+    }
+    logBroker(`fail request=${requestId.slice(0, 8)} message=${message}`);
     clearTimeout(entry.timer);
     this.pending.delete(requestId);
     entry.reject(new Error(message));
@@ -1036,6 +1217,9 @@ var LlmBroker = class {
   /** Reject all in-flight requests. Called when the parent SSE stream
    *  closes so a stranded request doesn't sit forever. */
   close(reason = "broker_closed") {
+    if (this.pending.size > 0) {
+      logBroker(`close reason=${reason} pending=${this.pending.size}`);
+    }
     this.closed = true;
     for (const [, entry] of this.pending.entries()) {
       clearTimeout(entry.timer);
@@ -1092,6 +1276,9 @@ var writeEvent = (res, event) => {
 var writeDone = (res) => {
   res.write("data: [DONE]\n\n");
 };
+var logAgentRoute = (message) => {
+  console.error(`[agent-route] ${message}`);
+};
 var createAgentRouter = (deps) => {
   const router = createRouter2();
   router.post("/message", async (req, res) => {
@@ -1105,6 +1292,9 @@ var createAgentRouter = (deps) => {
       res.status(409).json({ error: "no_repo_selected" });
       return;
     }
+    logAgentRoute(
+      `message start session=${parsed.data.sessionId.slice(0, 8)} repo=${repo.path} promptChars=${parsed.data.prompt.length} provider=${parsed.data.preferredProvider ?? "(default)"} model=${parsed.data.preferredModel ?? "(default)"}`
+    );
     res.setHeader("Content-Type", "text/event-stream");
     res.setHeader("Cache-Control", "no-cache, no-transform");
     res.setHeader("Connection", "keep-alive");
@@ -1130,21 +1320,33 @@ var createAgentRouter = (deps) => {
         prompt: parsed.data.prompt,
         history,
         signal: controller.signal,
-        broker: (payload) => broker.request(payload),
+        broker: (payload, observer) => broker.request(payload, observer),
         preferredProvider: parsed.data.preferredProvider,
         preferredModel: parsed.data.preferredModel
       })) {
         if (controller.signal.aborted) {
+          logAgentRoute(
+            `message aborted session=${parsed.data.sessionId.slice(0, 8)}`
+          );
           break;
         }
+        logAgentRoute(
+          `stream event session=${parsed.data.sessionId.slice(0, 8)} type=${event.type}`
+        );
         writeEvent(res, event);
       }
+      logAgentRoute(
+        `message done session=${parsed.data.sessionId.slice(0, 8)}`
+      );
       writeDone(res);
     } catch (err) {
       if (err && typeof err === "object" && "name" in err && err.name === "AbortError") {
         writeDone(res);
       } else {
         const message = err instanceof Error ? err.message : "Adapter stream failed";
+        logAgentRoute(
+          `message error session=${parsed.data.sessionId.slice(0, 8)} error=${message}`
+        );
         writeEvent(res, { type: "error", message });
         writeDone(res);
       }
@@ -1161,7 +1363,10 @@ var llmResponseBodySchema = z2.object({
   text: z2.string(),
   provider: z2.string().min(1),
   model: z2.string().min(1),
-  tokenUsage: z2.object({ input: z2.number().nonnegative(), output: z2.number().nonnegative() }).optional(),
+  tokenUsage: z2.object({
+    input: z2.number().nonnegative(),
+    output: z2.number().nonnegative()
+  }).optional(),
   error: z2.string().optional(),
   toolCalls: z2.array(
     z2.object({
@@ -2266,6 +2471,11 @@ var createEngineLocator = async (name) => {
 init_engine_locator_npm();
 var DIOLOGUE_PROVIDER_ID = "diologue";
 var DIOLOGUE_MODEL_ID = "diologue-routed";
+var END_OF_TURN_GRACE_MS = 600;
+var EDIT_DIRECTIVE = "You are an autonomous coding agent operating on a real git repository. Carry out the request by editing files directly with your tools (write / edit / patch / bash) \u2014 do not just describe the change, outline steps, or print code for the user to copy. Read only what you need, make the edits on disk, and finish once the change has actually been written.";
+var logAdapter = (message) => {
+  console.error(`[opencode-adapter] ${message}`);
+};
 var OpenCodeProcessAdapter = class {
   constructor(options = {}) {
     this.options = options;
@@ -2316,7 +2526,16 @@ var OpenCodeProcessAdapter = class {
           }
         }
       },
-      model: `${DIOLOGUE_PROVIDER_ID}/${DIOLOGUE_MODEL_ID}`
+      model: `${DIOLOGUE_PROVIDER_ID}/${DIOLOGUE_MODEL_ID}`,
+      // Auto-approve tool execution. opencode gates edit/bash/webfetch
+      // behind a permission prompt; this helper runs headless with no
+      // approver, so without this the agent's writes are never applied to
+      // the repo and a turn finishes having changed nothing.
+      permission: {
+        edit: "allow",
+        bash: "allow",
+        webfetch: "allow"
+      }
     };
   }
   async ensureServer() {
@@ -2325,7 +2544,10 @@ var OpenCodeProcessAdapter = class {
     }
     this.serverPromise = (async () => {
       const locator = await this.resolveLocator();
-      return locator.start({ config: this.buildShimConfig() });
+      logAdapter(`starting engine helperBase=${this.resolveHelperBaseUrl()}`);
+      const handle = await locator.start({ config: this.buildShimConfig() });
+      logAdapter(`engine ready url=${handle.url}`);
+      return handle;
     })();
     try {
       return await this.serverPromise;
@@ -2336,7 +2558,13 @@ var OpenCodeProcessAdapter = class {
   }
   async ensureOpencodeSession(handle, ourSessionId, repoPath, title) {
     const existing = this.sessionMap.get(ourSessionId);
-    if (existing) return existing;
+    if (existing) {
+      logAdapter(
+        `reuse opencodeSession=${existing.slice(0, 8)} session=${ourSessionId.slice(0, 8)} repo=${repoPath}`
+      );
+      return existing;
+    }
+    logAdapter(`create session=${ourSessionId.slice(0, 8)} repo=${repoPath}`);
     const created = await handle.client.session.create({
       body: { title },
       query: { directory: repoPath }
@@ -2346,6 +2574,9 @@ var OpenCodeProcessAdapter = class {
       throw new Error("opencode session.create returned no id");
     }
     this.sessionMap.set(ourSessionId, id);
+    logAdapter(
+      `created opencodeSession=${id.slice(0, 8)} session=${ourSessionId.slice(0, 8)}`
+    );
     return id;
   }
   async *streamMessage(request) {
@@ -2391,16 +2622,16 @@ var OpenCodeProcessAdapter = class {
         }
       });
       const realCallback = callback;
-      streamScopedBroker.request = async (payload) => {
-        return realCallback(payload);
+      streamScopedBroker.request = async (payload, observer) => {
+        return realCallback(payload, observer);
       };
       activeBrokerHandle = bindActiveBroker(streamScopedBroker);
-      console.error(
-        `[opencode-adapter] bound active broker token="${activeBrokerHandle.token.slice(0, 12)}\u2026" session=${request.sessionId.slice(0, 8)}`
+      logAdapter(
+        `bound active broker token="${activeBrokerHandle.token.slice(0, 12)}\u2026" session=${request.sessionId.slice(0, 8)}`
       );
     } else {
-      console.error(
-        `[opencode-adapter] WARNING: request.broker is missing for session=${request.sessionId.slice(0, 8)} \u2014 shim will 401`
+      logAdapter(
+        `WARNING request.broker missing session=${request.sessionId.slice(0, 8)}; shim will 401`
       );
     }
     const eventController = new AbortController();
@@ -2417,6 +2648,9 @@ var OpenCodeProcessAdapter = class {
         signal: eventController.signal
       });
       eventStream = res.stream;
+      logAdapter(
+        `subscribed events session=${request.sessionId.slice(0, 8)} opencodeSession=${openCodeSessionId.slice(0, 8)}`
+      );
     } catch (err) {
       yield {
         type: "error",
@@ -2427,7 +2661,11 @@ var OpenCodeProcessAdapter = class {
       return;
     }
     const promptBody = {
-      parts: [{ type: "text", text: request.prompt }]
+      parts: [
+        { type: "text", text: `${EDIT_DIRECTIVE}
+
+${request.prompt}` }
+      ]
     };
     if (streamScopedBroker && activeBrokerHandle) {
       promptBody.model = {
@@ -2435,22 +2673,63 @@ var OpenCodeProcessAdapter = class {
         modelID: DIOLOGUE_MODEL_ID
       };
     }
+    logAdapter(
+      `prompt start session=${request.sessionId.slice(0, 8)} opencodeSession=${openCodeSessionId.slice(0, 8)} promptChars=${request.prompt.length} provider=${request.preferredProvider ?? "(default)"} model=${request.preferredModel ?? "(default)"}`
+    );
     const promptPromise = handle.client.session.prompt({
       path: { id: openCodeSessionId },
       query: { directory: request.repoPath },
       body: promptBody
+    }).then((value) => {
+      logAdapter(
+        `prompt accepted session=${request.sessionId.slice(0, 8)} opencodeSession=${openCodeSessionId.slice(0, 8)}`
+      );
+      return value;
     }).catch((err) => {
-      return err instanceof Error ? err : new Error(String(err));
+      const error = err instanceof Error ? err : new Error(String(err));
+      logAdapter(
+        `prompt failed session=${request.sessionId.slice(0, 8)} opencodeSession=${openCodeSessionId.slice(0, 8)} error=${error.message}`
+      );
+      return error;
+    });
+    let stopConsuming = false;
+    const stopSignal = new Promise((resolve) => {
+      void promptPromise.finally(() => {
+        setTimeout(() => {
+          stopConsuming = true;
+          resolve("stop");
+        }, END_OF_TURN_GRACE_MS);
+      });
     });
+    let emittedDone = false;
+    const iterator = eventStream[Symbol.asyncIterator]();
     try {
-      for await (const item of eventStream) {
+      while (!stopConsuming) {
         if (request.signal?.aborted) break;
+        const nextP = iterator.next();
+        const next = await Promise.race([
+          nextP,
+          stopSignal.then(() => null)
+        ]);
+        if (next === null) {
+          void nextP.catch(() => void 0);
+          break;
+        }
+        if (next.done) break;
+        const rawItem = next.value;
+        const item = "payload" in rawItem && rawItem.payload ? rawItem.payload : rawItem;
         const mapped = mapEvent(item, mapState);
+        if (mapped.events.length > 0 || mapped.done) {
+          logAdapter(
+            `event ${item.type} mapped=${mapped.events.map((event) => event.type).join(",") || "(none)"} done=${mapped.done} session=${request.sessionId.slice(0, 8)}`
+          );
+        }
         for (const event of mapped.events) {
           if (event.type === "diff_proposed" && mapped.patchToFetch) {
             sawAnyPatch = true;
             lastPatchHash = mapped.patchToFetch.hash;
           }
+          if (event.type === "done") emittedDone = true;
           yield event;
         }
         if (mapped.done) {
@@ -2459,31 +2738,42 @@ var OpenCodeProcessAdapter = class {
       }
     } finally {
       eventController.abort();
+      try {
+        await iterator.return?.();
+      } catch {
+      }
       request.signal?.removeEventListener("abort", stopOnAbort);
       activeBrokerHandle?.release();
       streamScopedBroker?.close("turn_ended");
     }
-    if (sawAnyPatch) {
-      try {
-        const diffRes = await handle.client.session.diff({
-          path: { id: openCodeSessionId },
-          query: { directory: request.repoPath }
-        });
-        const unified = diffRes.data?.unified ?? "";
-        if (unified) {
-          yield {
-            type: "diff_proposed",
-            unified,
-            files: parseUnifiedDiffFiles(unified)
-          };
-        }
-      } catch {
+    try {
+      const diffRes = await handle.client.session.diff({
+        path: { id: openCodeSessionId },
+        query: { directory: request.repoPath }
+      });
+      const unified = diffRes.data?.unified ?? "";
+      if (unified) {
+        yield {
+          type: "diff_proposed",
+          unified,
+          files: parseUnifiedDiffFiles(unified)
+        };
       }
+    } catch (err) {
+      logAdapter(
+        `diff fetch failed session=${request.sessionId.slice(0, 8)} error=${err instanceof Error ? err.message : String(err)}`
+      );
     }
     const promptResult = await promptPromise;
     if (promptResult instanceof Error) {
       yield { type: "error", message: promptResult.message, recoverable: true };
+    } else {
+      logAdapter(`turn complete session=${request.sessionId.slice(0, 8)}`);
+    }
+    if (!emittedDone) {
+      yield { type: "done" };
     }
+    void sawAnyPatch;
     void lastPatchHash;
   }
   async close() {