nolo-cli 0.34.0-alpha.3 → 0.36.0-alpha.1

package/{chunk-I7VDDN45.js → chunk-LBZHTQTD.js}

@@ -27,7 +27,7 @@ import {
   hasAssistantVisibleOutput,
   resolveEmptyAssistantFallbackMessage,
   resolveEmptyAssistantOutcome
-} from "./chunk-AA2YUJNV.js";
+} from "./chunk-P66M7LSQ.js";
 import {
   createThinkParserState,
   createToolCallAccumulator,
@@ -42,7 +42,7 @@ import {
   requiresBareImageUrl,
   resolveToolGuidedSections,
   toBareImageUrlMessages
-} from "./chunk-M3JQWYBC.js";
+} from "./chunk-T2BZICLK.js";
 import {
   convertMessagesToResponsesInput,
   extractReasoningFromResponseOutput,
@@ -722,6 +722,191 @@ async function maybeAutoCompactLocalHistory(args) {
   }
 }
 
+// packages/agent-runtime/progressGuard.ts
+var DEFAULT_MAX_CONSECUTIVE_IDENTICAL_ROUNDS = 5;
+var DEFAULT_MAX_CONSECUTIVE_STAGNANT_TOOL_ROUNDS = 8;
+function sortJsonKeys(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(sortJsonKeys);
+  const sorted = {};
+  for (const key of Object.keys(obj).sort()) {
+    sorted[key] = sortJsonKeys(obj[key]);
+  }
+  return sorted;
+}
+function normalizeToolArguments(rawArgs) {
+  if (typeof rawArgs !== "string") {
+    try {
+      return JSON.stringify(sortJsonKeys(rawArgs ?? ""));
+    } catch {
+      return String(rawArgs ?? "");
+    }
+  }
+  const trimmed = rawArgs.trim();
+  if (!trimmed) return "";
+  try {
+    const parsed = JSON.parse(trimmed);
+    return JSON.stringify(sortJsonKeys(parsed));
+  } catch {
+    return trimmed;
+  }
+}
+function extractNormalizedContentText(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => {
+    if (part?.type === "text") return String(part.text ?? "").trim();
+    if (part?.type === "image_url") return `[img:${part.image_url?.url ?? ""}]`;
+    return "";
+  }).filter(Boolean).join("\n");
+}
+function buildToolCallsSignature(toolCalls) {
+  if (!toolCalls || toolCalls.length === 0) return "";
+  return toolCalls.map(
+    (tc) => `${tc.function?.name ?? ""}:${normalizeToolArguments(tc.function?.arguments)}`
+  ).join(";;");
+}
+function buildAssistantActionFingerprint(result) {
+  const content = extractNormalizedContentText(result.content);
+  const reasoning = typeof result.reasoning_content === "string" ? result.reasoning_content.trim() : "";
+  let toolCallsSig = buildToolCallsSignature(result.tool_calls);
+  let hasToolCalls = Array.isArray(result.tool_calls) && result.tool_calls.length > 0;
+  if (!toolCallsSig && Array.isArray(result.output) && result.output.length > 0) {
+    const blocksToolCalls = result.output.filter(
+      (b) => b.type === "toolCall"
+    ).map((b) => b.toolCall);
+    if (blocksToolCalls.length > 0) {
+      toolCallsSig = buildToolCallsSignature(blocksToolCalls);
+      hasToolCalls = true;
+    }
+  }
+  const hasNonEmptyText = content.length > 0 || reasoning.length > 0;
+  const fingerprint = `${content}##${reasoning}##${toolCallsSig}`;
+  return {
+    fingerprint,
+    hasNonEmptyText,
+    hasToolCalls,
+    toolCallsSignature: toolCallsSig
+  };
+}
+function buildToolResultsSignature(toolExecutions) {
+  if (toolExecutions.length === 0) return "";
+  return toolExecutions.map((exec) => {
+    const contentStr = typeof exec.content === "string" ? exec.content.trim() : "";
+    const metaStr = exec.metadata ? JSON.stringify(sortJsonKeys(exec.metadata)) : "";
+    return `${exec.toolName}:${contentStr}:${metaStr}`;
+  }).join(";;");
+}
+function resolveProgressGuardConfig(options, env = typeof process !== "undefined" ? process.env : {}) {
+  const envDisabled = env.NOLO_LOOP_PROGRESS_GUARD_DISABLED === "true" || env.NOLO_LOOP_PROGRESS_GUARD_DISABLED === "1";
+  const disabled = options?.disabled ?? envDisabled ?? false;
+  const parsePositiveInt = (val, fallback) => {
+    if (typeof val === "number" && Number.isFinite(val) && val >= 1) {
+      return Math.floor(val);
+    }
+    if (typeof val === "string") {
+      const parsed = parseInt(val, 10);
+      if (Number.isFinite(parsed) && parsed >= 1) {
+        return parsed;
+      }
+    }
+    return fallback;
+  };
+  const maxConsecutiveIdenticalRounds = parsePositiveInt(
+    options?.maxConsecutiveIdenticalRounds ?? env.NOLO_LOOP_MAX_IDENTICAL_ROUNDS,
+    DEFAULT_MAX_CONSECUTIVE_IDENTICAL_ROUNDS
+  );
+  const maxConsecutiveStagnantToolRounds = parsePositiveInt(
+    options?.maxConsecutiveStagnantToolRounds ?? env.NOLO_LOOP_MAX_STAGNANT_TOOL_ROUNDS,
+    DEFAULT_MAX_CONSECUTIVE_STAGNANT_TOOL_ROUNDS
+  );
+  return {
+    disabled,
+    maxConsecutiveIdenticalRounds,
+    maxConsecutiveStagnantToolRounds
+  };
+}
+var LocalLoopProgressGuard = class {
+  config;
+  lastAssistantFingerprint = null;
+  lastAssistantHasNonEmptyText = false;
+  consecutiveIdenticalCount = 0;
+  lastToolCallsSignature = null;
+  lastToolResultsSignature = null;
+  consecutiveStagnantToolCount = 0;
+  constructor(config, env) {
+    this.config = resolveProgressGuardConfig(config, env);
+  }
+  /**
+   * 在 LLM 返回 assistant 响应后调用。
+   * 仅在纯文本/无工具调用且实质文本相同达到阈值时直接熔断；
+   * 若存在工具调用，则不在此处熔断，留待工具执行后结合工具结果综合判定。
+   */
+  observeAssistantResponse(result) {
+    if (this.config.disabled) return { action: "continue" };
+    const { fingerprint, hasNonEmptyText, hasToolCalls } = buildAssistantActionFingerprint(result);
+    if (this.lastAssistantFingerprint !== null && this.lastAssistantFingerprint === fingerprint) {
+      this.consecutiveIdenticalCount += 1;
+      if (!hasToolCalls && hasNonEmptyText && this.consecutiveIdenticalCount >= this.config.maxConsecutiveIdenticalRounds) {
+        return {
+          action: "stall",
+          reason: "repetition_loop",
+          detail: `Consecutive identical text-only assistant response for ${this.consecutiveIdenticalCount} rounds.`,
+          consecutiveRounds: this.consecutiveIdenticalCount
+        };
+      }
+    } else {
+      this.lastAssistantFingerprint = fingerprint;
+      this.lastAssistantHasNonEmptyText = hasNonEmptyText;
+      this.consecutiveIdenticalCount = 1;
+    }
+    return { action: "continue" };
+  }
+  /**
+   * 在本轮所有工具执行完毕后调用，检查是否陷入停滞死循环。
+   * 只有当工具返回内容与元数据完全无变化时才计入无进展 streak；
+   * 一旦工具结果发生变化（如合法轮询状态推进），立即重置 identical streak，确保绝不误杀正常长任务。
+   */
+  observeToolExecution(toolCalls, toolResults) {
+    if (this.config.disabled) return { action: "continue" };
+    if (!toolCalls || toolCalls.length === 0) return { action: "continue" };
+    const toolCallsSig = buildToolCallsSignature(toolCalls);
+    const toolResultsSig = buildToolResultsSignature(toolResults);
+    const toolCallsUnchanged = this.lastToolCallsSignature !== null && this.lastToolCallsSignature === toolCallsSig;
+    const toolResultsUnchanged = this.lastToolResultsSignature !== null && this.lastToolResultsSignature === toolResultsSig;
+    if (toolCallsUnchanged && toolResultsUnchanged) {
+      this.consecutiveStagnantToolCount += 1;
+      if (this.consecutiveIdenticalCount >= this.config.maxConsecutiveIdenticalRounds) {
+        return {
+          action: "stall",
+          reason: "repetition_loop",
+          detail: `Consecutive identical assistant response with unchanged tool results for ${this.consecutiveIdenticalCount} rounds.`,
+          consecutiveRounds: this.consecutiveIdenticalCount
+        };
+      }
+      if (this.consecutiveStagnantToolCount >= this.config.maxConsecutiveStagnantToolRounds) {
+        return {
+          action: "stall",
+          reason: "stagnant_tool_calls",
+          detail: `Consecutive stagnant tool calls with unchanged results for ${this.consecutiveStagnantToolCount} rounds.`,
+          consecutiveRounds: this.consecutiveStagnantToolCount
+        };
+      }
+    } else {
+      this.lastToolCallsSignature = toolCallsSig;
+      this.lastToolResultsSignature = toolResultsSig;
+      this.consecutiveStagnantToolCount = 1;
+      if (!toolResultsUnchanged) {
+        this.consecutiveIdenticalCount = 1;
+      }
+    }
+    return { action: "continue" };
+  }
+};
+function createLocalLoopProgressGuard(config, env) {
+  return new LocalLoopProgressGuard(config, env);
+}
+
 // packages/agent-runtime/localLoop.ts
 var LOCAL_AGENT_CONFIG_MISSING_CODE = "LOCAL_AGENT_CONFIG_MISSING";
 function formatToolExecutionError(args) {
@@ -1490,6 +1675,7 @@ async function runLocalAgentTurn(input) {
   let reasoningEmptyRepairCount = 0;
   let skipFinalAppend = false;
   let partialContent = "";
+  const progressGuard = createLocalLoopProgressGuard(input.progressGuardConfig);
   try {
     const provider = await resolveProviderOnce();
     while (true) {
@@ -1549,6 +1735,23 @@ async function runLocalAgentTurn(input) {
           ...result.provider || agentConfig.provider ? { provider: result.provider || agentConfig.provider } : {}
         });
       }
+      const assistantGuardVerdict = progressGuard.observeAssistantResponse(result);
+      if (assistantGuardVerdict.action === "stall") {
+        emitLoopEvent(input, {
+          kind: "loop-stalled",
+          round,
+          reason: assistantGuardVerdict.reason,
+          detail: assistantGuardVerdict.detail,
+          consecutiveRounds: assistantGuardVerdict.consecutiveRounds,
+          atMs: Date.now()
+        });
+        result = {
+          ...result,
+          content: resolveEmptyAssistantFallbackMessage(assistantGuardVerdict.reason),
+          emptyAssistantFallbackReason: assistantGuardVerdict.reason
+        };
+        break;
+      }
       const toolCalls = result.tool_calls ?? [];
       const rawToolCallsCount = (result.tool_calls?.length ?? 0) || (Array.isArray(result.raw_tool_calls) ? result.raw_tool_calls.length : 0);
       if (toolCalls.length === 0 && rawToolCallsCount === 0) {
@@ -1618,6 +1821,7 @@ ${reasoningTailLog}
         ...result.reasoning_content ? { reasoning_content: result.reasoning_content } : {},
         tool_calls: toolCalls
       });
+      const executedToolResults = [];
       for (const toolCall of toolCalls) {
         throwIfAborted(input);
         const toolName = toolCall.function.name;
@@ -1730,6 +1934,11 @@ ${reasoningTailLog}
             }
           };
         }
+        executedToolResults.push({
+          toolName,
+          content: toolResult.content,
+          metadata: toolResult.metadata
+        });
         messages.push({
           role: "tool",
           content: formatToolMessageContent({
@@ -1742,6 +1951,26 @@ ${reasoningTailLog}
           ...toolResult.metadata ? { tool_result_metadata: toolResult.metadata } : {}
         });
       }
+      const toolExecutionGuardVerdict = progressGuard.observeToolExecution(
+        toolCalls,
+        executedToolResults
+      );
+      if (toolExecutionGuardVerdict.action === "stall") {
+        emitLoopEvent(input, {
+          kind: "loop-stalled",
+          round,
+          reason: toolExecutionGuardVerdict.reason,
+          detail: toolExecutionGuardVerdict.detail,
+          consecutiveRounds: toolExecutionGuardVerdict.consecutiveRounds,
+          atMs: Date.now()
+        });
+        result = {
+          ...result,
+          content: resolveEmptyAssistantFallbackMessage(toolExecutionGuardVerdict.reason),
+          emptyAssistantFallbackReason: toolExecutionGuardVerdict.reason
+        };
+        break;
+      }
       round += 1;
     }
   } catch (error) {
@@ -3379,27 +3608,116 @@ function spawnToWebStreams(options) {
   };
 }
 
+// packages/agent-runtime/processTask.ts
+var ProcessTaskEventLog = class {
+  events = /* @__PURE__ */ new Map();
+  /** Append one event; assigns the next monotonic seq for the task. */
+  append(input) {
+    const list = this.events.get(input.taskId) ?? [];
+    const lastSeq = list.length > 0 ? list[list.length - 1].seq : 0;
+    const event = Object.freeze({
+      taskId: input.taskId,
+      seq: lastSeq + 1,
+      type: input.type,
+      pid: input.pid,
+      createdAt: Date.now(),
+      ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {}
+    });
+    list.push(event);
+    this.events.set(input.taskId, list);
+    return { ...event };
+  }
+  /** All events of the task with `seq > cursor` (default 0 = from the start). */
+  read(taskId, cursor = 0) {
+    return (this.events.get(taskId) ?? []).filter((event) => event.seq > cursor).map((event) => ({ ...event }));
+  }
+  latestSeq(taskId) {
+    const list = this.events.get(taskId);
+    return list && list.length > 0 ? list[list.length - 1].seq : 0;
+  }
+  clear() {
+    this.events.clear();
+  }
+};
+
 // packages/agent-runtime/processRegistry.ts
+var taskIdCounter = 0;
+function mintTaskId(pid) {
+  taskIdCounter += 1;
+  return `ptask-${pid}-${Date.now().toString(36)}-${taskIdCounter.toString(36)}`;
+}
 var ProcessRegistry = class {
   processes = /* @__PURE__ */ new Map();
+  byTaskId = /* @__PURE__ */ new Map();
+  eventLog = new ProcessTaskEventLog();
+  /**
+   * Pre-register an envelope right after a successful spawn and emit the
+   * `started` event. Returns the stored record (with its stable taskId).
+   */
   add(proc) {
-    this.processes.set(proc.pid, {
+    const record = {
+      taskId: proc.taskId ?? mintTaskId(proc.pid),
       pid: proc.pid,
       pgid: proc.pgid,
       command: proc.command,
       label: proc.label,
       startedAt: Date.now(),
       status: "running",
-      persist: proc.persist ?? false
-    });
+      persist: proc.persist ?? false,
+      promoted: false,
+      transient: proc.transient ?? false
+    };
+    this.processes.set(proc.pid, record);
+    this.byTaskId.set(record.taskId, proc.pid);
+    this.eventLog.append({ taskId: record.taskId, pid: proc.pid, type: "started" });
+    return { ...record };
   }
   list() {
     return Array.from(this.processes.values()).map((proc) => ({ ...proc }));
   }
+  /**
+   * User-visible view: only real background tasks — entries registered by
+   * launchProcess (background from birth) plus envelopes promoted to
+   * background by timeout detach. Transient foreground grace-period envelopes
+   * (workspaceShell pre-registration, not yet promoted) are excluded so the
+   * status line, /procs and /stop keep behaving exactly as before Phase 0.
+   * Audit/internal consumers that need the full truth use list() instead.
+   */
+  listBackground() {
+    return Array.from(this.processes.values()).filter((proc) => !proc.transient).map((proc) => ({ ...proc }));
+  }
   get(pid) {
     const item = this.processes.get(pid);
     return item ? { ...item } : void 0;
   }
+  getTaskId(pid) {
+    return this.processes.get(pid)?.taskId;
+  }
+  getByTaskId(taskId) {
+    const pid = this.byTaskId.get(taskId);
+    return pid === void 0 ? void 0 : this.get(pid);
+  }
+  /** Append-only lifecycle events of a task with `seq > cursor` (ascending). */
+  getTaskEvents(taskId, cursor = 0) {
+    return this.eventLog.read(taskId, cursor);
+  }
+  latestTaskSeq(taskId) {
+    return this.eventLog.latestSeq(taskId);
+  }
+  /**
+   * Timeout-detach promotion: mark the pre-registered envelope as a background
+   * task. Same record, same taskId, no re-execution, no second registration.
+   */
+  promote(pid) {
+    const item = this.processes.get(pid);
+    if (!item) return void 0;
+    if (!item.promoted) {
+      item.promoted = true;
+      item.transient = false;
+      this.eventLog.append({ taskId: item.taskId, pid, type: "promoted" });
+    }
+    return { ...item };
+  }
   kill(pid, signal = "SIGTERM") {
     const item = this.processes.get(pid);
     if (!item) return false;
@@ -3409,18 +3727,21 @@ var ProcessRegistry = class {
       } catch {
       }
       item.status = "stopped";
+      this.eventLog.append({ taskId: item.taskId, pid, type: "killed" });
       return true;
     }
     return false;
   }
   stopAll(signal = "SIGTERM", opts) {
     for (const item of this.processes.values()) {
+      if (opts?.backgroundOnly && item.transient) continue;
       if (item.status === "running" && (opts?.includePersist || !item.persist)) {
         try {
           process.kill(-item.pgid, signal);
         } catch {
         }
         item.status = "stopped";
+        this.eventLog.append({ taskId: item.taskId, pid: item.pid, type: "killed" });
       }
     }
   }
@@ -3429,10 +3750,40 @@ var ProcessRegistry = class {
     if (item && item.status === "running") {
       item.exitCode = exitCode;
       item.status = exitCode === 0 ? "exited" : "failed";
+      this.eventLog.append({
+        taskId: item.taskId,
+        pid,
+        type: "exited",
+        exitCode
+      });
     }
   }
+  /**
+   * Grace-period completion: the command ended before detach promotion, so the
+   * envelope is transient by design — record the final event, then drop the
+   * envelope entirely ("不留痕是结果"). The event stream keeps the audit trail.
+   * No-op for already-promoted envelopes (their lifecycle is owned by
+   * markExited after detach).
+   */
+  completeTransient(pid, exitCode) {
+    const item = this.processes.get(pid);
+    if (!item || item.promoted) return;
+    this.eventLog.append({ taskId: item.taskId, pid, type: "exited", exitCode });
+    this.processes.delete(pid);
+    this.byTaskId.delete(item.taskId);
+  }
+  /** Drop an envelope without emitting events (spawn/registration failure paths). */
+  remove(pid) {
+    const item = this.processes.get(pid);
+    if (!item) return false;
+    this.processes.delete(pid);
+    this.byTaskId.delete(item.taskId);
+    return true;
+  }
   clear() {
     this.processes.clear();
+    this.byTaskId.clear();
+    this.eventLog.clear();
   }
 };
 var registry = null;
@@ -3780,6 +4131,21 @@ async function runWorkspaceCommand(args) {
     proc.stdin.write(args.stdin);
     proc.stdin.end();
   }
+  const label = deriveLabel(args.command.join(" "));
+  const registry2 = getProcessRegistry();
+  if (typeof proc.pid === "number") {
+    registry2.add({
+      pid: proc.pid,
+      pgid: proc.pid,
+      command: args.command.join(" "),
+      label,
+      // Foreground grace-period envelope: not a user-visible background task
+      // until promote() flips the marker on timeout detach (see
+      // listBackground). Keeps the status line / /procs / /stop semantics
+      // identical to pre-Phase-0.
+      transient: true
+    });
+  }
   const exitPromise = waitForNodeProcessExit(proc);
   const cleanupChildOnHostSignal = (signal) => {
     if (typeof proc.pid === "number") {
@@ -3856,6 +4222,9 @@ async function runWorkspaceCommand(args) {
     if (abortListener && args.abortSignal) {
       args.abortSignal.removeEventListener("abort", abortListener);
     }
+    if (typeof proc.pid === "number") {
+      registry2.remove(proc.pid);
+    }
     if (isSpawnFailureError(error)) {
       return spawnFailedCommandResult(error, args.outputLimit);
     }
@@ -3885,10 +4254,10 @@ async function runWorkspaceCommand(args) {
     exitPromise.catch(() => {
     });
     const pid = typeof proc.pid === "number" ? proc.pid : 0;
-    const label = deriveLabel(args.command.join(" "));
     const pgid = pid;
-    const registry2 = getProcessRegistry();
-    registry2.add({ pid, pgid, command: args.command.join(" "), label });
+    const promoted = registry2.promote(pid);
+    const envelope = promoted ?? registry2.add({ pid, pgid, command: args.command.join(" "), label });
+    const taskId = envelope.taskId;
     proc.on("close", (code) => {
       detachSignalCleanup();
       registry2.markExited(pid, code ?? 1);
@@ -3904,10 +4273,12 @@ Use listProcesses to inspect or stop it.`,
       detached: true,
       pid,
       label,
+      taskId,
       content: JSON.stringify({
         detached: true,
         pid,
         label,
+        taskId,
         status: "running",
         ...immediate ? { reason: "long-running-command" } : {}
       })
@@ -3918,6 +4289,9 @@ Use listProcesses to inspect or stop it.`,
     stderrPromise
   ]);
   const exitCode = aborted ? 130 : timedOut ? 124 : Number(raceWinner);
+  if (typeof proc.pid === "number") {
+    registry2.completeTransient(proc.pid, exitCode);
+  }
   const stderr = aborted ? `${rawStderr.trim() ? `${rawStderr.trim()}
 ` : ""}command aborted by signal
 ` : timedOut ? `${rawStderr.trim() ? `${rawStderr.trim()}
@@ -4054,7 +4428,15 @@ var execShellCapability = {
         exitCode: result.exitCode,
         timedOut: result.timedOut,
         ...result.aborted ? { aborted: true } : {},
-        ...result.detached ? { detached: true, pid: result.pid, label: result.label, status: "running" } : {},
+        ...result.detached ? {
+          detached: true,
+          pid: result.pid,
+          label: result.label,
+          // Phase 0: stable taskId from the pre-registered Execution
+          // Envelope (additive; existing detached fields untouched).
+          taskId: result.taskId,
+          status: "running"
+        } : {},
         ...normalized.activity ? { activity: normalized.activity } : {}
       }
     };
@@ -5666,7 +6048,7 @@ async function launchProcessTool(args) {
   }
   const pgid = detached ? pid : pid;
   const registry2 = getProcessRegistry();
-  registry2.add({ pid, pgid, command, label, persist });
+  const envelope = registry2.add({ pid, pgid, command, label, persist });
   const cleanupChildOnHostSignal = (signal) => {
     try {
       if (detached) {
@@ -5691,7 +6073,7 @@ async function launchProcessTool(args) {
     registry2.markExited(pid, code ?? 1);
   });
   const activity = extractActivity(parsed);
-  const resultData = { pid, label, status: "running" };
+  const resultData = { pid, label, taskId: envelope.taskId, status: "running" };
   return {
     content: JSON.stringify(resultData),
     metadata: {
@@ -5699,6 +6081,7 @@ async function launchProcessTool(args) {
       pid,
       label,
       status: "running",
+      taskId: envelope.taskId,
       processLaunch: resultData,
       ...activity ? { activity } : {}
     }
@@ -5903,10 +6286,10 @@ function buildLoadSkillExecutor(args) {
         metadata: { loadSkill: true, resolved: false }
       };
     }
-    const { resolveSkillByName } = await import("./skillDiscovery-GPUDHDTZ.js");
+    const { resolveSkillByName } = await import("./skillDiscovery-COX56OBO.js");
     const resolved = resolveSkillByName(args.cwd, name);
     if (!resolved) {
-      const { resolveCodingBuiltinSlug, buildCodingSkillContentBySlug } = await import("./codingSkills-6F4EQFCM.js");
+      const { resolveCodingBuiltinSlug, buildCodingSkillContentBySlug } = await import("./codingSkills-H6N5EKSX.js");
       const builtinSlug = resolveCodingBuiltinSlug(name);
       if (builtinSlug) {
         const body = buildCodingSkillContentBySlug(builtinSlug);
@@ -5941,7 +6324,7 @@ ${body}`,
   };
 }
 async function formatUnknownSkillMessage(cwd, requestedName) {
-  const { discoverSkills } = await import("./skillDiscovery-GPUDHDTZ.js");
+  const { discoverSkills } = await import("./skillDiscovery-COX56OBO.js");
   let available = [];
   try {
     available = discoverSkills(cwd).map((s) => s.name);

package/{chunk-ILZY5B4U.js → chunk-MUG4FG5J.js}

@@ -20,7 +20,7 @@ import {
   parseAgentRunEvent,
   t,
   toolLabel
-} from "./chunk-RKRXAL3V.js";
+} from "./chunk-7MWPUOKI.js";
 import {
   getReadableCliDb
 } from "./chunk-UNHKVD2N.js";
@@ -51,7 +51,7 @@ import {
 } from "./chunk-LTRXGFMS.js";
 import {
   formatAgentListCard
-} from "./chunk-5GQ6XCJY.js";
+} from "./chunk-JK7UM3LT.js";
 import {
   isGatewayHttpStatus
 } from "./chunk-RQSOAMPJ.js";
@@ -70,28 +70,28 @@ import {
   chooseMemoryOwners,
   loadMemoryCandidatesFromDb,
   resolveAgentMemoryPolicy
-} from "./chunk-Y5W623XU.js";
+} from "./chunk-NT3QRCVS.js";
 import {
   API_REPORTED_COST_MULTIPLIER,
   normalizeUsage,
   parseUiAskChoiceContent
-} from "./chunk-PILJX4DH.js";
+} from "./chunk-ARFXKWJH.js";
 import {
   getDefaultCliLocalRuntimeDb
 } from "./chunk-N4XRDM26.js";
 import {
   buildSkillDiscoveryContextLayer
-} from "./chunk-2BWU4ORW.js";
+} from "./chunk-OFZPJ3NT.js";
 import {
   parseExternalSkillMarkdown,
   parseSkillDocProtocol
-} from "./chunk-EY7V7REW.js";
+} from "./chunk-AETZ7AD6.js";
 import {
   LOCAL_AGENT_CONFIG_MISSING_CODE,
   LOCAL_TURN_ABORTED_CODE,
   readActionGate,
   readCommandActionGatePayload
-} from "./chunk-I7VDDN45.js";
+} from "./chunk-LBZHTQTD.js";
 import {
   resolveAgentRuntimeConfigFromRecord
 } from "./chunk-64KIQZA2.js";
@@ -5359,7 +5359,7 @@ function findCollapsedPasteSpanAt(buffer, pos, opts = {}) {
 // packages/cli/client/agentRun.ts
 import { ulid } from "ulid";
 async function loadRunLocalAgentTurn() {
-  const { runLocalAgentTurn } = await import("./agentRuntimeLocal-XXBMDMBU.js");
+  const { runLocalAgentTurn } = await import("./agentRuntimeLocal-GTNYV7LH.js");
   return runLocalAgentTurn;
 }
 async function resolveCurrentMachineId(options) {
@@ -7149,9 +7149,9 @@ async function runAgentRunCommand(args, deps) {
     }
   }
   if (typeof childRunId === "string" && childRunId.length > 0) {
-    const isTruncated = result.emptyAssistantFallbackReason === "length_truncated" || result.emptyAssistantFallbackReason === "stream_truncated";
-    const truncationNote = isTruncated ? { note: `empty assistant output: ${result.emptyAssistantFallbackReason}` } : {};
-    const finalStatus = isTruncated || result.exitCode !== 0 ? "failed" : "done";
+    const isStalledOrTruncated = result.emptyAssistantFallbackReason === "length_truncated" || result.emptyAssistantFallbackReason === "stream_truncated" || result.emptyAssistantFallbackReason === "repetition_loop" || result.emptyAssistantFallbackReason === "stagnant_tool_calls";
+    const truncationNote = isStalledOrTruncated ? { note: `empty assistant output: ${result.emptyAssistantFallbackReason}` } : {};
+    const finalStatus = isStalledOrTruncated || result.exitCode !== 0 ? "failed" : "done";
     await (deps.finalizeRunRecord ?? finalizeRunRecord)(
       childRunId,
       {

package/{chunk-Y5W623XU.js → chunk-NT3QRCVS.js}

@@ -1,11 +1,11 @@
 import {
   addContentToSpace
-} from "./chunk-QI3CHZUT.js";
+} from "./chunk-D72M3G32.js";
 import {
   prepareAndPersistMessage,
   uiAskChoiceFunc,
   uiAskChoiceFunctionSchema
-} from "./chunk-PILJX4DH.js";
+} from "./chunk-ARFXKWJH.js";
 import {
   require_date_fns
 } from "./chunk-M76ECQRD.js";
@@ -14,7 +14,7 @@ import {
 } from "./chunk-IIOHYLIG.js";
 import {
   buildSkillDocMarkdown
-} from "./chunk-EY7V7REW.js";
+} from "./chunk-AETZ7AD6.js";
 import {
   PLATFORM_HOSTED_DEEPSEEK_FLASH_MODEL,
   PLATFORM_HOSTED_DEEPSEEK_FLASH_PEAK_PRICE,