@cydm/pie 1.0.10 → 1.0.12

package/dist/builtin/extensions/ask-user/index.js

@@ -1,8 +1,8 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createAskUserCapability
-} from "../../../chunks/chunk-EJGQAAKS.js";
-import "../../../chunks/chunk-A5JSJAPK.js";
+} from "../../../chunks/chunk-SW6G4XW2.js";
+import "../../../chunks/chunk-D7NAXU7F.js";
 import "../../../chunks/chunk-TG2EQLX2.js";
 
 // builtin/extensions/ask-user/index.ts

package/dist/builtin/extensions/plan-mode/index.js

@@ -7,8 +7,8 @@ import {
   isPlanModeSafeCommand,
   markCompletedPlanSteps,
   restoreExecutionState
-} from "../../../chunks/chunk-EJGQAAKS.js";
-import "../../../chunks/chunk-A5JSJAPK.js";
+} from "../../../chunks/chunk-SW6G4XW2.js";
+import "../../../chunks/chunk-D7NAXU7F.js";
 import "../../../chunks/chunk-TG2EQLX2.js";
 
 // builtin/extensions/plan-mode/index.ts

package/dist/builtin/extensions/subagent/index.js

@@ -1,12 +1,12 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createCliHostCapabilities
-} from "../../../chunks/chunk-R2HMYSEK.js";
+} from "../../../chunks/chunk-YLOLJRLJ.js";
 import {
   createSharedFileSystemTools,
   createSubagentCapability
-} from "../../../chunks/chunk-EJGQAAKS.js";
-import "../../../chunks/chunk-A5JSJAPK.js";
+} from "../../../chunks/chunk-SW6G4XW2.js";
+import "../../../chunks/chunk-D7NAXU7F.js";
 import "../../../chunks/chunk-TG2EQLX2.js";
 
 // builtin/extensions/subagent/index.ts

package/dist/builtin/extensions/todo/index.js

@@ -7,8 +7,8 @@ import {
   executeManageTodoList,
   executionStateToTodos,
   restoreExecutionState
-} from "../../../chunks/chunk-EJGQAAKS.js";
-import "../../../chunks/chunk-A5JSJAPK.js";
+} from "../../../chunks/chunk-SW6G4XW2.js";
+import "../../../chunks/chunk-D7NAXU7F.js";
 import "../../../chunks/chunk-TG2EQLX2.js";
 
 // builtin/extensions/todo/index.ts

package/dist/chunks/{chunk-A5JSJAPK.js → chunk-D7NAXU7F.js}

@@ -3758,6 +3758,7 @@ var NodeHttpClient = class {
   async request(url, options = {}) {
     const requestStartTime = Date.now();
     const requestId = `${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+    const requestTimeoutMs = options.timeoutMs ?? 6e4;
     logHttp("DEBUG", `Request [${requestId}] started`, {
       url: url.slice(0, 100),
       method: options.method || "GET",
@@ -3857,13 +3858,32 @@ var NodeHttpClient = class {
             let done = false;
             let error = null;
             let waiting = null;
-            const flushBuffer = () => {
+            const wake = (value) => {
+              if (!waiting) return;
+              const w = waiting;
+              waiting = null;
+              w(value);
+            };
+            const failStream = (e) => {
+              if (done && error) return;
+              error = e;
+              done = true;
+              wake({ done: true, value: void 0 });
+              logHttp("ERROR", `Request [${requestId}] SSE stream error`, { error: e.message });
+            };
+            const flushBuffer = (final = false) => {
               if (bufferLength === 0) return;
               const buffer = Buffer.concat(bufferChunks, bufferLength);
               const bufferStr = buffer.toString("utf-8");
               const lines = bufferStr.split("\n");
               const lastLine = lines.pop();
-              if (lastLine !== void 0) {
+              if (final) {
+                if (lastLine !== void 0 && lastLine.length > 0) {
+                  lines.push(lastLine);
+                }
+                bufferChunks = [];
+                bufferLength = 0;
+              } else if (lastLine !== void 0) {
                 bufferChunks = [Buffer.from(lastLine)];
                 bufferLength = lastLine.length;
               } else {
@@ -3874,10 +3894,17 @@ var NodeHttpClient = class {
                 lineQueue.push(line);
               }
             };
+            let abortHandler = null;
             if (signal) {
-              signal.addEventListener("abort", () => {
-                res.destroy();
-              }, { once: true });
+              abortHandler = () => {
+                failStream(new Error("Request was aborted"));
+                res.destroy(new Error("Request was aborted"));
+              };
+              if (signal.aborted) {
+                abortHandler();
+              } else {
+                signal.addEventListener("abort", abortHandler, { once: true });
+              }
             }
             res.on("data", (chunk) => {
               totalBytes += chunk.length;
@@ -3886,22 +3913,18 @@ var NodeHttpClient = class {
               if (bufferLength > 16384 || chunk.includes(10)) {
                 flushBuffer();
               }
-              if (waiting) {
-                const w = waiting;
-                waiting = null;
-                w({ done: false, value: void 0 });
-              }
+              wake({ done: false, value: void 0 });
             });
             res.on("end", () => {
               if (bufferLength > 0) {
-                flushBuffer();
+                flushBuffer(true);
               }
-              done = true;
-              if (waiting) {
-                const w = waiting;
-                waiting = null;
-                w({ done: true, value: void 0 });
+              if (!res.complete) {
+                failStream(new Error("SSE stream ended before response completed"));
+                return;
               }
+              done = true;
+              wake({ done: true, value: void 0 });
               logHttp("DEBUG", `Request [${requestId}] SSE stream ended`, {
                 totalBytes,
                 lineCount,
@@ -3909,14 +3932,15 @@ var NodeHttpClient = class {
               });
             });
             res.on("error", (e) => {
-              error = e;
-              done = true;
-              if (waiting) {
-                const w = waiting;
-                waiting = null;
-                w({ done: true, value: void 0 });
+              failStream(e);
+            });
+            res.on("aborted", () => {
+              failStream(new Error("SSE stream aborted"));
+            });
+            res.on("close", () => {
+              if (!done || !res.complete) {
+                failStream(new Error("SSE stream closed before end"));
               }
-              logHttp("ERROR", `Request [${requestId}] SSE stream error`, { error: e.message });
             });
             try {
               while (true) {
@@ -3936,9 +3960,12 @@ var NodeHttpClient = class {
                 const waitResult = await new Promise((r) => {
                   waiting = r;
                 });
-                if (waitResult.done) break;
+                void waitResult;
               }
             } finally {
+              if (signal && abortHandler) {
+                signal.removeEventListener("abort", abortHandler);
+              }
               if (!done && !res.destroyed) {
                 res.destroy();
               }
@@ -3965,6 +3992,7 @@ var NodeHttpClient = class {
         logHttp("ERROR", `Request [${requestId}] timeout`);
         req.destroy(new Error("Request timeout"));
       });
+      req.setTimeout(requestTimeoutMs);
       if (options.signal) {
         options.signal.addEventListener("abort", () => {
           logHttp("DEBUG", `Request [${requestId}] aborted`);
@@ -4371,6 +4399,47 @@ var FileSystemGateway = class {
     const fs = nodeRequire("fs");
     fs.writeFileSync(path, content, encoding);
   }
+  /**
+   * Copy a file.
+   */
+  copyFile(source, destination) {
+    if (!this.allowWrites) {
+      throw new Error(`Writes not allowed: ${destination}`);
+    }
+    this.validatePath(source, "copy");
+    this.validatePath(destination, "copy");
+    const platform = detectPlatform();
+    const dir = this.dirname(destination);
+    this.mkdir(dir, { recursive: true });
+    if (platform === "puerts" && typeof CS !== "undefined") {
+      CS.System.IO.File.Copy(source, destination, true);
+      return;
+    }
+    const fs = nodeRequire("fs");
+    fs.copyFileSync(source, destination);
+  }
+  /**
+   * Rename or move a file.
+   */
+  renameFile(source, destination) {
+    if (!this.allowWrites) {
+      throw new Error(`Writes not allowed: ${destination}`);
+    }
+    this.validatePath(source, "rename");
+    this.validatePath(destination, "rename");
+    const platform = detectPlatform();
+    const dir = this.dirname(destination);
+    this.mkdir(dir, { recursive: true });
+    if (platform === "puerts" && typeof CS !== "undefined") {
+      if (CS.System.IO.File.Exists(destination)) {
+        CS.System.IO.File.Delete(destination);
+      }
+      CS.System.IO.File.Move(source, destination);
+      return;
+    }
+    const fs = nodeRequire("fs");
+    fs.renameSync(source, destination);
+  }
   /**
    * Delete file
    */
@@ -4937,6 +5006,52 @@ function mapOpenAIStopReason(reason) {
   }
 }
 
+// ../../packages/ai/src/providers/assistant-content-validation.ts
+var EMPTY_ASSISTANT_CONTENT_ERROR = "stream ended without assistant content";
+var EMPTY_ASSISTANT_CONTENT_ERROR_CODE = "empty_assistant_content";
+var EmptyAssistantContentError = class extends Error {
+  code = EMPTY_ASSISTANT_CONTENT_ERROR_CODE;
+  constructor(message = EMPTY_ASSISTANT_CONTENT_ERROR) {
+    super(message);
+    this.name = "EmptyAssistantContentError";
+  }
+};
+function hasAssistantContent(message) {
+  return message.content.some((block) => {
+    if (block.type === "text") {
+      return block.text.trim().length > 0;
+    }
+    if (block.type === "thinking") {
+      return block.thinking.trim().length > 0;
+    }
+    if (block.type === "toolCall") {
+      return block.name.trim().length > 0;
+    }
+    return false;
+  });
+}
+function assertAssistantHasContent(message) {
+  if (!hasAssistantContent(message)) {
+    throw new EmptyAssistantContentError();
+  }
+}
+function isEmptyAssistantContentError(error) {
+  return error instanceof EmptyAssistantContentError || typeof error === "object" && error !== null && "code" in error && error.code === EMPTY_ASSISTANT_CONTENT_ERROR_CODE;
+}
+function logEmptyAssistantContentError(error, model, options) {
+  if (!isEmptyAssistantContentError(error)) {
+    return;
+  }
+  getLogger().child({ module: "ai.provider" }).warn(EMPTY_ASSISTANT_CONTENT_ERROR, {
+    code: EMPTY_ASSISTANT_CONTENT_ERROR_CODE,
+    provider: model.provider,
+    model: model.id,
+    api: model.api,
+    sessionId: options?.sessionId,
+    metadata: options?.metadata
+  });
+}
+
 // ../../packages/ai/src/providers/openai-compat.ts
 var streamOpenAICompletions = (model, context, options) => {
   const stream = new AssistantMessageEventStream();
@@ -5172,9 +5287,11 @@ var streamOpenAICompletions = (model, context, options) => {
       if (output.stopReason === "aborted" || output.stopReason === "error") {
         throw new Error("An unknown error occurred");
       }
+      assertAssistantHasContent(output);
       stream.push({ type: "done", reason: output.stopReason, message: output });
       stream.end();
     } catch (error) {
+      logEmptyAssistantContentError(error, model, options);
       output.stopReason = options?.signal?.aborted ? "aborted" : "error";
       output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
       stream.push({ type: "error", reason: output.stopReason, error: output });
@@ -5553,9 +5670,11 @@ var streamAnthropic = (model, context, options) => {
       if (options?.signal?.aborted) {
         throw new Error("Request was aborted");
       }
+      assertAssistantHasContent(output);
       stream.push({ type: "done", reason: output.stopReason, message: output });
       stream.end();
     } catch (error) {
+      logEmptyAssistantContentError(error, model, options);
       for (const block of output.content) delete block.index;
       output.stopReason = options?.signal?.aborted ? "aborted" : "error";
       output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
@@ -9002,35 +9121,78 @@ registerApiProvider({
 });
 
 // ../../packages/agent-core/src/agent-loop.ts
+function createLoopErrorMessage(error, config, signal) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    role: "assistant",
+    content: [{ type: "text", text: "" }],
+    api: config.model.api,
+    provider: config.model.provider,
+    model: config.model.id,
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+    },
+    stopReason: signal?.aborted ? "aborted" : "error",
+    errorMessage: message,
+    timestamp: Date.now()
+  };
+}
+async function notifyOnError(config, error, phase) {
+  try {
+    await config.hooks?.onError?.(error instanceof Error ? error : new Error(String(error)), { phase });
+  } catch (hookError) {
+    console.warn(`[AgentLoop] onError hook failed during ${phase}:`, hookError);
+  }
+}
+function endStreamWithError(stream, newMessages, config, signal, error) {
+  const errorMessage = createLoopErrorMessage(error, config, signal);
+  newMessages.push(errorMessage);
+  stream.push({ type: "message_start", message: errorMessage });
+  stream.push({ type: "message_end", message: errorMessage });
+  stream.push({ type: "turn_end", message: errorMessage, toolResults: [] });
+  stream.push({ type: "agent_end", messages: newMessages });
+  stream.end(newMessages);
+}
 function agentLoop(prompts, context, config, signal, streamFn) {
   const stream = createAgentStream();
   (async () => {
-    try {
-      await config.hooks?.beforeAgentStart?.();
-    } catch (e) {
-      console.warn("[AgentLoop] beforeAgentStart hook failed:", e);
-    }
     const newMessages = [...prompts];
-    const currentContext = {
-      ...context,
-      messages: [...context.messages, ...prompts]
-    };
-    stream.push({ type: "agent_start" });
-    stream.push({ type: "turn_start" });
-    for (const prompt of prompts) {
-      stream.push({ type: "message_start", message: prompt });
-      stream.push({ type: "message_end", message: prompt });
-    }
     try {
-      await runLoop(currentContext, newMessages, config, signal, stream, streamFn);
+      try {
+        await config.hooks?.beforeAgentStart?.();
+      } catch (e) {
+        console.warn("[AgentLoop] beforeAgentStart hook failed:", e);
+      }
+      const currentContext = {
+        ...context,
+        messages: [...context.messages, ...prompts]
+      };
+      stream.push({ type: "agent_start" });
+      stream.push({ type: "turn_start" });
+      for (const prompt of prompts) {
+        stream.push({ type: "message_start", message: prompt });
+        stream.push({ type: "message_end", message: prompt });
+      }
+      try {
+        await runLoop(currentContext, newMessages, config, signal, stream, streamFn);
+      } catch (error) {
+        await notifyOnError(config, error, "runLoop");
+        endStreamWithError(stream, newMessages, config, signal, error);
+        return;
+      }
+      try {
+        await config.hooks?.afterAgentEnd?.(newMessages);
+      } catch (e) {
+        console.warn("[AgentLoop] afterAgentEnd hook failed:", e);
+      }
     } catch (error) {
-      config.hooks?.onError?.(error, { phase: "runLoop" });
-      throw error;
-    }
-    try {
-      await config.hooks?.afterAgentEnd?.(newMessages);
-    } catch (e) {
-      console.warn("[AgentLoop] afterAgentEnd hook failed:", e);
+      await notifyOnError(config, error, "agentLoop");
+      endStreamWithError(stream, newMessages, config, signal, error);
     }
   })();
   return stream;
@@ -9044,25 +9206,31 @@ function agentLoopContinue(context, config, signal, streamFn) {
   }
   const stream = createAgentStream();
   (async () => {
-    try {
-      await config.hooks?.beforeAgentStart?.();
-    } catch (e) {
-      console.warn("[AgentLoop] beforeAgentStart hook failed:", e);
-    }
     const newMessages = [];
-    const currentContext = { ...context };
-    stream.push({ type: "agent_start" });
-    stream.push({ type: "turn_start" });
     try {
-      await runLoop(currentContext, newMessages, config, signal, stream, streamFn);
+      try {
+        await config.hooks?.beforeAgentStart?.();
+      } catch (e) {
+        console.warn("[AgentLoop] beforeAgentStart hook failed:", e);
+      }
+      const currentContext = { ...context };
+      stream.push({ type: "agent_start" });
+      stream.push({ type: "turn_start" });
+      try {
+        await runLoop(currentContext, newMessages, config, signal, stream, streamFn);
+      } catch (error) {
+        await notifyOnError(config, error, "runLoop");
+        endStreamWithError(stream, newMessages, config, signal, error);
+        return;
+      }
+      try {
+        await config.hooks?.afterAgentEnd?.(newMessages);
+      } catch (e) {
+        console.warn("[AgentLoop] afterAgentEnd hook failed:", e);
+      }
     } catch (error) {
-      config.hooks?.onError?.(error, { phase: "runLoop" });
-      throw error;
-    }
-    try {
-      await config.hooks?.afterAgentEnd?.(newMessages);
-    } catch (e) {
-      console.warn("[AgentLoop] afterAgentEnd hook failed:", e);
+      await notifyOnError(config, error, "agentLoopContinue");
+      endStreamWithError(stream, newMessages, config, signal, error);
     }
   })();
   return stream;
@@ -9098,7 +9266,7 @@ async function runLoop(currentContext, newMessages, config, signal, stream, stre
       try {
         message = await streamAssistantResponse(currentContext, config, signal, stream, streamFn);
       } catch (error) {
-        config.hooks?.onError?.(error, { phase: "streamAssistantResponse" });
+        await notifyOnError(config, error, "streamAssistantResponse");
         throw error;
       }
       newMessages.push(message);
@@ -9274,10 +9442,14 @@ async function executeToolCalls(tools, assistantMessage, signal, stream, getStee
           details: {}
         };
         isError = true;
-        hooks?.onError?.(e instanceof Error ? e : new Error(String(e)), {
-          toolName: toolCall.name,
-          phase: "toolExecution"
-        });
+        try {
+          await hooks?.onError?.(e instanceof Error ? e : new Error(String(e)), {
+            toolName: toolCall.name,
+            phase: "toolExecution"
+          });
+        } catch (hookError) {
+          console.warn(`[AgentLoop] onError hook failed during toolExecution for ${toolCall.name}:`, hookError);
+        }
       }
     }
     try {
@@ -9789,15 +9961,30 @@ var Agent = class {
       this.abortController = void 0;
     }
   }
+  reportObserverError(kind, eventType, error) {
+    console.warn(`[Agent] ${kind} failed while handling ${eventType}:`, error);
+  }
   emit(e) {
     for (const listener of this.listeners) {
-      listener(e);
+      try {
+        listener(e);
+      } catch (error) {
+        this.reportObserverError("agent event listener", e.type, error);
+      }
+    }
+    try {
+      this.emitDerivedSemanticEvents(e);
+    } catch (error) {
+      this.reportObserverError("derived semantic event", e.type, error);
     }
-    this.emitDerivedSemanticEvents(e);
   }
   emitSemantic(e) {
     for (const listener of this.semanticListeners) {
-      listener(e);
+      try {
+        listener(e);
+      } catch (error) {
+        this.reportObserverError("semantic event listener", e.type, error);
+      }
     }
   }
   updateStatusSnapshot(next) {

package/dist/chunks/{chunk-EJGQAAKS.js → chunk-SW6G4XW2.js}

@@ -8,7 +8,7 @@ import {
   getFileSystem,
   getPlatformConfig,
   streamSimple
-} from "./chunk-A5JSJAPK.js";
+} from "./chunk-D7NAXU7F.js";
 import {
   __require
 } from "./chunk-TG2EQLX2.js";
@@ -374,6 +374,182 @@ function createCompactionSummaryMessage(summary, timestamp) {
   };
 }
 
+// ../../packages/agent-framework/src/session/durable-file.ts
+var DEFAULT_FILE_RETRY_DELAYS_MS = [0, 25, 75, 150];
+function durableFilePaths(filePath) {
+  return {
+    main: filePath,
+    backup: `${filePath}.bak`,
+    previous: `${filePath}.prev`
+  };
+}
+function isTransientFileError(error) {
+  const code = typeof error === "object" && error && "code" in error ? String(error.code) : "";
+  const message = error instanceof Error ? error.message : String(error);
+  return /^(EPERM|EACCES|EBUSY|ENOTEMPTY)$/.test(code) || /\b(EPERM|EACCES|EBUSY|locked|busy)\b/i.test(message);
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function retryFileOperation(operation, retryDelaysMs) {
+  let lastError;
+  for (const [index, delayMs] of retryDelaysMs.entries()) {
+    if (delayMs > 0) {
+      await sleep(delayMs);
+    }
+    try {
+      operation();
+      return;
+    } catch (error) {
+      lastError = error;
+      if (!isTransientFileError(error) || index === retryDelaysMs.length - 1) {
+        throw error;
+      }
+    }
+  }
+  throw lastError;
+}
+function retryDelays(options) {
+  return options.retryDelaysMs ?? DEFAULT_FILE_RETRY_DELAYS_MS;
+}
+function tempPathFor(filePath, operation) {
+  return `${filePath}.${operation}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+}
+async function replaceFile(gateway, filePath, content, retryDelaysMs) {
+  const tempPath = tempPathFor(filePath, "durable");
+  gateway.writeFile(tempPath, content, "utf-8");
+  try {
+    try {
+      await retryFileOperation(() => gateway.renameFile(tempPath, filePath), retryDelaysMs);
+    } catch {
+      await retryFileOperation(() => gateway.copyFile(tempPath, filePath), retryDelaysMs);
+      try {
+        gateway.deleteFile(tempPath);
+      } catch {
+      }
+    }
+  } catch (error) {
+    try {
+      gateway.deleteFile(tempPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+async function copyExistingFile(gateway, sourcePath, destinationPath, retryDelaysMs) {
+  if (!gateway.exists(sourcePath)) {
+    return false;
+  }
+  await retryFileOperation(() => gateway.copyFile(sourcePath, destinationPath), retryDelaysMs);
+  return true;
+}
+function readCandidate(options, role, path3) {
+  if (!options.gateway.exists(path3)) {
+    return null;
+  }
+  const rawContent = options.gateway.readFile(path3, "utf-8");
+  const parsed = options.parse(rawContent, path3);
+  const updatedAt = Number.isFinite(parsed.updatedAt) ? parsed.updatedAt : 0;
+  return {
+    ...parsed,
+    updatedAt,
+    role,
+    path: path3,
+    rawContent
+  };
+}
+function candidatePriority(role) {
+  if (role === "main") return 3;
+  if (role === "backup") return 2;
+  return 1;
+}
+function chooseBestCandidate(candidates) {
+  return [...candidates].sort((a, b) => {
+    const updatedAtDiff = b.updatedAt - a.updatedAt;
+    if (updatedAtDiff !== 0) return updatedAtDiff;
+    return candidatePriority(b.role) - candidatePriority(a.role);
+  })[0];
+}
+async function writeDurableFile(options, content) {
+  const parsed = options.parse(content, options.filePath);
+  const durableContent = parsed.content;
+  const paths = durableFilePaths(options.filePath);
+  const delays = retryDelays(options);
+  if (options.gateway.exists(paths.backup)) {
+    await copyExistingFile(options.gateway, paths.backup, paths.previous, delays);
+  }
+  await replaceFile(options.gateway, paths.backup, durableContent, delays);
+  await replaceFile(options.gateway, paths.main, durableContent, delays);
+}
+async function loadDurableFile(options) {
+  const paths = durableFilePaths(options.filePath);
+  const roles = [
+    ["main", paths.main],
+    ["backup", paths.backup],
+    ["previous", paths.previous]
+  ];
+  const candidates = [];
+  for (const [role, path3] of roles) {
+    try {
+      const candidate = readCandidate(options, role, path3);
+      if (candidate) {
+        candidates.push(candidate);
+      }
+    } catch {
+    }
+  }
+  if (candidates.length === 0) {
+    return null;
+  }
+  const best = chooseBestCandidate(candidates);
+  const main = candidates.find((candidate) => candidate.role === "main");
+  const backup = candidates.find((candidate) => candidate.role === "backup");
+  const needsMainRestore = !main || main.rawContent !== best.content;
+  const needsBackupRefresh = !backup || backup.rawContent !== best.content;
+  let restoredMain = false;
+  let refreshedBackup = false;
+  let repairError;
+  const delays = retryDelays(options);
+  try {
+    if (needsBackupRefresh) {
+      if (backup && backup.rawContent !== best.content) {
+        await replaceFile(options.gateway, paths.previous, backup.content, delays);
+      }
+      await replaceFile(options.gateway, paths.backup, best.content, delays);
+      refreshedBackup = true;
+    }
+    if (needsMainRestore) {
+      await replaceFile(options.gateway, paths.main, best.content, delays);
+      restoredMain = true;
+    }
+  } catch (error) {
+    repairError = error;
+  }
+  return {
+    data: best.data,
+    content: best.content,
+    source: best.role,
+    restoredMain,
+    refreshedBackup,
+    repairError
+  };
+}
+function durableFileExists(gateway, filePath) {
+  const paths = durableFilePaths(filePath);
+  return gateway.exists(paths.main) || gateway.exists(paths.backup) || gateway.exists(paths.previous);
+}
+function deleteDurableFile(gateway, filePath) {
+  const paths = durableFilePaths(filePath);
+  let deleted = false;
+  for (const path3 of [paths.main, paths.backup, paths.previous]) {
+    if (gateway.exists(path3)) {
+      gateway.deleteFile(path3);
+      deleted = true;
+    }
+  }
+  return deleted;
+}
+
 // ../../packages/agent-framework/src/session/store.ts
 var SESSION_VERSION = 2;
 function isSessionEntry(value) {
@@ -434,28 +610,6 @@ function migrateV1ToV2(data) {
     // Keep for backward compatibility
   };
 }
-function writeFileAtomic(gateway, filePath, content) {
-  const tempPath = filePath + ".tmp";
-  gateway.writeFile(tempPath, content, "utf-8");
-  try {
-    const req = globalThis.require;
-    if (typeof req === "function") {
-      req("fs").renameSync(tempPath, filePath);
-    } else {
-      gateway.writeFile(filePath, content, "utf-8");
-      try {
-        gateway.deleteFile(tempPath);
-      } catch {
-      }
-    }
-  } catch {
-    gateway.writeFile(filePath, content, "utf-8");
-    try {
-      gateway.deleteFile(tempPath);
-    } catch {
-    }
-  }
-}
 var FileSessionStore = class {
   sessionsDir;
   gateway;
@@ -485,6 +639,33 @@ var FileSessionStore = class {
     const safeId = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
     return this.gateway.join(this.sessionsDir, `${safeId}.json`);
   }
+  normalizeLoadedData(data) {
+    if (data.version === LEGACY_VERSION || !data.version) {
+      return { data: migrateV1ToV2(data), shouldPersist: true };
+    }
+    if (data.version !== SESSION_VERSION) {
+      console.warn(
+        `[SessionStore] Session version mismatch: ${data.version} vs ${SESSION_VERSION}`
+      );
+    }
+    if (!data.entries) {
+      data.entries = [];
+    }
+    return { data, shouldPersist: false };
+  }
+  parseSessionContent(content, filePath) {
+    if (!content || content.trim().length === 0) {
+      throw new Error("empty session file");
+    }
+    const parsed = JSON.parse(content);
+    const normalized = this.normalizeLoadedData(parsed);
+    const persistedContent = normalized.shouldPersist ? JSON.stringify(normalized.data, null, 2) : content;
+    return {
+      data: normalized.data,
+      content: persistedContent,
+      updatedAt: normalized.data.metadata?.updatedAt ?? 0
+    };
+  }
   /**
    * Save a session to disk (v2 format)
    */
@@ -514,7 +695,11 @@ var FileSessionStore = class {
     };
     const json = JSON.stringify(sessionData, null, 2);
     const filePath = this.getSessionPath(sessionId);
-    writeFileAtomic(this.gateway, filePath, json);
+    await writeDurableFile({
+      gateway: this.gateway,
+      filePath,
+      parse: (content, path3) => this.parseSessionContent(content, path3)
+    }, json);
   }
   /**
    * Legacy save method for backward compatibility
@@ -542,32 +727,23 @@ var FileSessionStore = class {
    */
   async load(sessionId) {
     const filePath = this.getSessionPath(sessionId);
-    if (!this.gateway.exists(filePath)) {
-      return null;
-    }
     try {
-      const json = this.gateway.readFile(filePath, "utf-8");
-      if (!json || json.trim().length === 0) {
-        console.warn(`[SessionStore] Empty session file: ${sessionId}, removing`);
-        this.gateway.deleteFile(filePath);
+      const loaded = await loadDurableFile({
+        gateway: this.gateway,
+        filePath,
+        parse: (content, path3) => this.parseSessionContent(content, path3)
+      });
+      if (!loaded) {
         return null;
       }
-      const data = JSON.parse(json);
-      if (data.version === LEGACY_VERSION || !data.version) {
-        const migrated = migrateV1ToV2(data);
-        const migratedJson = JSON.stringify(migrated, null, 2);
-        writeFileAtomic(this.gateway, filePath, migratedJson);
-        return migrated;
-      }
-      if (data.version !== SESSION_VERSION) {
+      if (loaded.restoredMain || loaded.refreshedBackup) {
         console.warn(
-          `[SessionStore] Session version mismatch: ${data.version} vs ${SESSION_VERSION}`
+          `[SessionStore] Repaired session ${sessionId} from ${loaded.source}` + (loaded.repairError ? ` with repair warning: ${loaded.repairError}` : "")
         );
+      } else if (loaded.repairError) {
+        console.warn(`[SessionStore] Loaded session ${sessionId} but sidecar refresh failed: ${loaded.repairError}`);
       }
-      if (!data.entries) {
-        data.entries = [];
-      }
-      return data;
+      return loaded.data;
     } catch (e) {
       console.error(`[SessionStore] Failed to load session: ${sessionId}`, e);
       return null;
@@ -578,12 +754,8 @@ var FileSessionStore = class {
    */
   async delete(sessionId) {
     const filePath = this.getSessionPath(sessionId);
-    if (!this.gateway.exists(filePath)) {
-      return false;
-    }
     try {
-      this.gateway.deleteFile(filePath);
-      return true;
+      return deleteDurableFile(this.gateway, filePath);
     } catch (e) {
       console.error(`[SessionStore] Failed to delete session: ${sessionId}`, e);
       return false;
@@ -594,7 +766,7 @@ var FileSessionStore = class {
    */
   async exists(sessionId) {
     const filePath = this.getSessionPath(sessionId);
-    return this.gateway.exists(filePath);
+    return durableFileExists(this.gateway, filePath);
   }
   /**
    * List all session IDs
@@ -604,7 +776,20 @@ var FileSessionStore = class {
       return [];
     }
     const files = this.gateway.readdir(this.sessionsDir);
-    return files.filter((f) => f.endsWith(".json")).filter((f) => !f.endsWith("-files.json")).map((f) => f.replace(/\.json$/i, ""));
+    const sessionIds = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      if (file.endsWith("-files.json") || file.endsWith("-files.json.bak") || file.endsWith("-files.json.prev")) {
+        continue;
+      }
+      if (file.endsWith(".json")) {
+        sessionIds.add(file.replace(/\.json$/i, ""));
+      } else if (file.endsWith(".json.bak")) {
+        sessionIds.add(file.replace(/\.json\.bak$/i, ""));
+      } else if (file.endsWith(".json.prev")) {
+        sessionIds.add(file.replace(/\.json\.prev$/i, ""));
+      }
+    }
+    return [...sessionIds];
   }
   /**
    * List all session metadata
@@ -1230,6 +1415,8 @@ function summarizeToolResultForGuard(result) {
   const text = content.filter((block) => !!block && typeof block === "object" && "type" in block).filter((block) => block.type === "text").map((block) => block.text || "").join("\n").trim();
   return text || stableStringify(result);
 }
+var RUNAWAY_TOOLCALL_WHITESPACE_DELTA_CHARS = 16384;
+var RUNAWAY_TOOLCALL_WHITESPACE_DELTA_EVENTS = 40;
 function cloneQueuedInput(input) {
   return {
     ...input,
@@ -1262,6 +1449,10 @@ var AgentSessionController = class {
   pendingAutoCompact;
   queueIdCounter = 0;
   repeatedToolFailures = /* @__PURE__ */ new Map();
+  streamGuard = {
+    whitespaceToolCallDeltaChars: 0,
+    whitespaceToolCallDeltaEvents: 0
+  };
   runtimeGuardTriggered = false;
   constructor(options) {
     this.agent = options.agent;
@@ -1285,6 +1476,9 @@ var AgentSessionController = class {
         this.resetRuntimeGuardState();
         this.emit({ type: "streaming_changed", isStreaming: true });
       }
+      if (event.type === "message_update") {
+        this.recordMessageUpdateForGuard(event);
+      }
       if (event.type === "tool_execution_end") {
         this.recordToolExecutionEndForGuard(event);
       }
@@ -1879,8 +2073,52 @@ var AgentSessionController = class {
   }
   resetRuntimeGuardState() {
     this.repeatedToolFailures.clear();
+    this.streamGuard = {
+      whitespaceToolCallDeltaChars: 0,
+      whitespaceToolCallDeltaEvents: 0
+    };
     this.runtimeGuardTriggered = false;
   }
+  triggerRuntimeGuard(toolName, repeatCount, reason) {
+    if (this.runtimeGuardTriggered) {
+      return;
+    }
+    this.runtimeGuardTriggered = true;
+    this.cancelRetry();
+    this.cancelAutoCompactTimerOnly();
+    this.cancelDispatchTimerOnly();
+    this.cancelAutoContinueTimerOnly();
+    this.emit({ type: "runtime_guard_triggered", toolName, repeatCount, reason });
+    this.agent.abort();
+  }
+  recordMessageUpdateForGuard(event) {
+    if (this.runtimeGuardTriggered) {
+      return;
+    }
+    const assistantEvent = event.assistantMessageEvent;
+    if (assistantEvent.type !== "toolcall_delta") {
+      this.streamGuard.whitespaceToolCallDeltaChars = 0;
+      this.streamGuard.whitespaceToolCallDeltaEvents = 0;
+      return;
+    }
+    if (assistantEvent.delta.trim().length > 0) {
+      this.streamGuard.whitespaceToolCallDeltaChars = 0;
+      this.streamGuard.whitespaceToolCallDeltaEvents = 0;
+      return;
+    }
+    this.streamGuard.whitespaceToolCallDeltaChars += assistantEvent.delta.length;
+    this.streamGuard.whitespaceToolCallDeltaEvents += 1;
+    const content = event.message.role === "assistant" && Array.isArray(event.message.content) ? event.message.content[assistantEvent.contentIndex] : void 0;
+    const partialArgs = typeof content?.partialArgs === "string" ? content.partialArgs : "";
+    const sparsePartialArgs = partialArgs.length >= RUNAWAY_TOOLCALL_WHITESPACE_DELTA_CHARS && partialArgs.replace(/\s/g, "").length / partialArgs.length < 0.05;
+    if (sparsePartialArgs || this.streamGuard.whitespaceToolCallDeltaChars >= RUNAWAY_TOOLCALL_WHITESPACE_DELTA_CHARS && this.streamGuard.whitespaceToolCallDeltaEvents >= RUNAWAY_TOOLCALL_WHITESPACE_DELTA_EVENTS) {
+      this.triggerRuntimeGuard(
+        "assistant_stream",
+        this.streamGuard.whitespaceToolCallDeltaEvents,
+        "runaway_tool_call_arguments"
+      );
+    }
+  }
   recordToolExecutionEndForGuard(event) {
     if (!event.isError) {
       const prefix = `${event.toolName}:`;
@@ -1898,14 +2136,7 @@ var AgentSessionController = class {
     if (repeatCount < 3 || this.runtimeGuardTriggered) {
       return;
     }
-    this.runtimeGuardTriggered = true;
-    this.cancelRetry();
-    this.cancelAutoCompactTimerOnly();
-    this.cancelDispatchTimerOnly();
-    this.cancelAutoContinueTimerOnly();
-    const reason = "repeated_tool_error";
-    this.emit({ type: "runtime_guard_triggered", toolName: event.toolName, repeatCount, reason });
-    this.agent.abort();
+    this.triggerRuntimeGuard(event.toolName, repeatCount, "repeated_tool_error");
   }
   emit(event) {
     for (const listener of this.listeners) {
@@ -3184,7 +3415,11 @@ var SessionTraceSnapshotWriter = class {
       this.flushTimer = null;
     }
     if (!this.cachedController || !this.cachedSessionId) return;
-    this.options.saveTrace(this.cachedController.getSnapshot());
+    try {
+      this.options.saveTrace(this.cachedController.getSnapshot());
+    } catch (error) {
+      console.warn("[SessionTrace] Failed to save session trace:", error);
+    }
   }
   notePendingUserText(text) {
     this.mutate((controller) => {
@@ -3567,7 +3802,7 @@ function inferUncertainty(text, signals) {
 function isParentHandoffRequired(task) {
   return task.needsParentWrite || task.status === "timeout" || task.status === "failed" || task.confidenceSignals.some((signal) => signal.type === "tool_error" || signal.type === "no_tool_use");
 }
-async function runSubagentWithProgress(deps, task, reportProgress) {
+async function runSubagentWithProgress(deps, task, reportProgress, signal) {
   const startTime = Date.now();
   task.status = "running";
   let timedOut = false;
@@ -3588,6 +3823,9 @@ async function runSubagentWithProgress(deps, task, reportProgress) {
     if (!apiKey) {
       throw new Error("No API key available for subagent execution.");
     }
+    if (signal?.aborted) {
+      throw new Error("Subagent aborted by parent");
+    }
     deps.log(`[Subagent ${task.name}] Plan: ${plan.complexity}/${plan.modelClass}, ${tools.length} tools`);
     deps.debugLog?.("plan", "SubagentPlan", plan);
     const systemPrompt = `You are a specialized subagent focused on one bounded task.
@@ -3611,6 +3849,7 @@ ${formatSkillsForPrompt(deps.skills ?? [])}`;
     let rejectTimeout = () => void 0;
     let timeout;
     let unsubscribe;
+    let removeAbortListener;
     const timeoutPromise = new Promise((_, reject) => {
       rejectTimeout = reject;
     });
@@ -3620,6 +3859,19 @@ ${formatSkillsForPrompt(deps.skills ?? [])}`;
       subagent.abort?.();
       rejectTimeout(new Error(timeoutMessage));
     }, plan.timeoutSeconds * 1e3);
+    const abortPromise = new Promise((_, reject) => {
+      if (!signal) return;
+      const abortSubagent = () => {
+        subagent.abort?.();
+        reject(new Error("Subagent aborted by parent"));
+      };
+      if (signal.aborted) {
+        abortSubagent();
+        return;
+      }
+      signal.addEventListener("abort", abortSubagent, { once: true });
+      removeAbortListener = () => signal.removeEventListener("abort", abortSubagent);
+    });
     unsubscribe = subagent.subscribe((event) => {
       if (event.type === "tool_execution_start") {
         toolCalls++;
@@ -3654,12 +3906,14 @@ ${formatSkillsForPrompt(deps.skills ?? [])}`;
           await subagent.prompt(prompt);
           await subagent.waitForIdle?.();
         })(),
-        timeoutPromise
+        timeoutPromise,
+        abortPromise
       ]);
     } finally {
       if (timeout) {
         clearTimeout(timeout);
       }
+      removeAbortListener?.();
       unsubscribe?.();
     }
     const messages = subagent.state.messages;
@@ -3795,9 +4049,19 @@ Use this for independent investigation, search, review, or triage work. Provide
         { description: "Array of tasks to run in parallel", minItems: 1, maxItems: 10 }
       )
     }, { additionalProperties: false }),
-    async execute(first, second) {
+    async execute(first, second, third, fourth) {
       const args = typeof first === "string" ? second : first;
-      const toolContext = typeof first === "string" ? { log: deps.log } : second;
+      const signal = typeof first === "string" ? third : second?.signal;
+      const reportProgress = typeof first === "string" ? fourth ? (update) => {
+        fourth({
+          content: update.message ? [{ type: "text", text: update.message }] : [],
+          details: { increment: update.increment }
+        });
+      } : () => void 0 : second?.reportProgress ?? (() => void 0);
+      const toolContext = {
+        log: typeof first === "string" ? deps.log : second?.log ?? deps.log,
+        reportProgress
+      };
       const normalized = normalizeTaskDefs(args);
       if ("error" in normalized) {
         return {
@@ -3825,7 +4089,7 @@ Use this for independent investigation, search, review, or triage work. Provide
       toolContext.log?.(`Spawning ${tasks.length} parallel subagents: ${tasks.map((task) => task.name).join(", ")}`);
       toolContext.reportProgress?.({ message: `Launching ${tasks.length} parallel subagents...`, increment: 5 });
       const startTime = Date.now();
-      await Promise.all(tasks.map((task) => runSubagentWithProgress(deps, task, toolContext.reportProgress ?? (() => void 0))));
+      await Promise.all(tasks.map((task) => runSubagentWithProgress(deps, task, toolContext.reportProgress, signal)));
       const totalDuration = Date.now() - startTime;
       const completed = tasks.filter((task) => task.status === "completed").length;
       const failed = tasks.filter((task) => task.status === "failed" || task.status === "timeout").length;

package/dist/chunks/{chunk-R2HMYSEK.js → chunk-YLOLJRLJ.js}

@@ -8,10 +8,10 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-EJGQAAKS.js";
+} from "./chunk-SW6G4XW2.js";
 import {
   Type
-} from "./chunk-A5JSJAPK.js";
+} from "./chunk-D7NAXU7F.js";
 
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, renameSync } from "fs";

package/dist/chunks/{src-3X3HBT2G.js → src-LZC56DRG.js}

@@ -3,7 +3,7 @@ import {
   Agent,
   agentLoop,
   agentLoopContinue
-} from "./chunk-A5JSJAPK.js";
+} from "./chunk-D7NAXU7F.js";
 import "./chunk-TG2EQLX2.js";
 export {
   Agent,

package/dist/cli.js

@@ -14,7 +14,7 @@ import {
   getSettingsPath,
   getThemesDir,
   migrateConfigFromAgentDir
-} from "./chunks/chunk-R2HMYSEK.js";
+} from "./chunks/chunk-YLOLJRLJ.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -52,7 +52,7 @@ import {
   selectToolsForRuntimePolicy,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-EJGQAAKS.js";
+} from "./chunks/chunk-SW6G4XW2.js";
 import {
   Deref,
   Errors,
@@ -86,7 +86,7 @@ import {
   setLogger,
   sortToolModelCandidatesByCapability,
   type_exports
-} from "./chunks/chunk-A5JSJAPK.js";
+} from "./chunks/chunk-D7NAXU7F.js";
 import {
   resolveCliProjectRoot
 } from "./chunks/chunk-NTYHFBUA.js";
@@ -56031,6 +56031,27 @@ var ExecutionStateManager = class {
 // src/session-trace.ts
 import * as fs15 from "node:fs";
 import * as path16 from "node:path";
+function saveTraceFileBestEffort(tracePath, content) {
+  const tempPath = `${tracePath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs15.writeFileSync(tempPath, content, "utf8");
+    try {
+      fs15.renameSync(tempPath, tracePath);
+      return;
+    } catch {
+      try {
+        fs15.copyFileSync(tempPath, tracePath);
+      } catch {
+      } finally {
+        try {
+          fs15.unlinkSync(tempPath);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
 var SessionTraceWriter = class extends SessionTraceSnapshotWriter {
   constructor(sessionsDir, sessionManager) {
     super({
@@ -56046,9 +56067,7 @@ var SessionTraceWriter = class extends SessionTraceSnapshotWriter {
       },
       saveTrace: (trace) => {
         const tracePath = path16.join(sessionsDir, `${trace.sessionId}.trace.json`);
-        const tempPath = `${tracePath}.tmp`;
-        fs15.writeFileSync(tempPath, JSON.stringify(trace, null, 2), "utf8");
-        fs15.renameSync(tempPath, tracePath);
+        saveTraceFileBestEffort(tracePath, JSON.stringify(trace, null, 2));
       }
     });
     this.sessionsDir = sessionsDir;
@@ -65328,7 +65347,7 @@ var InteractiveMode = class {
     if (savedLevel) {
       this.thinkingLevel = savedLevel;
     }
-    const { Agent } = await import("./chunks/src-3X3HBT2G.js");
+    const { Agent } = await import("./chunks/src-LZC56DRG.js");
     const activeSession = this.sessionManager.getActiveSession();
     this.agent = new Agent({
       initialState: {
@@ -67321,7 +67340,7 @@ async function startChat(initialPrompt, testCommand) {
 `);
       console.log("Assistant: ");
     }
-    const { Agent } = await import("./chunks/src-3X3HBT2G.js");
+    const { Agent } = await import("./chunks/src-LZC56DRG.js");
     let agent;
     const printModeExtensions = await loadPrintModeExtensions({
       cwd,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cydm/pie",
-	"version": "1.0.10",
+	"version": "1.0.12",
 	"description": "Pie AI Agent CLI",
 	"type": "module",
 	"bin": {