@cydm/pie 2.7.1 → 2.7.3

package/dist/chunks/{chunk-M44CWVDZ.js → chunk-F3U2TYDT.js}

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from "node:module"; const require =
 import {
   Agent,
   getToolCallerIdentity
-} from "./chunk-NJFPBU36.js";
+} from "./chunk-MPTME6HX.js";
 import {
   AssistantMessageEventStream,
   FileSystemGateway,
@@ -12,7 +12,7 @@ import {
   getPlatformConfig,
   hashText,
   streamSimple
-} from "./chunk-XUROMYTT.js";
+} from "./chunk-E5JQ5SVA.js";
 import {
   Type
 } from "./chunk-XXGYUYXI.js";
@@ -978,6 +978,39 @@ var SIMPLE_READ_COMMANDS = /* @__PURE__ */ new Set(["pwd", "ls", "cat", "head",
 var GIT_READ_SUBCOMMANDS = /* @__PURE__ */ new Set(["status", "log", "diff", "show", "rev-parse", "ls-files", "ls-tree", "blame", "describe", "shortlog", "merge-base"]);
 var UNSAFE_GIT_FLAGS = /^(?:-c|--config-env|--exec|--output|--ext-diff|--textconv)(?:=|$)/;
 var UNSAFE_RG_FLAGS = /^(?:--pre|--pre-glob)(?:=|$)/;
+function longOptionUnsafe(arg, dangerous, benign) {
+  const name = arg.slice(2).split("=", 1)[0];
+  if (!name) return true;
+  if (dangerous.some((option) => option.startsWith(name))) return true;
+  return !benign.some((option) => option.startsWith(name));
+}
+function isReadOnlyUniq(args) {
+  let operands = 0;
+  let endOptions = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!endOptions && arg === "--") {
+      endOptions = true;
+      continue;
+    }
+    if (!endOptions && arg.startsWith("--")) {
+      if (/^--(?:skip-fields|skip-chars|check-chars)(?:=\d+)?$/.test(arg)) {
+        if (!arg.includes("=") && !/^\d+$/.test(args[++i] ?? "")) return false;
+      } else if (longOptionUnsafe(arg, [], ["count", "repeated", "unique", "all-repeated", "group", "ignore-case", "zero-terminated", "help", "version"])) {
+        return false;
+      }
+      continue;
+    }
+    if (!endOptions && arg.startsWith("-") && arg !== "-") {
+      const match2 = /^-[cdDuiz]*(?:([fsw])(\d*))?$/.exec(arg);
+      if (!match2) return false;
+      if (match2[1] && !match2[2] && !/^\d+$/.test(args[++i] ?? "")) return false;
+      continue;
+    }
+    if (++operands > 1) return false;
+  }
+  return true;
+}
 function isReadOnlySegment(words) {
   if (words.length === 0) return false;
   const [program, ...args] = words;
@@ -991,11 +1024,72 @@ function isReadOnlySegment(words) {
     return !args.some((arg) => /^-(?:exec|execdir|ok|okdir|delete|fprint|fls|fprintf)/.test(arg));
   }
   if (program === "tree") {
-    return !args.some((arg) => /^-o./.test(arg) || arg === "-o" || arg === "--output" || arg.startsWith("--output="));
+    return !args.some((arg) => /^-[^-]*o/.test(arg) || arg.startsWith("--") && arg !== "--" && longOptionUnsafe(arg, ["output"], [
+      "ascii",
+      "charset",
+      "color",
+      "dirsfirst",
+      "du",
+      "filelimit",
+      "hardlinks",
+      "help",
+      "ignore-case",
+      "inode",
+      "links",
+      "metafirst",
+      "noreport",
+      "nolinks",
+      "outdent",
+      "quote",
+      "sort",
+      "timefmt",
+      "version",
+      "pattern",
+      "matchdirs",
+      "prune"
+    ]));
   }
   if (program === "sort") {
-    return !args.some((arg) => /^-o./.test(arg) || arg === "-o" || arg === "--output" || arg.startsWith("--output=") || arg === "--compress-program" || arg.startsWith("--compress-program="));
+    return !args.some((arg) => {
+      if (arg === "--") return false;
+      if (arg.startsWith("--")) {
+        return longOptionUnsafe(arg, ["output", "compress-program"], [
+          "numeric-sort",
+          "general-numeric-sort",
+          "human-numeric-sort",
+          "month-sort",
+          "version-sort",
+          "random-sort",
+          "random-source",
+          "reverse",
+          "unique",
+          "check",
+          "check-silent",
+          "ignore-case",
+          "ignore-leading-blanks",
+          "ignore-nonprinting",
+          "ignore-blanks",
+          "dictionary-order",
+          "merge",
+          "stable",
+          "batch-size",
+          "buffer-size",
+          "pipe-size",
+          "parallel",
+          "temporary-directory",
+          "field-separator",
+          "zero-terminated",
+          "help",
+          "version",
+          "debug",
+          "sort"
+        ]);
+      }
+      if (arg.startsWith("-") && arg !== "-") return arg.slice(1).includes("o");
+      return false;
+    });
   }
+  if (program === "uniq") return isReadOnlyUniq(args);
   if (program === "date") {
     return args.every((arg) => arg.startsWith("-") || arg.startsWith("+"));
   }
@@ -1059,6 +1153,7 @@ ${inlineMatch[1]}`;
 function isPlanModeSafeCommand(command) {
   const trimmed = command.trim();
   if (!trimmed || /[$`\n\r\0]/.test(trimmed)) return false;
+  if (/\{[^{}]*\}/.test(trimmed) || /\{\s*,/.test(trimmed)) return false;
   let tokens;
   try {
     tokens = (0, import_shell_quote.parse)(trimmed);
@@ -3191,7 +3286,11 @@ function isTransientCompactionFailure(error) {
   if (record?.name === "AbortError" || /request was aborted|local abort signal|user abort|user_interrupt|interrupted by user|esc pressed|ctrl\+c|\bcancel(?:led|ed)\b|insufficient[_ ]quota|exceeded[_ ]current[_ ]quota|exceeded your current quota|insufficient[_ ]balance|credit balance is too low|\barrearage\b|余额不足|\b(?:account|monthly|billing) quota (?:has been |is )?exhausted|billing|invalid api key|unauthorized|forbidden/i.test(text)) return false;
   const status = record?.status ?? record?.statusCode;
   if (status !== void 0) return status === 429 || status >= 500 && status <= 599;
-  return /\b(?:429|5\d\d|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|ECONNREFUSED|EPIPE)\b|fetch failed|network error|request timeout|socket hang up|connection error|sse stream (?:aborted|closed before end|ended before response completed)|rate.?limit|too many requests|overloaded|service unavailable/i.test(text);
+  return /\b(?:429|5\d\d|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|ECONNREFUSED|EPIPE)\b|fetch failed|network error|request timeout|socket hang up|connection error|sse stream (?:aborted|closed before end|ended before response completed)|responses stream ended without a terminal event|rate.?limit|too many requests|overloaded|service unavailable/i.test(text);
+}
+function explicitlyNonRetryable(error) {
+  if (Boolean(error && typeof error === "object" && error.replayEligible === true)) return false;
+  return Boolean(error && typeof error === "object" && error.retryable === false);
 }
 function waitForCompactionRetry(delayMs, signal) {
   return new Promise((resolve2, reject) => {
@@ -3245,11 +3344,15 @@ Return a text-only successor handoff. Do not call any tools.` }],
       ).result();
       throwIfAborted();
       if (response.stopReason === "error" && !response.content.some((block) => block.type === "toolCall")) {
-        throw new Error(response.errorMessage || "Compaction provider error");
+        const providerError = new Error(response.errorMessage || "Compaction provider error");
+        const explicitRetryable = response.retryable;
+        if (typeof explicitRetryable === "boolean") providerError.retryable = explicitRetryable;
+        if (response.replayEligible === true) providerError.replayEligible = true;
+        throw providerError;
       }
     } catch (error) {
       throwIfAborted();
-      if (attempt >= 2 || !isTransientCompactionFailure(error)) throw error;
+      if (attempt >= 2 || explicitlyNonRetryable(error) || !isTransientCompactionFailure(error)) throw error;
       await waitForCompactionRetry(250 * 2 ** attempt, signal);
       continue;
     }
@@ -3680,6 +3783,10 @@ var LruCache = class {
   weigh;
   maxWeight;
   map = /* @__PURE__ */ new Map();
+  total = 0;
+  weightOf(value) {
+    return this.weigh ? this.weigh(value) : 1;
+  }
   get(key) {
     const value = this.map.get(key);
     if (value !== void 0) {
@@ -3690,34 +3797,36 @@ var LruCache = class {
   }
   /** Insert a value, evicting until the entry and total weight fit. */
   set(key, value) {
-    this.map.delete(key);
-    const weight = this.weigh ? this.weigh(value) : 1;
+    const existing = this.map.get(key);
+    if (existing !== void 0) {
+      this.total -= this.weightOf(existing);
+      this.map.delete(key);
+    }
+    const weight = this.weightOf(value);
     if (weight > this.maxWeight) {
       return;
     }
-    let total = this.totalWeight() + weight;
-    while ((this.map.size >= this.limit || total > this.maxWeight) && this.map.size > 0) {
+    this.total += weight;
+    while ((this.map.size >= this.limit || this.total > this.maxWeight) && this.map.size > 0) {
       const oldest = this.map.keys().next().value;
-      const evicted = this.map.get(oldest);
-      total -= this.weigh ? this.weigh(evicted) : 1;
+      this.total -= this.weightOf(this.map.get(oldest));
       this.map.delete(oldest);
     }
     this.map.set(key, value);
   }
   delete(key) {
-    this.map.delete(key);
+    const existing = this.map.get(key);
+    if (existing !== void 0) {
+      this.total -= this.weightOf(existing);
+      this.map.delete(key);
+    }
   }
   clear() {
     this.map.clear();
+    this.total = 0;
   }
   get weight() {
-    return this.totalWeight();
-  }
-  totalWeight() {
-    if (!this.weigh) return this.map.size;
-    let total = 0;
-    for (const value of this.map.values()) total += this.weigh(value);
-    return total;
+    return this.total;
   }
 };
 function isRecord(value) {
@@ -6855,6 +6964,17 @@ function isAssistantTerminalCompletion(message) {
 }
 function createFailureClassification(context, retry, classifyFailure) {
   if (context.message?.role === "assistant" && context.message.retryable === false) {
+    if (context.message.replayEligible === true) {
+      return {
+        kind: "provider_transient",
+        retryable: true,
+        compactable: false,
+        userAbort: context.message.stopReason === "aborted",
+        terminal: false,
+        message: context.errorMessage,
+        replayExempt: true
+      };
+    }
     return { kind: "unknown", retryable: false, compactable: false, userAbort: context.message.stopReason === "aborted", terminal: true, message: context.errorMessage };
   }
   const hostClassification = classifyFailure?.(context);
@@ -6873,13 +6993,7 @@ function createFailureClassification(context, retry, classifyFailure) {
   };
 }
 function asTerminalFailure(failure, message = failure.message) {
-  return {
-    ...failure,
-    retryable: false,
-    compactable: false,
-    terminal: true,
-    message
-  };
+  return { ...failure, retryable: false, compactable: false, terminal: true, message };
 }
 function emitTurnEndPolicyFailure(emit, error) {
   const message = error instanceof Error ? error.message : String(error);
@@ -6907,6 +7021,36 @@ function handleTurnEndPolicyThrow(emit, error, context) {
   emit({ type: "turn_policy_error", message: `Turn-end policy failed after settle: ${message}` });
 }
 
+// ../../packages/agent-framework/src/session/controller/replay-stall-circuit.ts
+var ReplayStallCircuit = class {
+  constructor(limit) {
+    this.limit = limit;
+  }
+  limit;
+  consecutiveStalls = 0;
+  open = false;
+  get isOpen() {
+    return this.open;
+  }
+  get consecutiveTurnStalls() {
+    return this.consecutiveStalls;
+  }
+  /** A replay-exempt retry budget was exhausted for this turn. */
+  recordReplayExhaustion() {
+    this.consecutiveStalls += 1;
+    if (this.limit !== void 0 && this.consecutiveStalls >= this.limit && !this.open) {
+      this.open = true;
+      return { opened: true, consecutive: this.consecutiveStalls };
+    }
+    return { opened: false, consecutive: this.consecutiveStalls };
+  }
+  /** A turn succeeded, or failed in a way the endpoint actively answered. */
+  recordHealthyTurn() {
+    this.consecutiveStalls = 0;
+    this.open = false;
+  }
+};
+
 // ../../packages/agent-framework/src/session/controller/retry-policy.ts
 function defaultSetTimeout4(callback, delay) {
   return setTimeout(callback, delay);
@@ -6921,6 +7065,7 @@ var AgentSessionRetryController = class {
     this.removeTrailingAssistantError = removeTrailingAssistantError2;
     this.continueTurn = continueTurn;
     this.setRecoveryState = setRecoveryState;
+    this.replayCircuit = new ReplayStallCircuit(retry?.systemicReplayStallLimit);
   }
   retry;
   emit;
@@ -6933,6 +7078,8 @@ var AgentSessionRetryController = class {
   retryAttempts = /* @__PURE__ */ new Map();
   /** Total attempts across kinds in this recovery episode, for reporting. */
   totalRetryAttempts = 0;
+  /** L2 systemic-stall circuit (see replay-stall-circuit.ts). */
+  replayCircuit;
   retryTimer;
   retryEpoch = 0;
   pendingRetry;
@@ -6946,12 +7093,17 @@ var AgentSessionRetryController = class {
   waitForRetry() {
     return this.pendingRetry ?? Promise.resolve();
   }
+  /** L2 circuit: healthy turn (success or an actively-answered failure). */
+  noteEndpointHealthy() {
+    this.replayCircuit.recordHealthyTurn();
+  }
   async handleTurnEnd(message, failure) {
     if (!this.retry || !message || message.role !== "assistant") {
       this.settleStrandedRetry(failure);
       return;
     }
     if (!failure) {
+      this.noteEndpointHealthy();
       if (this.totalRetryAttempts > 0) {
         this.emit({ type: "retry_succeeded", attempts: this.totalRetryAttempts });
         this.emit({ type: "turn_retry_succeeded", attempts: this.totalRetryAttempts });
@@ -6962,6 +7114,9 @@ var AgentSessionRetryController = class {
       return;
     }
     if (!failure.retryable) {
+      if (failure.kind !== "unknown" && failure.kind !== "internal_error") {
+        this.noteEndpointHealthy();
+      }
       if (this.totalRetryAttempts > 0) {
         this.resetAttempts();
         this.setRecoveryState("none");
@@ -6969,6 +7124,16 @@ var AgentSessionRetryController = class {
       }
       return;
     }
+    if (failure.replayExempt === true && this.replayCircuit.isOpen) {
+      const openFailure = asTerminalFailure(failure, `${failure.message} (replay circuit open: ${this.replayCircuit.consecutiveTurnStalls} consecutive turns ended by timeout-replay exhaustion)`);
+      this.emit({ type: "retry_exhausted", errorMessage: openFailure.message, maxRetries: 0 });
+      this.emit({ type: "turn_failed_terminal", failure: openFailure, message });
+      this.emit({ type: "turn_settled" });
+      this.resetAttempts();
+      this.setRecoveryState("terminal");
+      this.resolvePending();
+      return;
+    }
     const maxRetries = this.retry.maxRetriesForFailure?.(failure) ?? this.retry.maxRetries ?? 3;
     const kindAttempts = (this.retryAttempts.get(failure.kind) ?? 0) + 1;
     this.retryAttempts.set(failure.kind, kindAttempts);
@@ -6978,6 +7143,12 @@ var AgentSessionRetryController = class {
     const totalExhausted = totalBudget !== void 0 && this.totalRetryAttempts > totalBudget;
     if (kindExhausted || totalExhausted) {
       const terminalFailure = asTerminalFailure(failure);
+      if (failure.replayExempt === true) {
+        const outcome = this.replayCircuit.recordReplayExhaustion();
+        if (outcome.opened) {
+          this.emit({ type: "retry_exhausted", errorMessage: `systemic timeout-stall: ${outcome.consecutive} consecutive turns ended by timeout-replay exhaustion`, maxRetries: totalExhausted ? totalBudget : maxRetries });
+        }
+      }
       this.emit({ type: "retry_exhausted", errorMessage: failure.message, maxRetries: totalExhausted ? totalBudget : maxRetries });
       this.emit({ type: "turn_failed_terminal", failure: terminalFailure, message });
       this.emit({ type: "turn_settled" });
@@ -7012,11 +7183,7 @@ var AgentSessionRetryController = class {
         if (epoch !== this.retryEpoch || pending !== this.pendingRetry) return;
         const errorMessage = error instanceof Error ? error.message : String(error);
         const terminalFailure = asTerminalFailure(failure, errorMessage);
-        this.emit({
-          type: "retry_exhausted",
-          errorMessage,
-          maxRetries
-        });
+        this.emit({ type: "retry_exhausted", errorMessage, maxRetries });
         this.emit({ type: "turn_failed_terminal", failure: terminalFailure, message });
         this.emit({ type: "turn_settled" });
         this.resetAttempts();
@@ -7071,9 +7238,7 @@ var AgentSessionRetryController = class {
     this.retryTimer = void 0;
   }
   ensurePending() {
-    if (this.pendingRetry) {
-      return;
-    }
+    if (this.pendingRetry) return;
     this.pendingRetry = new Promise((resolve2) => {
       this.resolvePendingRetry = resolve2;
     });

package/dist/chunks/{chunk-NJFPBU36.js → chunk-MPTME6HX.js}

@@ -4,7 +4,7 @@ import {
   disposeModelTransports,
   streamSimple,
   validateToolArguments
-} from "./chunk-XUROMYTT.js";
+} from "./chunk-E5JQ5SVA.js";
 
 // ../../packages/agent-core/src/agent-loop.ts
 function createLoopErrorMessage(error, config, signal) {

package/dist/chunks/{chunk-W74NRSRV.js → chunk-WLLZTG4W.js}

@@ -6,10 +6,10 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-M44CWVDZ.js";
+} from "./chunk-F3U2TYDT.js";
 import {
   getLogger
-} from "./chunk-XUROMYTT.js";
+} from "./chunk-E5JQ5SVA.js";
 import {
   Type
 } from "./chunk-XXGYUYXI.js";
@@ -153,6 +153,7 @@ function formatTransportLifecycle(event) {
   if (event.terminalAccepted !== void 0) parts.push(`terminal=${event.terminalAccepted ? "yes" : "no"}`);
   if (event.retryAllowed !== void 0) parts.push(`retryAllowed=${event.retryAllowed ? "yes" : "no"}`);
   if (event.retryDecision) parts.push(`retryDecision=${event.retryDecision}`);
+  if (event.replayExempt === true) parts.push("replayExempt=yes");
   if (event.cancelSource) parts.push(`cancelSource=${event.cancelSource}`);
   if (event.cleanupOutcome) parts.push(`cleanup=${event.cleanupOutcome}`);
   if (event.singleAttempt) parts.push(`singleAttempt=${event.singleAttempt}`);

package/dist/chunks/{src-C4KA4G75.js → src-TOJ3HCEX.js}

@@ -6,8 +6,8 @@ import {
   bindToolCallerIdentity,
   createToolCallerIdentity,
   getToolCallerIdentity
-} from "./chunk-NJFPBU36.js";
-import "./chunk-XUROMYTT.js";
+} from "./chunk-MPTME6HX.js";
+import "./chunk-E5JQ5SVA.js";
 import "./chunk-XXGYUYXI.js";
 import "./chunk-LZQXQOPJ.js";
 export {

package/dist/chunks/{test-stream-A5ZELKNG.js → test-stream-6426JXLY.js}

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   EventStream
-} from "./chunk-XUROMYTT.js";
+} from "./chunk-E5JQ5SVA.js";
 import "./chunk-XXGYUYXI.js";
 import "./chunk-LZQXQOPJ.js";