@cydm/pie 1.0.50 → 2.1.0

package/dist/chunks/{chunk-DZS34ACX.js → chunk-PMPD56N2.js}

@@ -1,17 +1,19 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   Agent
-} from "./chunk-FKAO25XH.js";
+} from "./chunk-QJH6YN2W.js";
 import {
   FileSystemGateway,
-  Type,
   completeSimple,
   detectPlatform,
   getFileSystem,
   getPlatformConfig,
   hashText,
   streamSimple
-} from "./chunk-K6ZOCJ4V.js";
+} from "./chunk-IM43UYVV.js";
+import {
+  Type
+} from "./chunk-XXGYUYXI.js";
 import {
   __commonJS,
   __toESM
@@ -1690,22 +1692,30 @@ function buildParallelResult(tasks, totalDuration) {
 `;
   return resultText;
 }
+var TASK_FIELD_ALIASES = ["task", "description", "prompt", "objective"];
 function normalizeTaskDefs(args) {
   const taskDefs = args?.tasks;
   if (!Array.isArray(taskDefs) || taskDefs.length === 0) {
     return { error: "Invalid spawn_subagents_parallel arguments: tasks must be a non-empty array." };
   }
   const normalized = [];
+  const allowedFields = [...TASK_FIELD_ALIASES, "name", "priority", "timeout"];
   for (const [index, def] of taskDefs.entries()) {
     if (!def || typeof def !== "object") {
-      return { error: `Invalid task #${index + 1}: expected an object with task.` };
+      return { error: `Invalid task #${index + 1}: expected an object with the objective in "task" (aliases "description"/"prompt"/"objective" accepted).` };
     }
-    if ("prompt" in def || "kind" in def || "max_turns" in def) {
-      return { error: "Invalid spawn_subagents_parallel arguments: use tasks[].task plus optional name/priority; prompt, kind, and max_turns are no longer supported." };
+    const unknownFields = Object.keys(def).filter((key) => !allowedFields.includes(key));
+    if (unknownFields.length > 0) {
+      return { error: `Invalid task #${index + 1}: unknown field(s) ${unknownFields.map((key) => `"${key}"`).join(", ")}; allowed fields: ${allowedFields.map((key) => `"${key}"`).join(", ")}.` };
     }
-    const task = typeof def.task === "string" ? def.task.trim() : "";
+    const taskValues = [
+      ...new Set(
+        TASK_FIELD_ALIASES.map((key) => typeof def[key] === "string" ? def[key].trim() : "").filter((value) => value.length > 0)
+      )
+    ];
+    const task = taskValues.join("\n\n");
     if (!task) {
-      return { error: `Invalid task #${index + 1}: task cannot be empty.` };
+      return { error: `Invalid task #${index + 1}: provide the objective in "task" (aliases "description"/"prompt"/"objective" are accepted).` };
     }
     const timeoutSeconds = "timeout" in def ? Number(def.timeout) : DEFAULT_SUBAGENT_TIMEOUT_SECONDS;
     if (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0) {
@@ -1721,25 +1731,61 @@ function normalizeTaskDefs(args) {
   }
   return normalized;
 }
+var DEFAULT_MAX_CONCURRENT_SUBAGENTS = 4;
+var MAX_TRANSIENT_RETRIES = 2;
+var TRANSIENT_RETRY_BACKOFF_MS = 2e3;
+var TRANSIENT_ERROR_PATTERN = /econnreset|econnaborted|etimedout|timeout|enotfound|eai_again|econnrefused|socket hang up|sse stream aborted|fetch failed|status 5\d\d|bad gateway|service unavailable|overloaded/i;
+function isTransientNetworkError(message) {
+  return TRANSIENT_ERROR_PATTERN.test(message);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve3) => {
+    const timer = setTimeout(resolve3, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        resolve3();
+      },
+      { once: true }
+    );
+  });
+}
+async function runWithConcurrencyLimit(jobs, limit) {
+  let next = 0;
+  const workers = Array.from({ length: Math.max(1, Math.min(limit, jobs.length)) }, async () => {
+    while (next < jobs.length) {
+      const current = jobs[next++];
+      await current();
+    }
+  });
+  await Promise.all(workers);
+}
 function createSubagentCapability(deps) {
   const spawnParallelTool = {
     name: "spawn_subagents_parallel",
     label: "Spawn Subagents",
     description: `Spawn child agents to run bounded sub-tasks in parallel.
 
-Use this for independent investigation, search, review, or triage work. Provide each task as a plain objective. Pie chooses the model class automatically. Use timeout only for unusually long tasks.`,
+Use this for independent investigation, search, review, or triage work. Provide each task as a plain objective. Pie chooses the model class automatically. Use timeout only for unusually long tasks.
+
+Arguments shape (each tasks[] item puts the objective in "task" \u2014 "description"/"prompt"/"objective" are accepted as aliases):
+{ "tasks": [{ "task": "<objective text>", "name": "<optional short label>", "priority": "fast" | "thorough", "timeout": 600 }] }`,
     parameters: Type.Object({
       tasks: Type.Array(
         Type.Object(
           {
-            task: Type.String({ description: "The bounded sub-task objective. Be specific and include expected output." }),
+            task: Type.Optional(Type.String({ description: "The bounded sub-task objective. Be specific and include expected output. Preferred field name." })),
+            description: Type.Optional(Type.String({ description: "Alias for task." })),
+            prompt: Type.Optional(Type.String({ description: "Alias for task." })),
+            objective: Type.Optional(Type.String({ description: "Alias for task." })),
             name: Type.Optional(Type.String({ description: "Short name for this subagent, shown in progress updates." })),
             priority: Type.Optional(Type.Union([Type.Literal("fast"), Type.Literal("thorough")], { description: "fast uses lower-cost defaults; thorough raises model class when needed." })),
-            timeout: Type.Optional(Type.Number({ description: "Timeout in seconds. Default: 1200s (20 minutes). For longer tasks, explicitly set a higher value, e.g. { timeout: 3600 }." }))
+            timeout: Type.Optional(Type.Number({ description: "Timeout in seconds. Default: 1200s (20 minutes). For longer tasks, explicitly set a higher value, e.g. 3600." }))
           },
-          { additionalProperties: false }
+          { additionalProperties: false, description: "Objective goes in 'task' (or an accepted alias); plus optional name/priority/timeout." }
         ),
-        { description: "Array of tasks to run in parallel", minItems: 1, maxItems: 10 }
+        { description: "Array of tasks to run in parallel; at least one of task/description/prompt/objective must be a non-empty string per item.", minItems: 1, maxItems: 10 }
       )
     }, { additionalProperties: false }),
     async execute(first, second, third, fourth) {
@@ -1782,7 +1828,30 @@ 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, signal)));
+      const runTask = async (task) => {
+        for (let attempt = 0; ; attempt++) {
+          await runSubagentWithProgress(deps, task, toolContext.reportProgress, signal);
+          const canRetry = task.status === "failed" && isTransientNetworkError(task.error ?? "") && attempt < MAX_TRANSIENT_RETRIES && !signal?.aborted;
+          if (!canRetry) return;
+          const failureReason = task.error ?? "unknown";
+          task.evidence.length = 0;
+          task.runtimeEvidence.length = 0;
+          task.reportedEvidence.length = 0;
+          task.confidenceSignals.length = 0;
+          task.status = "pending";
+          task.error = void 0;
+          task.completedAt = void 0;
+          const backoffMs = (deps.transientRetryBackoffMs ?? TRANSIENT_RETRY_BACKOFF_MS) * (attempt + 1);
+          toolContext.reportProgress?.({ message: `[${task.name}] Transient error, retrying in ${Math.round(backoffMs / 1e3)}s (attempt ${attempt + 2}/${MAX_TRANSIENT_RETRIES + 1})...` });
+          deps.log(`[subagent] ${task.name} failed with a transient error (${failureReason}); retrying`);
+          await sleep(backoffMs, signal);
+          if (signal?.aborted) return;
+        }
+      };
+      await runWithConcurrencyLimit(
+        tasks.map((task) => () => runTask(task)),
+        Math.max(1, deps.maxConcurrentSubagents ?? DEFAULT_MAX_CONCURRENT_SUBAGENTS)
+      );
       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;
@@ -2582,14 +2651,14 @@ function isTransientFileError(error) {
   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) {
+function sleep2(ms) {
   return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function retryFileOperation(operation, retryDelaysMs) {
   let lastError;
   for (const [index, delayMs] of retryDelaysMs.entries()) {
     if (delayMs > 0) {
-      await sleep(delayMs);
+      await sleep2(delayMs);
     }
     try {
       operation();
@@ -3978,7 +4047,8 @@ var SessionManager = class {
         name: newName ?? `${this.activeSession.metadata.name} (Branch)`,
         createdAt: now,
         updatedAt: now,
-        tags: this.activeSession.metadata.tags
+        tags: this.activeSession.metadata.tags,
+        cwd: this.activeSession.metadata.cwd
       }
     );
     return newSessionId;
@@ -4015,7 +4085,8 @@ var SessionManager = class {
         createdAt: now,
         updatedAt: now,
         activeEntryId: newActiveEntryId,
-        tags: this.activeSession.metadata.tags
+        tags: this.activeSession.metadata.tags,
+        cwd: this.activeSession.metadata.cwd
       }
     );
     return newSessionId;
@@ -6185,7 +6256,10 @@ async function askSingleQuestion(args) {
     if (response.type === "multiline_input" && (response.skipped || response.timedOut)) {
       return buildSkippedResult(question, response.timedOut === true);
     }
-    const answer = response.type === "multiline_input" ? response.value : void 0;
+    const answer = response.type === "multiline_input" ? response.value?.trim() : void 0;
+    if (answer === "") {
+      return buildSkippedResult(question, false);
+    }
     if (answer === void 0) {
       return { content: [{ type: "text", text: "User cancelled" }], details: { cancelled: true } };
     }
@@ -6203,7 +6277,12 @@ async function askSingleQuestion(args) {
     id: `ask-user:select:${Date.now()}`,
     prompt: question,
     options: displayOptions,
-    timeoutMs: DEFAULT_ASK_TIMEOUT_MS
+    timeoutMs: DEFAULT_ASK_TIMEOUT_MS,
+    // Tab-style navigation for hosts that support it: ← at the first page
+    // selects Back, → at the last page selects Review (row presence mirrors
+    // allowBack/allowReview). Hosts without shortcut support ignore these.
+    leftShortcut: allowBack ? BACK_OPTION : void 0,
+    rightShortcut: allowReview ? REVIEW_OPTION : void 0
   });
   if (selection.type === "select_one" && (selection.skipped || selection.timedOut)) {
     return buildSkippedResult(question, selection.timedOut === true);
@@ -6228,7 +6307,10 @@ async function askSingleQuestion(args) {
     if (response.type === "text_input" && (response.skipped || response.timedOut)) {
       return buildSkippedResult(question, response.timedOut === true);
     }
-    const customAnswer = response.type === "text_input" ? response.value : void 0;
+    const customAnswer = response.type === "text_input" ? response.value?.trim() : void 0;
+    if (customAnswer === "") {
+      return buildSkippedResult(question, false);
+    }
     if (customAnswer === void 0) {
       return { content: [{ type: "text", text: "User cancelled" }], details: { cancelled: true } };
     }
@@ -6308,8 +6390,11 @@ function createAskUserCapability() {
             }
             answers[q.id] = {
               question: q.question,
-              answer: result.details?.answer || result.content[0].text,
-              ...result.details
+              ...result.details,
+              // After the spread: `answer` wins over the same spread key, and
+              // `??` preserves intentional values (`||` let "" re-clobber the
+              // fallback — a latent trap for any falsy answer).
+              answer: result.details?.answer ?? result.content[0].text
             };
             currentIndex++;
           }
@@ -6318,7 +6403,7 @@ function createAskUserCapability() {
               const reviewOptions = [
                 CONFIRM_OPTION,
                 ...questions.map((q2, i) => {
-                  const answer = answers[q2.id]?.answer || "(not answered)";
+                  const answer = answers[q2.id]?.answer ?? "(not answered)";
                   const displayAnswer = answer.length > 20 ? `${answer.substring(0, 20)}...` : answer;
                   return `\u270F\uFE0F Q${i + 1}: ${displayAnswer}`;
                 }),
@@ -6372,8 +6457,8 @@ function createAskUserCapability() {
               }
               answers[q.id] = {
                 question: q.question,
-                answer: result.details?.answer || result.content[0].text,
-                ...result.details
+                ...result.details,
+                answer: result.details?.answer ?? result.content[0].text
               };
             }
           }
@@ -11582,6 +11667,13 @@ function getModelLabel(model) {
 function textFromAssistant(message) {
   return message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
 }
+function classifyUnderstandingFailure(message) {
+  if (/\b40[123]\b|payment required|insufficient[ _-]?balance|arrearage|余额|quota/i.test(message)) return "auth_or_balance";
+  if (/\b429\b|rate.?limit|too many requests/i.test(message)) return "rate_limited";
+  if (/timed? ?out|timeout|etimedout/i.test(message)) return "timeout";
+  if (/does not support|unsupported|multimodal|modality|not declare/i.test(message)) return "unsupported";
+  return "provider_error";
+}
 function modalityForReadFileUnderstandingKind(kind) {
   if (kind === "image") return "image";
   if (kind === "video") return "video";
@@ -11614,83 +11706,147 @@ function createReadFileUnderstandingHandler(deps) {
 }
 async function understandFileWithModel(deps, request) {
   const purpose = `read_file.${request.kind}`;
-  const decision = deps.resolveToolModel(purpose);
   const agentModel = deps.getAgentModel();
-  const routeDetails = {
+  const singleDecision = deps.resolveToolModel(purpose);
+  const candidateDecisions = deps.resolveToolModelCandidates?.(purpose) ?? [singleDecision];
+  const sessionId = deps.getSessionId() || `read-file-${Date.now()}`;
+  const attempts = [];
+  let sendAttemptCount = 0;
+  const baseRouteDetails = {
     purpose,
-    requiredCapability: decision.requiredCapability,
-    routeSource: decision.routeSource,
+    requiredCapability: singleDecision.requiredCapability,
     agentModel: getModelLabel(agentModel),
-    toolModel: getModelLabel(decision.model),
-    fallbackReason: decision.fallbackReason,
     kind: request.kind,
     mimeType: request.mimeType
   };
-  if (!decision.model || !decision.apiKey) {
+  for (const decision of candidateDecisions) {
+    const attemptBase = { toolModel: getModelLabel(decision.model), routeSource: decision.routeSource };
+    if (!decision.model || !decision.apiKey) {
+      attempts.push({
+        ...attemptBase,
+        failureCategory: "unavailable",
+        fallbackReason: decision.fallbackReason,
+        durationMs: 0
+      });
+      continue;
+    }
+    const startedAt = Date.now();
+    sendAttemptCount += 1;
+    try {
+      const directImageContent = buildDirectImageUnderstandingContent(request);
+      const prepared = directImageContent ? { content: directImageContent, details: { inputMode: "inlineDataUrl" } } : await deps.prepareFileContent({
+        request,
+        model: decision.model,
+        apiKey: decision.apiKey,
+        sessionId
+      });
+      const send = deps.sendUnderstandingRequest ?? completeSimple;
+      const response = await send(
+        decision.model,
+        {
+          systemPrompt: "You are a file-understanding tool. Answer only from the provided file. Keep the answer concise and factual.",
+          messages: [{ role: "user", content: [buildReadFileUnderstandingPrompt(request), ...prepared.content], timestamp: Date.now() }]
+        },
+        {
+          apiKey: decision.apiKey,
+          maxTokens: Math.min(decision.model.maxTokens || 4096, 4096),
+          signal: request.signal
+        }
+      );
+      const errorMessage = response.stopReason === "error" || response.stopReason === "aborted" ? response.errorMessage : void 0;
+      const durationMs = Date.now() - startedAt;
+      if (response.stopReason === "aborted") {
+        attempts.push({ ...attemptBase, failureCategory: "aborted", error: errorMessage, durationMs });
+        return {
+          content: [{ type: "text", text: `read_file ${request.kind} understanding failed: ${errorMessage ?? "aborted"}` }],
+          details: { understanding: { ...baseRouteDetails, ...attemptBase, error: errorMessage, attempts } },
+          isError: true
+        };
+      }
+      if (errorMessage) {
+        attempts.push({
+          ...attemptBase,
+          failureCategory: classifyUnderstandingFailure(errorMessage),
+          error: errorMessage,
+          durationMs
+        });
+        continue;
+      }
+      attempts.push({ ...attemptBase, durationMs });
+      const text = textFromAssistant(response) || "(file understanding model returned no text)";
+      return {
+        content: [{ type: "text", text }],
+        details: {
+          understanding: {
+            ...baseRouteDetails,
+            // Capability follows the candidate that actually served the request,
+            // not the first decision's.
+            requiredCapability: decision.requiredCapability,
+            ...attemptBase,
+            fallbackReason: decision.fallbackReason,
+            responseStopReason: response.stopReason,
+            ...prepared.details,
+            attempts
+          }
+        },
+        isError: false
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const durationMs = Date.now() - startedAt;
+      if (request.signal?.aborted) {
+        attempts.push({ ...attemptBase, failureCategory: "aborted", error: message, durationMs });
+        return {
+          content: [{ type: "text", text: `read_file ${request.kind} understanding failed: ${message}` }],
+          details: { understanding: { ...baseRouteDetails, ...attemptBase, error: message, attempts } },
+          isError: true
+        };
+      }
+      attempts.push({
+        ...attemptBase,
+        failureCategory: classifyUnderstandingFailure(message),
+        error: message,
+        durationMs
+      });
+    }
+  }
+  const routedAttempts = attempts.filter((attempt) => attempt.toolModel !== void 0);
+  if (routedAttempts.length === 0 || sendAttemptCount === 0) {
     return {
       content: [{
         type: "text",
-        text: decision.fallbackReason || `No configured model declares ${request.kind} capability for ${purpose}.`
+        text: singleDecision.fallbackReason || `No configured model declares ${request.kind} capability for ${purpose}.`
       }],
-      details: { understanding: routeDetails },
-      isError: true
-    };
-  }
-  const sessionId = deps.getSessionId() || `read-file-${Date.now()}`;
-  try {
-    const directImageContent = buildDirectImageUnderstandingContent(request);
-    const prepared = directImageContent ? { content: directImageContent, details: { inputMode: "inlineDataUrl" } } : await deps.prepareFileContent({
-      request,
-      model: decision.model,
-      apiKey: decision.apiKey,
-      sessionId
-    });
-    const fileContent = prepared.content;
-    const content = [
-      buildReadFileUnderstandingPrompt(request),
-      ...fileContent
-    ];
-    const response = await completeSimple(
-      decision.model,
-      {
-        systemPrompt: "You are a file-understanding tool. Answer only from the provided file. Keep the answer concise and factual.",
-        messages: [{ role: "user", content, timestamp: Date.now() }]
-      },
-      {
-        apiKey: decision.apiKey,
-        maxTokens: Math.min(decision.model.maxTokens || 4096, 4096),
-        signal: request.signal
-      }
-    );
-    const errorMessage = response.stopReason === "error" || response.stopReason === "aborted" ? response.errorMessage : void 0;
-    const text = textFromAssistant(response) || (errorMessage ? `read_file ${request.kind} understanding failed: ${errorMessage}` : "(file understanding model returned no text)");
-    return {
-      content: [{ type: "text", text }],
       details: {
         understanding: {
-          ...routeDetails,
-          toolModel: getModelLabel(decision.model),
-          responseStopReason: response.stopReason,
-          ...prepared.details,
-          ...errorMessage ? { error: errorMessage } : {}
-        }
-      },
-      isError: response.stopReason === "error" || response.stopReason === "aborted"
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      content: [{ type: "text", text: `read_file ${request.kind} understanding failed: ${message}` }],
-      details: {
-        understanding: {
-          ...routeDetails,
-          toolModel: getModelLabel(decision.model),
-          error: message
+          ...baseRouteDetails,
+          toolModel: getModelLabel(singleDecision.model),
+          routeSource: singleDecision.routeSource,
+          fallbackReason: singleDecision.fallbackReason,
+          attempts
         }
       },
       isError: true
     };
   }
+  const lastAttempt = routedAttempts[routedAttempts.length - 1];
+  const viaSegments = attempts.filter((attempt) => attempt.error || attempt.fallbackReason).map((attempt) => `via ${attempt.toolModel ?? "unconfigured route"}: ${attempt.error ?? attempt.fallbackReason}`);
+  const firstFailure = attempts.find((attempt) => attempt.error || attempt.fallbackReason);
+  const combinedError = sendAttemptCount === 1 ? `read_file ${request.kind} understanding failed: ${firstFailure?.error ?? firstFailure?.fallbackReason ?? "unknown error"}` : `read_file ${request.kind} understanding failed after ${sendAttemptCount} route(s): ${viaSegments.join("; ")}`;
+  return {
+    content: [{ type: "text", text: combinedError }],
+    details: {
+      understanding: {
+        ...baseRouteDetails,
+        toolModel: lastAttempt.toolModel,
+        routeSource: lastAttempt.routeSource,
+        fallbackReason: lastAttempt.fallbackReason ?? lastAttempt.error,
+        error: combinedError,
+        attempts
+      }
+    },
+    isError: true
+  };
 }
 
 // ../../packages/shared-headless-capabilities/src/session-trace.ts
@@ -13790,7 +13946,7 @@ function createSharedWebFetchTool(deps = {}) {
         const extractionMethod = isHtml ? "html_readability" : isPdf ? "pdf_text" : "plain_text";
         if (isHtml && looksJavaScriptHeavy(raw, text)) {
           return {
-            content: [{ type: "text", text: `web_fetch could not read meaningful content from ${url}; this page appears to require JavaScript. Use Playwright browser tools for browser-rendered content.` }],
+            content: [{ type: "text", text: `web_fetch could not read meaningful content from ${url}; this page appears to require JavaScript. Use the chrome-devtools-axi skill (or computer-use browser tools) for browser-rendered content.` }],
             details: {
               url,
               sourceUrl: url,

package/dist/chunks/{chunk-FKAO25XH.js → chunk-QJH6YN2W.js}

@@ -3,7 +3,7 @@ import {
   EventStream,
   streamSimple,
   validateToolArguments
-} from "./chunk-K6ZOCJ4V.js";
+} from "./chunk-IM43UYVV.js";
 
 // ../../packages/agent-core/src/agent-loop.ts
 function createLoopErrorMessage(error, config, signal) {