naiad-cli 0.2.38 → 0.2.39

package/extensions/naiad-extension.ts

@@ -11,7 +11,7 @@ import {
   calculateCost,
 } from "@mariozechner/pi-ai";
 import { execSync, execFileSync, spawn } from "child_process";
-import * as readline from "readline";
+// Note: readline removed - using manual LF buffering for JSONL framing (v0.57.0+ compatibility)
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
@@ -637,10 +637,11 @@ When you're done, provide a clear, actionable summary the caller can act on.`;
             let closed = false;
             let terminationReason: "timeout" | "abort" | null = null;
             let statusLine = "";
+            let stdoutBuffer = "";
+            const stdoutDecoder = new TextDecoder("utf-8", { fatal: false });
+            const stderrDecoder = new TextDecoder("utf-8", { fatal: false });
 
-            const rl = readline.createInterface({ input: child.stdout!, crlfDelay: Infinity });
-
-            rl.on("line", (line: string) => {
+            function processLine(line: string) {
               if (!line.trim()) return;
               let event: any;
               try {
@@ -690,10 +691,40 @@ When you're done, provide a clear, actionable summary the caller can act on.`;
                   }
                 }
               }
+            }
+
+            function flushStdoutBuffer(final = false) {
+              if (final && stdoutBuffer.trim()) {
+                processLine(stdoutBuffer.trim());
+                stdoutBuffer = "";
+              }
+            }
+
+            // Use LF-only buffering for JSONL (v0.57.0+ compatibility)
+            // readline is avoided because it splits on Unicode line separators (U+2028/U+2029)
+            child.stdout!.on("data", (data: Buffer) => {
+              stdoutBuffer += stdoutDecoder.decode(data, { stream: true });
+              const lines = stdoutBuffer.split("\n");
+              stdoutBuffer = lines.pop() ?? "";
+
+              for (const line of lines) {
+                processLine(line);
+              }
+            });
+
+            child.stdout!.on("end", () => {
+              // Flush decoder and process any remaining partial line
+              stdoutBuffer += stdoutDecoder.decode(undefined, { stream: false });
+              flushStdoutBuffer(true);
             });
 
             child.stderr!.on("data", (data: Buffer) => {
-              stderr += data.toString();
+              stderr += stderrDecoder.decode(data, { stream: true });
+            });
+
+            child.stderr!.on("end", () => {
+              // Flush any remaining stderr bytes
+              stderr += stderrDecoder.decode(undefined, { stream: false });
             });
 
             child.on("error", (err) => {
@@ -719,6 +750,9 @@ When you're done, provide a clear, actionable summary the caller can act on.`;
                 signal.removeEventListener("abort", abortHandler);
               }
 
+              // Flush any remaining output in the stdout buffer
+              flushStdoutBuffer(true);
+
               if (terminationReason === "timeout") {
                 const timeoutSec = Math.round(timeoutMs / 1000);
                 reject(new Error(`Seer timed out after ${timeoutSec} seconds`));
@@ -1204,17 +1238,125 @@ When you're done, provide a clear, actionable summary the caller can act on.`;
     const isGHA = process.env.GITHUB_ACTIONS === "true";
     const apiBaseUrl = inferenceUrl.replace(/\/api\/v1\/inference$/, "");
 
-    async function callToolEndpoint(method: string, endpoint: string, body?: unknown): Promise<any> {
-      const url = `${apiBaseUrl}/api/v1/threads/${threadId}/github/${endpoint}`;
-      const res = await fetch(url, {
-        method,
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey}`,
-        },
-        body: body ? JSON.stringify(body) : undefined,
+    const GITHUB_TOOL_TIMEOUT_MS = 30_000;
+
+    function createAbortError(message = "Aborted"): Error {
+      const err = new Error(message);
+      err.name = "AbortError";
+      return err;
+    }
+
+    function throwIfAborted(signal?: AbortSignal): void {
+      if (signal?.aborted) {
+        throw createAbortError();
+      }
+    }
+
+    function waitForTurn(previous: Promise<unknown>, signal?: AbortSignal): Promise<void> {
+      if (!signal) {
+        return previous.then(() => undefined);
+      }
+      if (signal.aborted) {
+        return Promise.reject(createAbortError());
+      }
+
+      return new Promise<void>((resolve, reject) => {
+        const onAbort = () => {
+          signal.removeEventListener("abort", onAbort);
+          reject(createAbortError());
+        };
+
+        previous.then(
+          () => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+          },
+          (err) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(err);
+          },
+        );
+
+        signal.addEventListener("abort", onAbort, { once: true });
       });
-      const data = await res.json();
+    }
+
+    // Abort-aware mutex for serializing mutating GitHub operations.
+    // If a caller aborts while waiting, its queued operation is skipped and
+    // later operations can continue once earlier ones finish.
+    class AbortAwareMutex {
+      private tail: Promise<void> = Promise.resolve();
+
+      async acquire<T>(fn: () => Promise<T>, signal?: AbortSignal): Promise<T> {
+        throwIfAborted(signal);
+
+        const previous = this.tail;
+        let release!: () => void;
+        const current = new Promise<void>((resolve) => {
+          release = resolve;
+        });
+
+        // Successors still wait for `previous`, but this slot can be released
+        // early if the waiting caller aborts.
+        this.tail = previous.then(() => current, () => current);
+
+        try {
+          await waitForTurn(previous, signal);
+          throwIfAborted(signal);
+          return await fn();
+        } finally {
+          release();
+        }
+      }
+    }
+    const githubMutex = new AbortAwareMutex();
+
+    async function callToolEndpoint(
+      method: string,
+      endpoint: string,
+      body?: unknown,
+      signal?: AbortSignal,
+    ): Promise<any> {
+      const url = `${apiBaseUrl}/api/v1/threads/${threadId}/github/${endpoint}`;
+      const timeoutSignal = AbortSignal.timeout(GITHUB_TOOL_TIMEOUT_MS);
+      const combinedSignal = signal
+        ? AbortSignal.any([signal, timeoutSignal])
+        : timeoutSignal;
+
+      let res: Response;
+      let raw = "";
+
+      try {
+        res = await fetch(url, {
+          method,
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+          },
+          body: body ? JSON.stringify(body) : undefined,
+          signal: combinedSignal,
+        });
+
+        raw = await res.text();
+      } catch (err) {
+        if (signal?.aborted) throw err;
+        if (timeoutSignal.aborted) {
+          throw new Error(
+            `GitHub tool request timed out after ${Math.round(GITHUB_TOOL_TIMEOUT_MS / 1000)} seconds`,
+          );
+        }
+        throw err;
+      }
+
+      let data: any = {};
+      if (raw) {
+        try {
+          data = JSON.parse(raw);
+        } catch {
+          data = { raw };
+        }
+      }
+
       if (res.status === 409) {
         return data;
       }
@@ -1237,7 +1379,7 @@ When you're done, provide a clear, actionable summary the caller can act on.`;
       parameters: Type.Object({}),
       async execute(toolCallId, params, signal, onUpdate, ctx) {
         if (isGHA) {
-          const data = await callToolEndpoint("GET", "context");
+          const data = await callToolEndpoint("GET", "context", undefined, signal);
           return { content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }] };
         }
 
@@ -1300,122 +1442,125 @@ When you're done, provide a clear, actionable summary the caller can act on.`;
         ),
       }),
       async execute(toolCallId, params, signal, onUpdate, ctx) {
-        // Stage files
-        if (params.files && params.files.length > 0) {
-          execFileSync("git", ["add", ...params.files]);
-        } else {
-          execFileSync("git", ["add", "-A"]);
-        }
-
-        // Check if there are changes to commit
-        try {
-          execFileSync("git", ["diff", "--cached", "--quiet"]);
-          // exit 0 means no changes
-          return { content: [{ type: "text" as const, text: JSON.stringify({ pushed: false, reason: "no_changes" }) }] };
-        } catch {
-          // exit non-zero means there are staged changes — continue
-        }
+        // Serialize mutating GitHub operations to prevent race conditions (v0.58.0+ parallel tool execution)
+        return githubMutex.acquire(async () => {
+          // Stage files
+          if (params.files && params.files.length > 0) {
+            execFileSync("git", ["add", ...params.files]);
+          } else {
+            execFileSync("git", ["add", "-A"]);
+          }
 
-        // Set git identity and commit
-        execFileSync("git", ["config", "user.name", "naiad-bot"]);
-        execFileSync("git", ["config", "user.email", "266131081+naiad-bot@users.noreply.github.com"]);
-        execFileSync("git", ["commit", "-m", params.message]);
+          // Check if there are changes to commit
+          try {
+            execFileSync("git", ["diff", "--cached", "--quiet"]);
+            // exit 0 means no changes
+            return { content: [{ type: "text" as const, text: JSON.stringify({ pushed: false, reason: "no_changes" }) }] };
+          } catch {
+            // exit non-zero means there are staged changes — continue
+          }
 
-        const headSha = execFileSync("git", ["rev-parse", "HEAD"]).toString().trim();
+          // Set git identity and commit
+          execFileSync("git", ["config", "user.name", "naiad-bot"]);
+          execFileSync("git", ["config", "user.email", "266131081+naiad-bot@users.noreply.github.com"]);
+          execFileSync("git", ["commit", "-m", params.message]);
 
-        if (isGHA) {
-          // Step 1: Preflight — validate push safety and get expectedRef WITHOUT minting a push token
-          const preflight = await callToolEndpoint("POST", "push-preflight", {
-            message: params.message,
-            commit_sha: headSha,
-          });
+          const headSha = execFileSync("git", ["rev-parse", "HEAD"]).toString().trim();
 
-          if (preflight.error) {
-            return { content: [{ type: "text" as const, text: JSON.stringify(preflight) }] };
-          }
+          if (isGHA) {
+            // Step 1: Preflight — validate push safety and get expectedRef WITHOUT minting a push token
+            const preflight = await callToolEndpoint("POST", "push-preflight", {
+              message: params.message,
+              commit_sha: headSha,
+            }, signal);
 
-          const { expectedRef, branch: preflightBranch } = preflight;
+            if (preflight.error) {
+              return { content: [{ type: "text" as const, text: JSON.stringify(preflight) }] };
+            }
 
-          // Step 2: Check for merge commits (pre-push safety) using server-provided expectedRef
-          const merges = execFileSync("git", ["rev-list", "--merges", `${expectedRef}..HEAD`]).toString().trim();
-          if (merges) {
-            return {
-              content: [{ type: "text" as const, text: JSON.stringify({ error: "policy_denied", message: "Merge commits are not allowed", retryable: false }) }],
-            };
-          }
+            const { expectedRef, branch: preflightBranch } = preflight;
 
-          // Step 3: Mint push token — only after merge check passes
-          const pushData = await callToolEndpoint("POST", "commit-and-push", {
-            message: params.message,
-            commit_sha: headSha,
-          });
+            // Step 2: Check for merge commits (pre-push safety) using server-provided expectedRef
+            const merges = execFileSync("git", ["rev-list", "--merges", `${expectedRef}..HEAD`]).toString().trim();
+            if (merges) {
+              return {
+                content: [{ type: "text" as const, text: JSON.stringify({ error: "policy_denied", message: "Merge commits are not allowed", retryable: false }) }],
+              };
+            }
 
-          if (pushData.error) {
-            return { content: [{ type: "text" as const, text: JSON.stringify(pushData) }] };
-          }
+            // Step 3: Mint push token — only after merge check passes
+            const pushData = await callToolEndpoint("POST", "commit-and-push", {
+              message: params.message,
+              commit_sha: headSha,
+            }, signal);
 
-          const { pushToken, pushUrl, branch } = pushData;
+            if (pushData.error) {
+              return { content: [{ type: "text" as const, text: JSON.stringify(pushData) }] };
+            }
 
-          // Validate pushUrl matches the expected repo (not just any GitHub URL)
-          const rawRemote = execFileSync("git", ["remote", "get-url", "origin"]).toString().trim();
-          const expectedRepo = rawRemote
-            .replace(/^https?:\/\/github\.com\//, "")
-            .replace(/^git@github\.com:/, "")
-            .replace(/\.git$/, "");
-          const expectedPushUrl = `https://github.com/${expectedRepo}.git`;
-          if (!pushUrl || pushUrl !== expectedPushUrl) {
-            return {
-              content: [{ type: "text" as const, text: JSON.stringify({ error: "policy_denied", message: "Push URL does not match expected repository", retryable: false }) }],
-            };
-          }
+            const { pushToken, pushUrl, branch } = pushData;
+
+            // Validate pushUrl matches the expected repo (not just any GitHub URL)
+            const rawRemote = execFileSync("git", ["remote", "get-url", "origin"]).toString().trim();
+            const expectedRepo = rawRemote
+              .replace(/^https?:\/\/github\.com\//, "")
+              .replace(/^git@github\.com:/, "")
+              .replace(/\.git$/, "");
+            const expectedPushUrl = `https://github.com/${expectedRepo}.git`;
+            if (!pushUrl || pushUrl !== expectedPushUrl) {
+              return {
+                content: [{ type: "text" as const, text: JSON.stringify({ error: "policy_denied", message: "Push URL does not match expected repository", retryable: false }) }],
+              };
+            }
 
-          const basicAuth = Buffer.from(`x-access-token:${pushToken}`).toString("base64");
+            const basicAuth = Buffer.from(`x-access-token:${pushToken}`).toString("base64");
 
-          // Clean-room push — env vars (GIT_CONFIG_NOSYSTEM, GIT_CONFIG_GLOBAL,
-          // GIT_CONFIG) already neutralize system/global/local config includes.
-          try {
-            execFileSync(
-              "git",
-              [
-                "-c", "core.hooksPath=/dev/null",
-                "-c", "credential.helper=",
-                `-c`, `http.extraheader=Authorization: Basic ${basicAuth}`,
-                "push", pushUrl, `HEAD:refs/heads/${branch}`, "--no-force",
-              ],
-              {
-                env: {
-                  PATH: process.env.PATH,
-                  HOME: process.env.HOME,
-                  GIT_CONFIG_NOSYSTEM: "1",
-                  GIT_CONFIG_GLOBAL: "/dev/null",
-                  GIT_CONFIG: "/dev/null",
-                  GIT_TERMINAL_PROMPT: "0",
+            // Clean-room push — env vars (GIT_CONFIG_NOSYSTEM, GIT_CONFIG_GLOBAL,
+            // GIT_CONFIG) already neutralize system/global/local config includes.
+            try {
+              execFileSync(
+                "git",
+                [
+                  "-c", "core.hooksPath=/dev/null",
+                  "-c", "credential.helper=",
+                  `-c`, `http.extraheader=Authorization: Basic ${basicAuth}`,
+                  "push", pushUrl, `HEAD:refs/heads/${branch}`, "--no-force",
+                ],
+                {
+                  env: {
+                    PATH: process.env.PATH,
+                    HOME: process.env.HOME,
+                    GIT_CONFIG_NOSYSTEM: "1",
+                    GIT_CONFIG_GLOBAL: "/dev/null",
+                    GIT_CONFIG: "/dev/null",
+                    GIT_TERMINAL_PROMPT: "0",
+                  },
                 },
-              },
-            );
-          } catch (pushErr: any) {
-            // Sanitize error — execFileSync includes the full command with credentials
-            const stderr = pushErr.stderr?.toString() || "";
-            throw new Error(`git push failed: ${stderr.replace(/Authorization:[^\s]*/g, "Authorization: [REDACTED]")}`);
-          }
+              );
+            } catch (pushErr: any) {
+              // Sanitize error — execFileSync includes the full command with credentials
+              const stderr = pushErr.stderr?.toString() || "";
+              throw new Error(`git push failed: ${stderr.replace(/Authorization:[^\s]*/g, "Authorization: [REDACTED]")}`);
+            }
 
-          // Post-push verification (defense-in-depth: server checks for merge commits)
-          const verifyResult = await callToolEndpoint("POST", "post-push-verify", {
-            commit_sha: headSha,
-            expected_ref: expectedRef,
-            branch,
-          });
-          if (verifyResult.error) {
-            return { content: [{ type: "text" as const, text: JSON.stringify(verifyResult) }] };
+            // Post-push verification (defense-in-depth: server checks for merge commits)
+            const verifyResult = await callToolEndpoint("POST", "post-push-verify", {
+              commit_sha: headSha,
+              expected_ref: expectedRef,
+              branch,
+            }, signal);
+            if (verifyResult.error) {
+              return { content: [{ type: "text" as const, text: JSON.stringify(verifyResult) }] };
+            }
+
+            return { content: [{ type: "text" as const, text: JSON.stringify({ pushed: true, headSha, branch }) }] };
           }
 
+          // Local fallback: just push
+          execFileSync("git", ["push"]);
+          const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"]).toString().trim();
           return { content: [{ type: "text" as const, text: JSON.stringify({ pushed: true, headSha, branch }) }] };
-        }
-
-        // Local fallback: just push
-        execFileSync("git", ["push"]);
-        const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"]).toString().trim();
-        return { content: [{ type: "text" as const, text: JSON.stringify({ pushed: true, headSha, branch }) }] };
+        }, signal);
       },
     });
 
@@ -1437,35 +1582,38 @@ When you're done, provide a clear, actionable summary the caller can act on.`;
         draft: Type.Optional(Type.Boolean({ description: "Create as draft PR. Defaults to false." })),
       }),
       async execute(toolCallId, params, signal, onUpdate, ctx) {
-        if (isGHA) {
-          const data = await callToolEndpoint("POST", "pr", {
-            title: params.title,
-            body: params.body,
-            draft: params.draft,
-          });
-          return { content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }] };
-        }
+        // Serialize mutating GitHub operations to prevent race conditions (v0.58.0+ parallel tool execution)
+        return githubMutex.acquire(async () => {
+          if (isGHA) {
+            const data = await callToolEndpoint("POST", "pr", {
+              title: params.title,
+              body: params.body,
+              draft: params.draft,
+            }, signal);
+            return { content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }] };
+          }
 
-        // Local fallback: gh CLI
-        try {
-          // Try to update existing PR first
-          execFileSync("gh", ["pr", "edit", "--title", params.title, "--body", params.body]);
-          const prJson = execFileSync("gh", ["pr", "view", "--json", "number,url"]).toString().trim();
-          const pr = JSON.parse(prJson);
-          return { content: [{ type: "text" as const, text: JSON.stringify({ prNumber: pr.number, prUrl: pr.url, created: false }) }] };
-        } catch {
-          // No existing PR — create one
-          const createArgs = ["pr", "create", "--title", params.title, "--body", params.body];
-          if (params.draft) createArgs.push("--draft");
-          const prUrl = execFileSync("gh", createArgs).toString().trim();
-          // Fetch PR number from the newly created PR
-          let prNumber: number | undefined;
+          // Local fallback: gh CLI
           try {
-            const newPrJson = execFileSync("gh", ["pr", "view", "--json", "number"]).toString().trim();
-            prNumber = JSON.parse(newPrJson).number;
-          } catch {}
-          return { content: [{ type: "text" as const, text: JSON.stringify({ prNumber, prUrl, created: true }) }] };
-        }
+            // Try to update existing PR first
+            execFileSync("gh", ["pr", "edit", "--title", params.title, "--body", params.body]);
+            const prJson = execFileSync("gh", ["pr", "view", "--json", "number,url"]).toString().trim();
+            const pr = JSON.parse(prJson);
+            return { content: [{ type: "text" as const, text: JSON.stringify({ prNumber: pr.number, prUrl: pr.url, created: false }) }] };
+          } catch {
+            // No existing PR — create one
+            const createArgs = ["pr", "create", "--title", params.title, "--body", params.body];
+            if (params.draft) createArgs.push("--draft");
+            const prUrl = execFileSync("gh", createArgs).toString().trim();
+            // Fetch PR number from the newly created PR
+            let prNumber: number | undefined;
+            try {
+              const newPrJson = execFileSync("gh", ["pr", "view", "--json", "number"]).toString().trim();
+              prNumber = JSON.parse(newPrJson).number;
+            } catch {}
+            return { content: [{ type: "text" as const, text: JSON.stringify({ prNumber, prUrl, created: true }) }] };
+          }
+        }, signal);
       },
     });
 
@@ -1492,25 +1640,28 @@ When you're done, provide a clear, actionable summary the caller can act on.`;
         ),
       }),
       async execute(toolCallId, params, signal, onUpdate, ctx) {
-        if (isGHA) {
-          const data = await callToolEndpoint("POST", "comment", {
-            body: params.body,
-            target: params.target,
-            reviewCommentId: params.reviewCommentId,
-          });
-          return { content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }] };
-        }
+        // Serialize mutating GitHub operations to prevent race conditions (v0.58.0+ parallel tool execution)
+        return githubMutex.acquire(async () => {
+          if (isGHA) {
+            const data = await callToolEndpoint("POST", "comment", {
+              body: params.body,
+              target: params.target,
+              reviewCommentId: params.reviewCommentId,
+            }, signal);
+            return { content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }] };
+          }
 
-        // Local fallback: gh CLI
-        if (params.target === "pr_review_thread") {
-          throw new Error("pr_review_thread target is not supported in local CLI mode — use GHA or reply manually");
-        }
-        if (params.target === "issue") {
-          execFileSync("gh", ["issue", "comment", "--body", params.body]);
-        } else {
-          execFileSync("gh", ["pr", "comment", "--body", params.body]);
-        }
-        return { content: [{ type: "text" as const, text: JSON.stringify({ commentUrl: "comment posted locally" }) }] };
+          // Local fallback: gh CLI
+          if (params.target === "pr_review_thread") {
+            throw new Error("pr_review_thread target is not supported in local CLI mode — use GHA or reply manually");
+          }
+          if (params.target === "issue") {
+            execFileSync("gh", ["issue", "comment", "--body", params.body]);
+          } else {
+            execFileSync("gh", ["pr", "comment", "--body", params.body]);
+          }
+          return { content: [{ type: "text" as const, text: JSON.stringify({ commentUrl: "comment posted locally" }) }] };
+        }, signal);
       },
     });
 
@@ -1547,27 +1698,30 @@ When you're done, provide a clear, actionable summary the caller can act on.`;
         ),
       }),
       async execute(toolCallId, params, signal, onUpdate, ctx) {
-        if (isGHA) {
-          const data = await callToolEndpoint("POST", "review", {
-            body: params.body,
-            event: params.event,
-            comments: params.comments,
-          });
-          return { content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }] };
-        }
+        // Serialize mutating GitHub operations to prevent race conditions (v0.58.0+ parallel tool execution)
+        return githubMutex.acquire(async () => {
+          if (isGHA) {
+            const data = await callToolEndpoint("POST", "review", {
+              body: params.body,
+              event: params.event,
+              comments: params.comments,
+            }, signal);
+            return { content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }] };
+          }
 
-        // Local fallback: gh pr review
-        if (params.comments && params.comments.length > 0) {
-          throw new Error("Inline review comments are not supported in local CLI mode — use GHA for inline comments");
-        }
-        const reviewArgs = ["pr", "review", "--body", params.body];
-        if (params.event === "REQUEST_CHANGES") {
-          reviewArgs.push("--request-changes");
-        } else {
-          reviewArgs.push("--comment");
-        }
-        execFileSync("gh", reviewArgs);
-        return { content: [{ type: "text" as const, text: JSON.stringify({ reviewUrl: "review posted locally" }) }] };
+          // Local fallback: gh pr review
+          if (params.comments && params.comments.length > 0) {
+            throw new Error("Inline review comments are not supported in local CLI mode — use GHA for inline comments");
+          }
+          const reviewArgs = ["pr", "review", "--body", params.body];
+          if (params.event === "REQUEST_CHANGES") {
+            reviewArgs.push("--request-changes");
+          } else {
+            reviewArgs.push("--comment");
+          }
+          execFileSync("gh", reviewArgs);
+          return { content: [{ type: "text" as const, text: JSON.stringify({ reviewUrl: "review posted locally" }) }] };
+        }, signal);
       },
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "naiad-cli",
-  "version": "0.2.38",
+  "version": "0.2.39",
   "type": "module",
   "bin": {
     "naiad": "./dist/index.js"
@@ -21,7 +21,7 @@
     "test": "tsx --test src/callback/server.test.ts"
   },
   "dependencies": {
-    "@mariozechner/pi-coding-agent": "^0.56.0"
+    "@mariozechner/pi-coding-agent": "^0.58.3"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",