@cydm/pie 2.5.0 → 2.5.1

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

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createAskUserCapability
-} from "../../../chunks/chunk-JXY3YLDS.js";
+} from "../../../chunks/chunk-REP6QANY.js";
 import "../../../chunks/chunk-ZKHMNEXL.js";
 import "../../../chunks/chunk-YRXXRLMQ.js";
 import "../../../chunks/chunk-XXGYUYXI.js";

package/dist/builtin/extensions/herdr-agent-state/index.js

@@ -136,7 +136,42 @@ function spawnHerdrReport(binPath, args, timeoutMs = REPORT_TIMEOUT_MS) {
   } catch {
   }
 }
-function attachHerdrReporter(host, herdr, transport = (args) => spawnHerdrReport(herdr.binPath, args), sequencer = createReportSequencer()) {
+var KILL_GRACE_MS = 1e3;
+async function runHerdrReportBounded(binPath, args, timeoutMs = REPORT_TIMEOUT_MS) {
+  let child;
+  try {
+    child = spawn(binPath, args, { detached: true, stdio: "ignore" });
+  } catch {
+    return { outcome: "spawn-error", exitCode: null };
+  }
+  return await new Promise((resolve) => {
+    let killTimer;
+    let settled = false;
+    const finish = (outcome, exitCode) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (killTimer) clearTimeout(killTimer);
+      resolve({ outcome, exitCode });
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      killTimer = setTimeout(() => {
+        try {
+          if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+        } catch {
+        }
+        killTimer = setTimeout(() => finish("escalated", child.exitCode), 250);
+      }, KILL_GRACE_MS);
+    }, timeoutMs);
+    child.on("error", () => finish("spawn-error", null));
+    child.on("exit", (code) => finish("exited", code));
+  });
+}
+function attachHerdrReporter(host, herdr, transport = (args) => spawnHerdrReport(herdr.binPath, args), sequencer = createReportSequencer(), shutdownTransport = (args) => runHerdrReportBounded(herdr.binPath, args)) {
   const nextSeq = sequencer;
   let agentActive = false;
   const blockingToolCalls = /* @__PURE__ */ new Map();
@@ -238,10 +273,10 @@ function attachHerdrReporter(host, herdr, transport = (args) => spawnHerdrReport
     }
     publishState();
   });
-  host.registerCleanup?.((reason) => {
+  host.registerCleanup?.(async (reason) => {
     if (reason !== "shutdown") return;
     if (!heldPane) return;
-    report(
+    await shutdownTransport(
       buildReleaseReportArgs({
         paneId: herdr.paneId,
         source: SOURCE_ID,
@@ -267,6 +302,7 @@ export {
   createReportSequencer,
   herdrAgentStateExtension as default,
   readHerdrEnvironment,
+  runHerdrReportBounded,
   spawnHerdrReport,
   summarizeAskUserQuestion
 };

package/dist/builtin/extensions/mcp-adapter/index.js

@@ -24724,11 +24724,13 @@ var McpServerManager = class {
     };
     for (const tools of Object.values(this.readCacheFile())) {
       for (const tool of tools) {
-        if (!this.definitions.has(tool.server)) continue;
+        const definition = this.definitions.get(tool.server);
+        if (!definition || definition.disabled) continue;
         claim2(tool, false);
       }
     }
     for (const runtime of this.runtimes.values()) {
+      if (runtime.definition.disabled) continue;
       for (const tool of runtime.tools ?? []) claim2(tool, true);
     }
     for (const name of conflicts) {
@@ -24849,6 +24851,20 @@ ${tail}` : "")
         error: `MCP call "${prefixedName}" was cancelled before the request was sent; nothing was executed.`
       };
     }
+    const postConnectCatalog = this.loadCatalog();
+    if (this.conflictedNames.has(prefixedName)) {
+      return {
+        delivery: "not_sent",
+        error: `MCP tool name "${prefixedName}" became claimed by more than one server during connection. Rename one of the servers so every tool name is unambiguous; the call was NOT sent.`
+      };
+    }
+    const postDescriptor = postConnectCatalog.find((tool) => tool.prefixedName === prefixedName);
+    if (postDescriptor && (postDescriptor.server !== server || postDescriptor.tool !== toolName)) {
+      return {
+        delivery: "not_sent",
+        error: `MCP tool "${prefixedName}" resolved to ${postDescriptor.server}/${postDescriptor.tool} after connecting; refusing to send the stale target ${server}/${toolName}. Retry the call.`
+      };
+    }
     try {
       const result = await withTimeout(
         client.callTool({ name: toolName, arguments: args }, void 0, signal !== void 0 ? { signal } : void 0),
@@ -25266,19 +25282,26 @@ function mcpAdapter(ctx) {
     ctx.log
   );
   async function reloadManager() {
-    await manager.dispose().catch(() => void 0);
+    let replacement;
     try {
-      manager = new McpServerManager(
-        resolveMcpAdapterConfig(ctx.cwd, configDir).servers,
-        metadataCacheDir,
-        ctx.log
-      );
+      const resolved = resolveMcpAdapterConfig(ctx.cwd, configDir);
+      if (resolved.problems.length > 0) {
+        const message = `config layers failed to parse: ${resolved.problems.join("; ")}`;
+        ctx.log(`mcp: config reload failed, keeping the previous manager: ${message}`);
+        if (ctx.hasUI) ctx.ui.notify(`MCP adapter config error (previous servers kept): ${message}`, "error");
+        return { ok: false, error: message };
+      }
+      replacement = new McpServerManager(resolved.servers, metadataCacheDir, ctx.log);
     } catch (error2) {
       const message = error2 instanceof Error ? error2.message : String(error2);
-      ctx.log(`mcp: config reload failed: ${message}`);
-      if (ctx.hasUI) ctx.ui.notify(`MCP adapter config error: ${message}`, "error");
-      manager = new McpServerManager([], metadataCacheDir, ctx.log);
+      ctx.log(`mcp: config reload failed, keeping the previous manager: ${message}`);
+      if (ctx.hasUI) ctx.ui.notify(`MCP adapter config error (previous servers kept): ${message}`, "error");
+      return { ok: false, error: message };
     }
+    const previous = manager;
+    manager = replacement;
+    await previous.dispose().catch(() => void 0);
+    return { ok: true };
   }
   ctx.registerCleanup?.(() => manager.dispose().catch(() => void 0));
   function readProjectOverride() {
@@ -25359,6 +25382,7 @@ function mcpAdapter(ctx) {
         }
         const overrides = readProjectOverride().mcpServers;
         const forceEnabled = overrides?.[definition.name]?.disabled === false;
+        const previousOverride = overrides?.[definition.name]?.disabled;
         const filePath = writeProjectOverride(
           definition.name,
           // enable must lift a source-level disabled:true with an explicit
@@ -25367,8 +25391,24 @@ function mcpAdapter(ctx) {
           // existing force-enable on repeated enable commands too.
           sub === "disable" ? true : definition.disabled || forceEnabled ? false : null
         );
-        await reloadManager();
-        const effectiveDisabled = manager.getDefinition(definition.name)?.disabled ?? false;
+        const reload = await reloadManager();
+        if (!reload.ok) {
+          writeProjectOverride(definition.name, previousOverride === void 0 ? null : previousOverride);
+          commandCtx.ui.notify(
+            `MCP server "${definition.name}" NOT ${sub === "disable" ? "disabled" : "enabled"}: config reload failed (${reload.error}); previous servers kept and the override was rolled back.`,
+            "error"
+          );
+          return;
+        }
+        const reloaded = manager.getDefinition(definition.name);
+        if (!reloaded) {
+          commandCtx.ui.notify(
+            `MCP server "${definition.name}" disappeared from the reloaded config (wrote ${filePath}); check project/global config merges.`,
+            "error"
+          );
+          return;
+        }
+        const effectiveDisabled = reloaded.disabled;
         const stateLabel = effectiveDisabled ? "disabled" : sub === "disable" ? "still enabled" : "enabled";
         commandCtx.ui.notify(
           `MCP server "${definition.name}" ${stateLabel} (wrote ${filePath}). ` + (eagerRegistered.length > 0 ? "Restart or /reload to resync direct tools." : "Effective immediately."),

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

@@ -7,7 +7,7 @@ import {
   isPlanModeSafeCommand,
   markCompletedPlanSteps,
   restoreExecutionState
-} from "../../../chunks/chunk-JXY3YLDS.js";
+} from "../../../chunks/chunk-REP6QANY.js";
 import "../../../chunks/chunk-ZKHMNEXL.js";
 import "../../../chunks/chunk-YRXXRLMQ.js";
 import {

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

@@ -1,11 +1,11 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createCliHostCapabilities
-} from "../../../chunks/chunk-PU7IIEKH.js";
+} from "../../../chunks/chunk-N2MK46AE.js";
 import {
   createSharedFileSystemTools,
   createSubagentCapability
-} from "../../../chunks/chunk-JXY3YLDS.js";
+} from "../../../chunks/chunk-REP6QANY.js";
 import "../../../chunks/chunk-ZKHMNEXL.js";
 import "../../../chunks/chunk-YRXXRLMQ.js";
 import "../../../chunks/chunk-5353DEEC.js";

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

@@ -8,7 +8,7 @@ import {
   executeManageTodoList,
   executionStateToTodos,
   restoreExecutionState
-} from "../../../chunks/chunk-JXY3YLDS.js";
+} from "../../../chunks/chunk-REP6QANY.js";
 import "../../../chunks/chunk-ZKHMNEXL.js";
 import "../../../chunks/chunk-YRXXRLMQ.js";
 import "../../../chunks/chunk-XXGYUYXI.js";

package/dist/chunks/{chunk-PU7IIEKH.js → chunk-N2MK46AE.js}

@@ -8,7 +8,7 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-JXY3YLDS.js";
+} from "./chunk-REP6QANY.js";
 import {
   getBuiltinDir,
   getConfigDir
@@ -543,9 +543,24 @@ function createBashTool(defaultCwd, options) {
           totalNewlines += data.reduce((count, byte) => count + (byte === 10 ? 1 : 0), 0);
           if (headBytes >= maxHeadBytes) return;
           const prefix = data.subarray(0, maxHeadBytes - headBytes);
-          headChunks.push(prefix);
+          headChunks.push(Buffer.from(prefix));
           headBytes += prefix.length;
         };
+        const appendRollingChunk = (data) => {
+          const owned = Buffer.from(data);
+          chunks.push(owned);
+          chunksBytes += owned.length;
+          while (chunksBytes > maxChunksBytes && chunks.length > 1) {
+            const removed = chunks.shift();
+            chunksBytes -= removed.length;
+          }
+          if (chunks.length === 1 && chunksBytes > maxChunksBytes) {
+            const only = chunks[0];
+            const tail = only.subarray(only.length - maxChunksBytes);
+            chunks[0] = Buffer.from(tail);
+            chunksBytes = tail.length;
+          }
+        };
         let timedOut = false;
         let processExited = false;
         let exitCode = null;
@@ -641,12 +656,7 @@ function createBashTool(defaultCwd, options) {
               return;
             }
           }
-          chunks.push(data);
-          chunksBytes += data.length;
-          while (chunksBytes > maxChunksBytes && chunks.length > 1) {
-            const removed = chunks.shift();
-            chunksBytes -= removed.length;
-          }
+          appendRollingChunk(data);
           if (onUpdate) {
             const fullBuffer = Buffer.concat(chunks);
             const fullText = fullBuffer.toString("utf-8");
@@ -700,12 +710,7 @@ function createBashTool(defaultCwd, options) {
               return;
             }
           }
-          chunks.push(data);
-          chunksBytes += data.length;
-          while (chunksBytes > maxChunksBytes && chunks.length > 1) {
-            const removed = chunks.shift();
-            chunksBytes -= removed.length;
-          }
+          appendRollingChunk(data);
         });
         const finishExecution = async (code, sig, stdioIncomplete = false) => {
           if (settled) return;

package/dist/chunks/{chunk-JXY3YLDS.js → chunk-REP6QANY.js}

@@ -1742,8 +1742,7 @@ function normalizeTaskDefs(args) {
     if (def.model !== void 0 && !modelOverride) {
       return { error: `Invalid task #${index + 1}: "model" must be a non-empty model reference such as "provider/model-id".` };
     }
-    const thinkingLevel = typeof def.thinkingLevel === "string" ? def.thinkingLevel.trim() : void 0;
-    if (def.thinkingLevel !== void 0 && (!thinkingLevel || !SUBAGENT_THINKING_LEVELS.includes(thinkingLevel))) {
+    if (def.thinkingLevel !== void 0 && (typeof def.thinkingLevel !== "string" || !SUBAGENT_THINKING_LEVELS.includes(def.thinkingLevel))) {
       return { error: `Invalid task #${index + 1}: "thinkingLevel" must be one of ${SUBAGENT_THINKING_LEVELS.map((level) => `"${level}"`).join(", ")}.` };
     }
     normalized.push({
@@ -1752,7 +1751,7 @@ function normalizeTaskDefs(args) {
       priority,
       timeoutSeconds,
       modelOverride,
-      thinkingLevel
+      thinkingLevel: def.thinkingLevel
     });
   }
   return normalized;
@@ -2968,6 +2967,9 @@ var FileSessionStore = class {
     throw new Error(`Session directory is a symbolic link; ${operation} refused: ${dir}`);
   }
   headStatus(sessionId) {
+    if (sessionDirIsSymlink(this.pathsFor(sessionId).dir)) {
+      return "missing";
+    }
     const head = this.tryReadHeadFile(sessionId);
     if (head === "corrupt") {
       return "corrupt";
@@ -3023,6 +3025,9 @@ var FileSessionStore = class {
    * never reinitialize a damaged session to sequence 0.
    */
   tryReadHeadFile(sessionId) {
+    if (sessionDirIsSymlink(this.pathsFor(sessionId).dir)) {
+      return null;
+    }
     const headPath = this.pathsFor(sessionId).headPath;
     const durable = readDurableFileSync(this.gateway, headPath, (content) => this.parseHeadContent(content));
     if (durable !== null) {

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   createCliWebResearchHealthStore,
   formatSize,
   truncateHeadTail
-} from "./chunks/chunk-PU7IIEKH.js";
+} from "./chunks/chunk-N2MK46AE.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -60,7 +60,7 @@ import {
   setExtensionEnabledInSettings,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-JXY3YLDS.js";
+} from "./chunks/chunk-REP6QANY.js";
 import "./chunks/chunk-ZKHMNEXL.js";
 import {
   Deref,
@@ -55209,11 +55209,44 @@ function canonicalSessionDir(sessionsDir, sessionId) {
 function publishJournalPath(sessionsDir, safeTargetId) {
   return path7.join(sessionsDir, PUBLISH_JOURNAL_DIR, `${safeTargetId}.json`);
 }
+var FSYNC_UNSUPPORTED_CODES = /* @__PURE__ */ new Set(["EPERM", "EINVAL", "ENOTSUP", "EOPNOTSUPP", "EACCES", "EBADF"]);
+function fsyncDirectory(dirPath) {
+  try {
+    const fd = fs7.openSync(dirPath, "r");
+    try {
+      fs7.fsyncSync(fd);
+    } finally {
+      fs7.closeSync(fd);
+    }
+  } catch (error) {
+    const code = error?.code;
+    if (code !== void 0 && FSYNC_UNSUPPORTED_CODES.has(code)) return;
+    throw error;
+  }
+}
 function writePublishJournal(journalPath, record) {
-  fs7.mkdirSync(path7.dirname(journalPath), { recursive: true });
+  const journalDir = path7.dirname(journalPath);
+  fs7.mkdirSync(journalDir, { recursive: true });
   const tempPath = `${journalPath}.tmp`;
   fs7.writeFileSync(tempPath, JSON.stringify(record, void 0, "	"));
+  const tempFd = fs7.openSync(tempPath, "r+");
+  try {
+    fs7.fsyncSync(tempFd);
+  } finally {
+    fs7.closeSync(tempFd);
+  }
   fs7.renameSync(tempPath, journalPath);
+  fsyncDirectory(journalDir);
+  fsyncDirectory(path7.dirname(journalDir));
+}
+function markPublishJournalFailed(journalPath) {
+  if (!journalPath) return;
+  try {
+    const record = JSON.parse(fs7.readFileSync(journalPath, "utf8"));
+    if (record?.v !== 1 || typeof record.failedAt === "number") return;
+    writePublishJournal(journalPath, { ...record, failedAt: Date.now() });
+  } catch {
+  }
 }
 function clearPublishJournal(journalPath) {
   if (!journalPath) return;
@@ -55266,6 +55299,7 @@ async function rewindStoredSession(params) {
 }
 async function forkStoredSession(params) {
   let stagingId;
+  let preserveStagingForRecovery = false;
   try {
     const sanitizedTargetId = params.targetSessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
     if (sanitizedTargetId.startsWith(STAGING_SESSION_ID_PREFIX)) {
@@ -55396,6 +55430,7 @@ async function forkStoredSession(params) {
     if (hadPreviousTarget) {
       try {
         params.store.moveSession(params.targetSessionId, backupId);
+        if (params.sessionsDir) fsyncDirectory(params.sessionsDir);
       } catch (error) {
         clearPublishJournal(journalPath);
         throw error;
@@ -55403,6 +55438,7 @@ async function forkStoredSession(params) {
     }
     try {
       params.store.moveSession(stagingId, params.targetSessionId);
+      if (params.sessionsDir) fsyncDirectory(params.sessionsDir);
     } catch (error) {
       if (hadPreviousTarget) {
         try {
@@ -55410,8 +55446,11 @@ async function forkStoredSession(params) {
             throw new Error("target path is occupied");
           }
           params.store.moveSession(backupId, params.targetSessionId);
+          if (params.sessionsDir) fsyncDirectory(params.sessionsDir);
           clearPublishJournal(journalPath);
         } catch (restoreError) {
+          markPublishJournalFailed(journalPath);
+          preserveStagingForRecovery = true;
           throw new SessionControlError(
             "session_io_error",
             `Fork publication failed; previous session is preserved as ${backupId}. Restore failed: ${String(restoreError)}`,
@@ -55446,7 +55485,7 @@ async function forkStoredSession(params) {
   } catch (error) {
     throw toIoError(error);
   } finally {
-    if (stagingId) {
+    if (stagingId && !preserveStagingForRecovery) {
       try {
         params.store.delete(stagingId);
       } catch {
@@ -55519,7 +55558,7 @@ function recoverOnePublishJournal(params) {
   try {
     const parsed = JSON.parse(fs7.readFileSync(params.journalPath, "utf8"));
     const safeId = /^[a-zA-Z0-9_-]+$/;
-    if (parsed?.v !== 1 || !safeId.test(parsed.targetId ?? "") || !safeId.test(parsed.stagingId ?? "") || !((parsed.backupDir ?? null) === null || safeId.test(parsed.backupDir))) {
+    if (parsed?.v !== 1 || !safeId.test(parsed.targetId ?? "") || !safeId.test(parsed.stagingId ?? "") || !((parsed.backupDir ?? null) === null || safeId.test(parsed.backupDir)) || !((parsed.failedAt ?? void 0) === void 0 || typeof parsed.failedAt === "number")) {
       throw new Error("journal record has unexpected shape");
     }
     record = parsed;
@@ -55545,7 +55584,7 @@ function recoverOnePublishJournal(params) {
   const backupExists = record.backupDir ? dirExists(record.backupDir) : false;
   const stagingExists = dirExists(record.stagingId);
   try {
-    if (targetExists && !stagingExists) {
+    if (targetExists && !stagingExists && record.failedAt === void 0) {
       if (backupExists && record.backupDir) removeSessionDir(record.backupDir);
       removeJournal();
       return { action: "publish-completed", targetId: record.targetId };
@@ -55555,22 +55594,32 @@ function recoverOnePublishJournal(params) {
         path7.join(params.sessionsDir, record.backupDir),
         path7.join(params.sessionsDir, record.targetId)
       );
-      removeJournal();
+      fsyncDirectory(params.sessionsDir);
       if (stagingExists) {
         try {
           removeSessionDir(record.stagingId);
         } catch (error) {
           warn(`[session-control] Restored ${record.targetId} but could not remove its abandoned staging copy ${record.stagingId}: ${String(error)}`);
+          return { action: "ambiguous-preserved", targetId: record.targetId, message: `Staging cleanup failed after restore; journal preserved: ${String(error)}` };
         }
       }
+      removeJournal();
       return { action: "restored-previous-target", targetId: record.targetId };
     }
     if (!targetExists && !backupExists) {
-      if (stagingExists) removeSessionDir(record.stagingId);
+      if (stagingExists) {
+        try {
+          removeSessionDir(record.stagingId);
+        } catch (error) {
+          warn(`[session-control] Could not remove abandoned staging copy ${record.stagingId}: ${String(error)}`);
+          return { action: "ambiguous-preserved", targetId: record.targetId, message: `Staging cleanup failed; journal preserved: ${String(error)}` };
+        }
+      }
       removeJournal();
       return stagingExists ? { action: "discarded-incomplete-fork", targetId: record.targetId } : { action: "nothing-to-recover", targetId: record.targetId };
     }
-    const message = `[session-control] Ambiguous interrupted publish for target ${record.targetId} (target=${targetExists}, backup=${backupExists}, staging=${stagingExists}); nothing was deleted \u2014 inspect ${params.sessionsDir} and ${journalName} manually`;
+    const reason = record.failedAt !== void 0 ? "the publish failed in-process (restore failed) and the backup was preserved" : `target=${targetExists}, backup=${backupExists}, staging=${stagingExists}`;
+    const message = `[session-control] Ambiguous interrupted publish for target ${record.targetId} (${reason}); nothing was deleted \u2014 inspect ${params.sessionsDir} and ${journalName} manually`;
     warn(message);
     return { action: "ambiguous-preserved", targetId: record.targetId, message };
   } catch (error) {

package/package.json

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