@cydm/pie 1.0.45 → 1.0.47

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-PKR3PO73.js";
+} from "../../../chunks/chunk-IJMP3JTX.js";
 import "../../../chunks/chunk-FKAO25XH.js";
 import "../../../chunks/chunk-K6ZOCJ4V.js";
 import "../../../chunks/chunk-LZQXQOPJ.js";

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

@@ -7,7 +7,7 @@ import {
   isPlanModeSafeCommand,
   markCompletedPlanSteps,
   restoreExecutionState
-} from "../../../chunks/chunk-PKR3PO73.js";
+} from "../../../chunks/chunk-IJMP3JTX.js";
 import "../../../chunks/chunk-FKAO25XH.js";
 import {
   Type

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-75JWZPRK.js";
+} from "../../../chunks/chunk-U4B6RJ6Z.js";
 import {
   createSharedFileSystemTools,
   createSubagentCapability
-} from "../../../chunks/chunk-PKR3PO73.js";
+} from "../../../chunks/chunk-IJMP3JTX.js";
 import "../../../chunks/chunk-FKAO25XH.js";
 import "../../../chunks/chunk-K6ZOCJ4V.js";
 import "../../../chunks/chunk-LZQXQOPJ.js";

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

@@ -7,7 +7,7 @@ import {
   executeManageTodoList,
   executionStateToTodos,
   restoreExecutionState
-} from "../../../chunks/chunk-PKR3PO73.js";
+} from "../../../chunks/chunk-IJMP3JTX.js";
 import "../../../chunks/chunk-FKAO25XH.js";
 import "../../../chunks/chunk-K6ZOCJ4V.js";
 import "../../../chunks/chunk-LZQXQOPJ.js";

package/dist/chunks/{chunk-PKR3PO73.js → chunk-IJMP3JTX.js}

@@ -3524,9 +3524,6 @@ var SessionManager = class {
       (e) => e.type === "message" && e.message
     ).length;
     if (this.activeSession.metadata.messageCount === 0) {
-      if (await this.store.exists(this.activeSession.id)) {
-        await this.store.delete(this.activeSession.id);
-      }
       this.activeSession.isDirty = false;
       return;
     }
@@ -4692,6 +4689,31 @@ function asTerminalFailure(failure, message = failure.message) {
     message
   };
 }
+function emitTurnEndPolicyFailure(emit, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  emit({
+    type: "turn_failed_terminal",
+    failure: {
+      kind: "internal_error",
+      message: `Turn-end policy failed: ${message}`,
+      retryable: false,
+      compactable: false,
+      userAbort: false,
+      terminal: true
+    }
+  });
+  emit({ type: "turn_settled" });
+}
+function handleTurnEndPolicyThrow(emit, error, context) {
+  context.cancelPendingRecovery();
+  if (context.recoveryWasActive) {
+    context.markRecoveryTerminal();
+    emitTurnEndPolicyFailure(emit, error);
+    return;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  emit({ type: "turn_policy_error", message: `Turn-end policy failed after settle: ${message}` });
+}
 
 // ../../packages/agent-framework/src/session/controller/retry-policy.ts
 function defaultSetTimeout4(callback, delay) {
@@ -4728,6 +4750,7 @@ var AgentSessionRetryController = class {
   }
   async handleTurnEnd(message, failure) {
     if (!this.retry || !message || message.role !== "assistant") {
+      this.settleStrandedRetry(failure);
       return;
     }
     if (!failure) {
@@ -4790,6 +4813,33 @@ var AgentSessionRetryController = class {
       });
     }, delayMs);
   }
+  /**
+   * A retried turn can end without an assistant failure message (for example
+   * the request dies before any content arrives, or a host classifier throws).
+   * Without this net the pending recovery promise never resolves:
+   * waitForRetry()/waitForSettled() hang forever, queued input never
+   * dispatches, and the whole task freezes with no turn_settled.
+   */
+  settleStrandedRetry(failure) {
+    if (this.retryTimer !== void 0 || this.pendingRetry === void 0) {
+      return;
+    }
+    const terminalFailure = asTerminalFailure(failure ?? {
+      kind: "internal_error",
+      message: "Retried turn ended without an assistant message; recovery settled to avoid a hang",
+      retryable: false,
+      compactable: false,
+      userAbort: false,
+      terminal: true
+    });
+    const maxRetries = this.retry?.maxRetries ?? 3;
+    this.emit({ type: "retry_exhausted", errorMessage: terminalFailure.message, maxRetries });
+    this.emit({ type: "turn_failed_terminal", failure: terminalFailure });
+    this.emit({ type: "turn_settled" });
+    this.retryAttempt = 0;
+    this.setRecoveryState("terminal");
+    this.resolvePending();
+  }
   cancel() {
     this.cancelTimerOnly();
     this.retryAttempt = 0;
@@ -4822,6 +4872,8 @@ var AgentSessionRetryController = class {
 // ../../packages/agent-framework/src/session/controller/runtime-guard.ts
 var RUNAWAY_TOOLCALL_WHITESPACE_DELTA_CHARS = 16384;
 var RUNAWAY_TOOLCALL_WHITESPACE_DELTA_EVENTS = 40;
+var TOOL_FAILURE_ABORT_THRESHOLD = 4;
+var TOOL_FAILURE_ADVISORY_THRESHOLD = 2;
 var TOOL_FAILURE_SIGNATURE_CHARS = 1e3;
 var TOOL_FAILURE_SIGNATURE_CONTEXT_LINES = 5;
 var FAILURE_DIAGNOSTIC_LINE_PATTERN = /\b(E2E_FAILED|AssertionError|TimeoutError|SyntaxError|ReferenceError|TypeError|Error):|(^|\b)(failed|failure|timed out|timeout|exit code|command failed|npm ERR!)/i;
@@ -4874,10 +4926,12 @@ function isStateChangingSuccess(event) {
   return event.toolName === "bash" && details?.commandClass === "filesystem_write";
 }
 var AgentSessionRuntimeGuard = class {
-  constructor(trigger) {
+  constructor(trigger, advise) {
     this.trigger = trigger;
+    this.advise = advise;
   }
   trigger;
+  advise;
   repeatedToolFailures = /* @__PURE__ */ new Map();
   streamGuard = {
     whitespaceToolCallDeltaChars: 0,
@@ -4947,7 +5001,18 @@ var AgentSessionRuntimeGuard = class {
     const key = `${event.toolName}:${reason}:${stableStringify(event.args)}:${resultSummary}`;
     const repeatCount = (this.repeatedToolFailures.get(key) ?? 0) + 1;
     this.repeatedToolFailures.set(key, repeatCount);
-    if (repeatCount < 3 || this.isTriggered) {
+    if (this.isTriggered) {
+      return;
+    }
+    if (repeatCount >= TOOL_FAILURE_ADVISORY_THRESHOLD && repeatCount < TOOL_FAILURE_ABORT_THRESHOLD && this.advise) {
+      this.advise(
+        event.toolName,
+        repeatCount,
+        reason,
+        `Tool ${event.toolName} failed ${repeatCount} times in a row with the identical error and identical arguments. Re-read the tool error above: it usually names the exact recovery step or alternative tool. Retrying the same call unchanged will fail again; change the approach.`
+      );
+    }
+    if (repeatCount < TOOL_FAILURE_ABORT_THRESHOLD) {
       return;
     }
     this.isTriggered = true;
@@ -5281,9 +5346,14 @@ var AgentSessionController = class {
     if (options.onEvent) {
       this.listeners.add(options.onEvent);
     }
-    this.runtimeGuard = new AgentSessionRuntimeGuard((toolName, repeatCount, reason) => {
-      this.triggerRuntimeGuard(toolName, repeatCount, reason);
-    });
+    this.runtimeGuard = new AgentSessionRuntimeGuard(
+      (toolName, repeatCount, reason) => {
+        this.triggerRuntimeGuard(toolName, repeatCount, reason);
+      },
+      (toolName, repeatCount, reason, guidance) => {
+        this.emit({ type: "runtime_guard_advisory", toolName, repeatCount, reason, guidance });
+      }
+    );
     this.queue = new AgentSessionQueue({
       agent: this.agent,
       getIsStreaming: () => this.isStreaming,
@@ -5569,7 +5639,16 @@ var AgentSessionController = class {
     if (event.type === "turn_end") {
       void this.syncNewAgentMessages();
       this.recordLifecycle({ type: "turn_end_success" });
-      void this.handleTurnEndRuntimePolicies(event.message, event.toolResults);
+      void this.handleTurnEndRuntimePolicies(event.message, event.toolResults).catch((error) => handleTurnEndPolicyThrow((event2) => this.emit(event2), error, {
+        recoveryWasActive: this.isRecoveryActive(),
+        cancelPendingRecovery: () => {
+          this.retryController.cancel();
+          this.autoCompact.cancel();
+        },
+        markRecoveryTerminal: () => {
+          this.recoveryState = "terminal";
+        }
+      }));
     }
     if (event.type === "agent_end") {
       this.recordLifecycle({ type: "agent_end" });
@@ -5789,46 +5868,52 @@ function isExtensionEnabled(identity, ...layers) {
   }
   return true;
 }
-function extractExtensionSettings(parsed) {
+function extractEnablementMap(parsed, key) {
   if (!parsed || typeof parsed !== "object") {
     return {};
   }
-  if (!hasOwn(parsed, "extensions")) {
+  if (!hasOwn(parsed, key)) {
     return {};
   }
-  const extensions = parsed.extensions;
-  if (!extensions || typeof extensions !== "object" || Array.isArray(extensions)) {
+  const map = parsed[key];
+  if (!map || typeof map !== "object" || Array.isArray(map)) {
     return {};
   }
-  return extensions;
+  return map;
 }
-function setExtensionEnabledInSettings(settingsObject, identity, enabled) {
-  const extensions = cloneOwnProperties(extractExtensionSettings(settingsObject));
-  const current = hasOwn(extensions, identity) ? extensions[identity] : void 0;
+function extractExtensionSettings(parsed) {
+  return extractEnablementMap(parsed, "extensions");
+}
+function setEnablementInMap(settingsObject, key, identity, enabled) {
+  const map = cloneOwnProperties(extractEnablementMap(settingsObject, key));
+  const current = hasOwn(map, identity) ? map[identity] : void 0;
   if (enabled === void 0) {
     if (current && typeof current === "object" && !Array.isArray(current)) {
       const next = cloneOwnProperties(current);
       delete next.enabled;
       if (Object.keys(next).length === 0) {
-        delete extensions[identity];
+        delete map[identity];
       } else {
-        defineOwnDataProperty(extensions, identity, next);
+        defineOwnDataProperty(map, identity, next);
       }
     } else {
-      delete extensions[identity];
+      delete map[identity];
     }
   } else {
     const next = current && typeof current === "object" && !Array.isArray(current) ? cloneOwnProperties(current) : {};
     defineOwnDataProperty(next, "enabled", enabled);
-    defineOwnDataProperty(extensions, identity, next);
+    defineOwnDataProperty(map, identity, next);
   }
-  if (Object.keys(extensions).length === 0) {
-    delete settingsObject.extensions;
+  if (Object.keys(map).length === 0) {
+    delete settingsObject[key];
   } else {
-    defineOwnDataProperty(settingsObject, "extensions", extensions);
+    defineOwnDataProperty(settingsObject, key, map);
   }
   return settingsObject;
 }
+function setExtensionEnabledInSettings(settingsObject, identity, enabled) {
+  return setEnablementInMap(settingsObject, "extensions", identity, enabled);
+}
 
 // ../../packages/agent-framework/src/interaction.ts
 var InteractionUnavailableError = class extends Error {
@@ -6807,6 +6892,19 @@ function snapshotFromStatAndContent(stat, content) {
     contentHash: hashText(content)
   };
 }
+function mergeLineRanges(ranges) {
+  const sorted = [...ranges].sort((left, right) => left.startLine - right.startLine || left.endLine - right.endLine);
+  const merged = [];
+  for (const range2 of sorted) {
+    const last = merged[merged.length - 1];
+    if (last && range2.startLine <= last.endLine + 1) {
+      last.endLine = Math.max(last.endLine, range2.endLine);
+    } else {
+      merged.push({ startLine: range2.startLine, endLine: range2.endLine });
+    }
+  }
+  return merged;
+}
 function createFileObservationState(options = {}) {
   const files = /* @__PURE__ */ new Map();
   const maxFiles = Math.max(1, Math.floor(options.maxFiles ?? 100));
@@ -6833,6 +6931,33 @@ function createFileObservationState(options = {}) {
       readRanges.delete(oldest);
     }
   }
+  function coverageSpansFile(coveredRanges, totalLines) {
+    if (totalLines <= 0) return true;
+    const merged = mergeLineRanges(coveredRanges);
+    return merged.length > 0 && merged[0].startLine <= 1 && merged[merged.length - 1].endLine >= totalLines;
+  }
+  function summarize(observed) {
+    const merged = mergeLineRanges(observed.coveredRanges);
+    const coveredLines = merged.reduce((total, range2) => total + (range2.endLine - range2.startLine + 1), 0);
+    let firstUnseenLine;
+    if (observed.coveredTotalLines > 0 && coveredLines < observed.coveredTotalLines) {
+      firstUnseenLine = merged.length > 0 && merged[0].startLine <= 1 ? merged[merged.length - 1].endLine + 1 : 1;
+    }
+    let lastRange;
+    for (const range2 of observed.readRanges.values()) {
+      if (range2.coverage) {
+        lastRange = range2.coverage;
+      }
+    }
+    return {
+      readCount: observed.readRanges.size,
+      coveredLines,
+      totalLines: observed.coveredTotalLines,
+      completeTextKnown: observed.completeTextKnown,
+      ...lastRange ? { lastRange } : {},
+      ...firstUnseenLine ? { firstUnseenLine } : {}
+    };
+  }
   return {
     isUnchangedReadRange(absolutePath, rangeKey, snapshot, selectedContentHash) {
       const observed = files.get(absolutePath);
@@ -6845,16 +6970,32 @@ function createFileObservationState(options = {}) {
       touchFile(absolutePath, observed);
       return unchanged;
     },
-    recordTextRead(absolutePath, rangeKey, snapshot, selectedContentHash, completeTextKnown) {
-      const observed = files.get(absolutePath) ?? {
+    recordTextRead(absolutePath, rangeKey, snapshot, selectedContentHash, completeTextKnown, coverage) {
+      const existing = files.get(absolutePath);
+      const contentMatches = !!existing && snapshotsHaveSameContent(existing.snapshot, snapshot);
+      const observed = existing ?? {
         snapshot,
         completeTextKnown: false,
-        readRanges: /* @__PURE__ */ new Map()
+        readRanges: /* @__PURE__ */ new Map(),
+        coveredRanges: [],
+        coveredTotalLines: 0
       };
-      const preservesFreshCompleteRead = observed.completeTextKnown && snapshotsHaveSameContent(observed.snapshot, snapshot);
+      const preservesFreshCompleteRead = observed.completeTextKnown && contentMatches;
+      if (!contentMatches || coverage && observed.coveredTotalLines !== coverage.totalLines) {
+        observed.coveredRanges = [];
+        observed.coveredTotalLines = coverage?.totalLines ?? observed.coveredTotalLines;
+      }
       observed.snapshot = snapshot;
-      observed.completeTextKnown = completeTextKnown || preservesFreshCompleteRead;
-      touchRange(observed.readRanges, rangeKey, { snapshot, selectedContentHash });
+      if (coverage) {
+        observed.coveredRanges = mergeLineRanges([...observed.coveredRanges, { startLine: coverage.startLine, endLine: coverage.endLine }]);
+        observed.coveredTotalLines = coverage.totalLines;
+      }
+      observed.completeTextKnown = completeTextKnown || preservesFreshCompleteRead || observed.coveredTotalLines > 0 && coverageSpansFile(observed.coveredRanges, observed.coveredTotalLines);
+      touchRange(observed.readRanges, rangeKey, {
+        snapshot,
+        selectedContentHash,
+        ...coverage ? { coverage: { startLine: coverage.startLine, endLine: coverage.endLine } } : {}
+      });
       touchFile(absolutePath, observed);
     },
     getCompleteTextSnapshot(absolutePath) {
@@ -6865,11 +7006,20 @@ function createFileObservationState(options = {}) {
       touchFile(absolutePath, observed);
       return observed.snapshot;
     },
+    describeObservation(absolutePath) {
+      const observed = files.get(absolutePath);
+      if (!observed) {
+        return void 0;
+      }
+      return summarize(observed);
+    },
     recordCompleteTextWrite(absolutePath, snapshot) {
       touchFile(absolutePath, {
         snapshot,
         completeTextKnown: true,
-        readRanges: /* @__PURE__ */ new Map()
+        readRanges: /* @__PURE__ */ new Map(),
+        coveredRanges: [],
+        coveredTotalLines: 0
       });
     },
     invalidate(absolutePath) {
@@ -7137,7 +7287,7 @@ function createReadTool(cwd, options) {
                 resolve3({
                   content: [{
                     type: "text",
-                    text: "File unchanged since previous read of this range. Use a different offset/limit if you need another section."
+                    text: `File unchanged since previous read of this range (offset=${startLineDisplay}${limit === void 0 ? ", no limit" : `, limit=${limit}`}). Earlier reads still count toward write_file coverage of this file. Use a different offset/limit if you need another section.`
                   }],
                   details: {
                     unchangedSincePreviousRead: true,
@@ -7187,7 +7337,15 @@ Base directory: ${nodePath.dirname(absolutePath)}
                 rangeKey,
                 snapshot,
                 range2.selectedContentHash,
-                isCompleteTextKnown
+                isCompleteTextKnown,
+                {
+                  // firstLineExceedsLimit yields an intentionally empty range
+                  // (start - 1): zero lines were actually shown, so it must
+                  // contribute nothing to write coverage.
+                  startLine: startLineDisplay,
+                  endLine: startLineDisplay + (truncation.firstLineExceedsLimit ? 0 : truncation.truncated ? truncation.outputLines : range2.selectedLines) - 1,
+                  totalLines: range2.totalLines
+                }
               );
               outputText = sourceHeader + outputText;
               const textContent = [{ type: "text", text: outputText }];
@@ -7548,8 +7706,10 @@ function createWriteTool(cwd, options) {
                 const currentSnapshot = snapshotFromStatAndContent(currentStat, currentContent);
                 const observedSnapshot = fileObservationState.getCompleteTextSnapshot(absolutePath);
                 if (!observedSnapshot) {
+                  const summary = fileObservationState.describeObservation(absolutePath);
+                  const coverageHint = summary && summary.totalLines > 0 ? ` Previous reads cover ${summary.coveredLines}/${summary.totalLines} lines${summary.lastRange ? ` (last read: lines ${summary.lastRange.startLine}-${summary.lastRange.endLine})` : ""}${summary.firstUnseenLine ? `; read the rest with read_file offset=${summary.firstUnseenLine}` : "; read the full file with read_file (no offset/limit)"}.` : " Read the current full file with read_file (no offset/limit) first.";
                   throw new Error(
-                    usesExternalFileObservationState ? "Read the current full file with read_file before overwriting it, or use edit_file for targeted changes." : "Existing-file overwrite requires write_file to share a fileObservationState with read_file; use createSharedFileSystemTools or pass the same fileObservationState to both tools."
+                    usesExternalFileObservationState ? `write_file blocked: overwriting requires the file to be fully observed by read_file.${coverageHint} Alternatively, use edit_file for targeted changes.` : "Existing-file overwrite requires write_file to share a fileObservationState with read_file; use createSharedFileSystemTools or pass the same fileObservationState to both tools."
                   );
                 }
                 if (!snapshotsHaveSameContent(observedSnapshot, currentSnapshot)) {
@@ -14799,6 +14959,7 @@ export {
   getExtensionEnablementEntry,
   isExtensionEnabled,
   extractExtensionSettings,
+  setEnablementInMap,
   setExtensionEnabledInSettings,
   registerInteractionHandler,
   hasInteractionHandler,

package/dist/chunks/{chunk-75JWZPRK.js → chunk-U4B6RJ6Z.js}

@@ -8,7 +8,7 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-PKR3PO73.js";
+} from "./chunk-IJMP3JTX.js";
 import {
   Type
 } from "./chunk-K6ZOCJ4V.js";

package/dist/chunks/{test-stream-XCE2KXJU.js → test-stream-5T7E7C25.js}

@@ -90,7 +90,7 @@ function createTestStreamFnFromSequenceEnv(value = process.env.PIE_TEST_MOCK_STR
   }
   const steps = parseMockStreamSequence(value);
   let callIndex = 0;
-  return async (model, context) => {
+  return async (model, context, options) => {
     const step = steps[Math.min(callIndex, steps.length - 1)];
     assertSystemPromptIncludes(context.systemPrompt, callIndex);
     callIndex += 1;
@@ -143,7 +143,14 @@ function createTestStreamFnFromSequenceEnv(value = process.env.PIE_TEST_MOCK_STR
       stream.push({ type: "done", reason: "stop", message });
     };
     if (step?.delayMs) {
-      setTimeout(emit, step.delayMs);
+      const timer = setTimeout(emit, step.delayMs);
+      options?.signal?.addEventListener("abort", () => {
+        clearTimeout(timer);
+        const reason = options.signal?.reason;
+        const message = reason instanceof Error ? reason.message : String(reason ?? "aborted");
+        const error = createAssistantMessage(model, "", "error", message);
+        stream.push({ type: "error", reason: "error", error });
+      }, { once: true });
     } else {
       queueMicrotask(emit);
     }