@cydm/pie 1.0.11 → 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-H6PTIABA.js";
-import "../../../chunks/chunk-QACYLY3B.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-H6PTIABA.js";
-import "../../../chunks/chunk-QACYLY3B.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-GNHANWYT.js";
+} from "../../../chunks/chunk-YLOLJRLJ.js";
 import {
   createSharedFileSystemTools,
   createSubagentCapability
-} from "../../../chunks/chunk-H6PTIABA.js";
-import "../../../chunks/chunk-QACYLY3B.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-H6PTIABA.js";
-import "../../../chunks/chunk-QACYLY3B.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-QACYLY3B.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);

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

@@ -8,7 +8,7 @@ import {
   getFileSystem,
   getPlatformConfig,
   streamSimple
-} from "./chunk-QACYLY3B.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}.${Date.now()}.${Math.random().toString(36).slice(2)}.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

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

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

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

@@ -3,7 +3,7 @@ import {
   Agent,
   agentLoop,
   agentLoopContinue
-} from "./chunk-QACYLY3B.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-GNHANWYT.js";
+} from "./chunks/chunk-YLOLJRLJ.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -52,7 +52,7 @@ import {
   selectToolsForRuntimePolicy,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-H6PTIABA.js";
+} from "./chunks/chunk-SW6G4XW2.js";
 import {
   Deref,
   Errors,
@@ -86,7 +86,7 @@ import {
   setLogger,
   sortToolModelCandidatesByCapability,
   type_exports
-} from "./chunks/chunk-QACYLY3B.js";
+} from "./chunks/chunk-D7NAXU7F.js";
 import {
   resolveCliProjectRoot
 } from "./chunks/chunk-NTYHFBUA.js";
@@ -65347,7 +65347,7 @@ var InteractiveMode = class {
     if (savedLevel) {
       this.thinkingLevel = savedLevel;
     }
-    const { Agent } = await import("./chunks/src-M32UEGIU.js");
+    const { Agent } = await import("./chunks/src-LZC56DRG.js");
     const activeSession = this.sessionManager.getActiveSession();
     this.agent = new Agent({
       initialState: {
@@ -67340,7 +67340,7 @@ async function startChat(initialPrompt, testCommand) {
 `);
       console.log("Assistant: ");
     }
-    const { Agent } = await import("./chunks/src-M32UEGIU.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.11",
+	"version": "1.0.12",
 	"description": "Pie AI Agent CLI",
 	"type": "module",
 	"bin": {