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

package/{chunk-PILJX4DH.js → chunk-7KY6U7MW.js}

@@ -13,7 +13,7 @@ import {
 } from "./chunk-AGGIDPCZ.js";
 import {
   runLlm
-} from "./chunk-TLBZMLLJ.js";
+} from "./chunk-55C3UZSC.js";
 import {
   cleanupCliSessionForDialog
 } from "./chunk-MGIHZ5CJ.js";
@@ -3519,7 +3519,7 @@ var messageSlice = createSliceWithThunks({
             runtimeOptions: args.runtimeOptions
           });
           if (agentKeyToUse) {
-            const { streamAgentChatTurn } = await import("./agentSlice-HTIEYKIU.js");
+            const { streamAgentChatTurn } = await import("./agentSlice-B2IMSPH5.js");
             await dispatch(
               streamAgentChatTurn({
                 agentKey: agentKeyToUse,
@@ -4742,7 +4742,7 @@ var deleteDialogThunk = async (payload, thunkApi) => {
   }
   if (isCurrentDialog) {
     await thunkApi.dispatch(resetMsgs());
-    const { clearPendingAttachments: clearPendingAttachments2 } = await import("./dialogSlice-6BINHWQT.js");
+    const { clearPendingAttachments: clearPendingAttachments2 } = await import("./dialogSlice-62JC4ZMX.js");
     dispatch(clearPendingAttachments2());
   }
   return { dialogKey, isCurrentDialog, attachmentPlan };
@@ -4750,15 +4750,15 @@ var deleteDialogThunk = async (payload, thunkApi) => {
 
 // packages/chat/dialog/dialogSlice.ts
 var runCreateDialogAction = async (args, thunkApi) => {
-  const { createDialogAction } = await import("./createDialogAction-FD5AEOUF.js");
+  const { createDialogAction } = await import("./createDialogAction-5LB4YBPS.js");
   return createDialogAction(args, thunkApi);
 };
 var runCreateAgentAutomationAction = async (args, thunkApi) => {
-  const { createAgentAutomationAction } = await import("./createAgentAutomationAction-TGUXUZCY.js");
+  const { createAgentAutomationAction } = await import("./createAgentAutomationAction-IDIY6K45.js");
   return createAgentAutomationAction(args, thunkApi);
 };
 var runUpdateDialogTitleAction = async (args, thunkApi) => {
-  const { updateDialogTitleAction } = await import("./updateDialogTitleAction-EDUCIB7G.js");
+  const { updateDialogTitleAction } = await import("./updateDialogTitleAction-2A3BEXSP.js");
   return updateDialogTitleAction(args, thunkApi);
 };
 var runAddDialogAgentAction = async (args, thunkApi) => {
@@ -4782,7 +4782,7 @@ var runSetDialogExtraReferencesAction = async (args, thunkApi) => {
   return setDialogExtraReferencesAction(args, thunkApi);
 };
 var runHandleSendMessageAction = async (args, thunkApi) => {
-  const { handleSendMessageAction } = await import("./handleSendMessageAction-QVG5YNZY.js");
+  const { handleSendMessageAction } = await import("./handleSendMessageAction-YB64A32O.js");
   return handleSendMessageAction(args, thunkApi);
 };
 function clearDialogState() {
@@ -4795,7 +4795,7 @@ var createPageAndAddReference = createAsyncThunk(
   async (payload, { dispatch, getState, rejectWithValue }) => {
     const { slateData, jsonData, title, type, fileId, groupId, dialogKey } = payload;
     try {
-      const { createDocState } = await import("./docStore-SIUFLABN.js");
+      const { createDocState } = await import("./docStore-ZRNKZZXU.js");
       const pageKey = await createDocState(
         { slateData, title },
         { dispatch, getState }

package/chunk-AETZ7AD6.js

@@ -0,0 +1,274 @@
+import {
+  dump,
+  load
+} from "./chunk-KHCLMKZZ.js";
+import {
+  asTrimmedNonEmptyStringArray
+} from "./chunk-I42VC5KR.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/ai/skills/skillDocProtocol.ts
+var SKILL_DOC_ENUMS = {
+  triggerMode: ["explicit", "required", "recommended"],
+  // budgetTier 只服务 WorkflowReferenceConfig；skill 侧已移除（零读点）。
+  budgetTier: ["low", "medium", "high"],
+  modality: ["text", "image", "video", "audio", "3d"],
+  docKind: ["knowledge", "instruction", "skill"]
+};
+var SKILL_CONFIG_BLOCK = "skill-config";
+var EVAL_CONFIG_BLOCK = "eval-config";
+var WORKFLOW_CONFIG_BLOCK = "workflow-config";
+var normalizeStringArray = (value) => {
+  if (!Array.isArray(value)) return void 0;
+  const items = [...new Set(asTrimmedNonEmptyStringArray(value))];
+  return items.length > 0 ? items : void 0;
+};
+var normalizeSkillEnumValue = (key, value) => typeof value === "string" && SKILL_DOC_ENUMS[key].includes(value) ? value : void 0;
+var normalizeSkillModalities = (value) => {
+  const raw = normalizeStringArray(value);
+  if (!raw) return void 0;
+  const filtered = raw.flatMap((item) => {
+    const modality = normalizeSkillEnumValue("modality", item);
+    return modality ? [modality] : [];
+  });
+  return filtered.length > 0 ? Array.from(new Set(filtered)) : void 0;
+};
+var normalizeSkillConfig = (value, fallbackTools) => {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  const name = asOptionalTrimmedString(record.name) ?? "";
+  const description = asOptionalTrimmedString(record.description) ?? "";
+  if (!name || !description) return void 0;
+  const triggerMode = normalizeSkillEnumValue("triggerMode", record.triggerMode);
+  const modalities = normalizeSkillModalities(record.modalities);
+  const toolNames = normalizeStringArray(record.toolNames) ?? normalizeStringArray(fallbackTools) ?? void 0;
+  return {
+    version: "0.1",
+    kind: "skill",
+    id: asOptionalTrimmedString(record.id),
+    name,
+    description,
+    triggerMode,
+    toolNames,
+    modalities,
+    requiredSkills: normalizeStringArray(record.requiredSkills),
+    recommendedSkills: normalizeStringArray(record.recommendedSkills),
+    promptPatch: asOptionalTrimmedString(record.promptPatch)
+  };
+};
+var normalizeEvalConfig = (value) => {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  if (!Array.isArray(record.cases)) return void 0;
+  const cases = [];
+  for (const item of record.cases) {
+    if (!item || typeof item !== "object") continue;
+    const testCase = item;
+    const input = asOptionalTrimmedString(testCase.input) ?? "";
+    if (!input) continue;
+    cases.push({
+      input,
+      expectedTools: normalizeStringArray(testCase.expectedTools),
+      expectedSignals: normalizeStringArray(testCase.expectedSignals),
+      forbiddenSignals: normalizeStringArray(testCase.forbiddenSignals)
+    });
+  }
+  return cases.length > 0 ? {
+    version: "0.1",
+    cases
+  } : void 0;
+};
+var normalizeWorkflowConfig = (value) => {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  const name = asOptionalTrimmedString(record.name) ?? "";
+  const description = asOptionalTrimmedString(record.description) ?? "";
+  if (!name || !description) return void 0;
+  const budgetTier = normalizeSkillEnumValue("budgetTier", record.budgetTier);
+  return {
+    version: "0.1",
+    kind: "workflow",
+    id: asOptionalTrimmedString(record.id),
+    name,
+    description,
+    defaultAgent: asOptionalTrimmedString(record.defaultAgent),
+    inputs: normalizeStringArray(record.inputs),
+    recommendedTools: normalizeStringArray(record.recommendedTools),
+    requiredTools: normalizeStringArray(record.requiredTools),
+    requiredOutputs: normalizeStringArray(record.requiredOutputs),
+    gates: normalizeStringArray(record.gates),
+    budgetTier,
+    contextStrategy: asOptionalTrimmedString(record.contextStrategy),
+    failureProtocol: asOptionalTrimmedString(record.failureProtocol)
+  };
+};
+var normalizePageSkillMetadata = (value, fallbackTools) => {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  const kind = normalizeSkillEnumValue("docKind", record.kind);
+  const meta = {
+    kind,
+    requiredSkills: normalizeStringArray(record.requiredSkills),
+    recommendedSkills: normalizeStringArray(record.recommendedSkills),
+    skillConfig: normalizeSkillConfig(record.skillConfig, fallbackTools),
+    evalConfig: normalizeEvalConfig(record.evalConfig),
+    workflowConfig: normalizeWorkflowConfig(record.workflowConfig)
+  };
+  if (meta.skillConfig && !meta.kind) {
+    meta.kind = "skill";
+  }
+  if (meta.workflowConfig && !meta.kind) {
+    meta.kind = "instruction";
+  }
+  return meta.kind || meta.requiredSkills || meta.recommendedSkills || meta.skillConfig || meta.evalConfig || meta.workflowConfig ? meta : void 0;
+};
+var extractCommentBlock = (markdown, blockName) => {
+  if (!markdown) return void 0;
+  const matcher = new RegExp(
+    `<!--\\s*${blockName}\\s*\\n([\\s\\S]*?)-->`,
+    "i"
+  );
+  const match = markdown.match(matcher);
+  return asOptionalTrimmedString(match?.[1]);
+};
+var removeCommentBlock = (markdown, blockName) => markdown.replace(
+  new RegExp(`\\n?<!--\\s*${blockName}\\s*\\n[\\s\\S]*?-->\\s*`, "gi"),
+  "\n\n"
+);
+var parseYamlObject = (raw) => {
+  if (!raw) return void 0;
+  try {
+    const parsed = load(raw);
+    return parsed && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var parseSkillDocProtocol = (markdown, existingMeta, fallbackTools) => {
+  const source = typeof markdown === "string" ? markdown : "";
+  const skillBlock = parseYamlObject(extractCommentBlock(source, SKILL_CONFIG_BLOCK));
+  const evalBlock = parseYamlObject(extractCommentBlock(source, EVAL_CONFIG_BLOCK));
+  const workflowBlock = parseYamlObject(extractCommentBlock(source, WORKFLOW_CONFIG_BLOCK));
+  const cleanedContent = removeCommentBlock(
+    removeCommentBlock(
+      removeCommentBlock(source, SKILL_CONFIG_BLOCK),
+      EVAL_CONFIG_BLOCK
+    ),
+    WORKFLOW_CONFIG_BLOCK
+  ).replace(/\n{3,}/g, "\n\n").trim();
+  const parsedMeta = normalizePageSkillMetadata(
+    {
+      ...existingMeta ?? {},
+      ...skillBlock ? {
+        kind: existingMeta?.kind === "skill" || skillBlock.kind === "skill" ? "skill" : existingMeta?.kind,
+        requiredSkills: skillBlock.requiredSkills ?? existingMeta?.requiredSkills,
+        recommendedSkills: skillBlock.recommendedSkills ?? existingMeta?.recommendedSkills,
+        skillConfig: skillBlock
+      } : {},
+      ...evalBlock ? { evalConfig: evalBlock } : {},
+      ...workflowBlock ? { workflowConfig: workflowBlock } : {}
+    },
+    fallbackTools
+  );
+  return {
+    content: cleanedContent,
+    meta: parsedMeta
+  };
+};
+var resolvePageSkillMetadata = (page) => {
+  if (!page) return void 0;
+  const existingMeta = normalizePageSkillMetadata(page.meta, page.tools);
+  return parseSkillDocProtocol(page.content ?? "", existingMeta, page.tools).meta;
+};
+var yamlBlock = (value) => dump(value, { lineWidth: 120, noRefs: true }).trim();
+var buildSkillConfigComment = (config) => {
+  const payload = {
+    version: config.version,
+    kind: config.kind,
+    ...config.id ? { id: config.id } : {},
+    name: config.name,
+    description: config.description,
+    ...config.triggerMode ? { triggerMode: config.triggerMode } : {},
+    ...config.requiredSkills?.length ? { requiredSkills: config.requiredSkills } : {},
+    ...config.recommendedSkills?.length ? { recommendedSkills: config.recommendedSkills } : {},
+    ...config.toolNames?.length ? { toolNames: config.toolNames } : {},
+    ...config.modalities?.length ? { modalities: config.modalities } : {},
+    ...config.promptPatch ? { promptPatch: config.promptPatch } : {}
+  };
+  return `<!-- ${SKILL_CONFIG_BLOCK}
+${yamlBlock(payload)}
+-->`;
+};
+var buildEvalConfigComment = (config) => `<!-- ${EVAL_CONFIG_BLOCK}
+${yamlBlock({
+  version: config.version,
+  cases: config.cases
+})}
+-->`;
+var buildWorkflowConfigComment = (config) => `<!-- ${WORKFLOW_CONFIG_BLOCK}
+${yamlBlock({
+  version: config.version,
+  kind: config.kind,
+  ...config.id ? { id: config.id } : {},
+  name: config.name,
+  description: config.description,
+  ...config.defaultAgent ? { defaultAgent: config.defaultAgent } : {},
+  ...config.inputs?.length ? { inputs: config.inputs } : {},
+  ...config.recommendedTools?.length ? { recommendedTools: config.recommendedTools } : {},
+  ...config.requiredTools?.length ? { requiredTools: config.requiredTools } : {},
+  ...config.requiredOutputs?.length ? { requiredOutputs: config.requiredOutputs } : {},
+  ...config.gates?.length ? { gates: config.gates } : {},
+  ...config.budgetTier ? { budgetTier: config.budgetTier } : {},
+  ...config.contextStrategy ? { contextStrategy: config.contextStrategy } : {},
+  ...config.failureProtocol ? { failureProtocol: config.failureProtocol } : {}
+})}
+-->`;
+var buildSkillDocMarkdown = (options) => {
+  const sections = [
+    asOptionalTrimmedString(options.body) ?? "",
+    buildSkillConfigComment(options.skillConfig),
+    options.evalConfig ? buildEvalConfigComment(options.evalConfig) : "",
+    options.workflowConfig ? buildWorkflowConfigComment(options.workflowConfig) : ""
+  ].filter(Boolean);
+  return sections.join("\n\n").trim();
+};
+var extractFrontmatter = (markdown) => {
+  const match = markdown.match(/^\s*---\s*\n([\s\S]*?)\n\s*---\s*\n?/);
+  if (!match) return { body: markdown.trim() };
+  const frontmatter = parseYamlObject(match[1]);
+  const body = markdown.slice(match[0].length).trim();
+  return { frontmatter, body };
+};
+var normalizeAllowedTools = (value) => {
+  if (Array.isArray(value)) {
+    return normalizeStringArray(value) ?? [];
+  }
+  if (typeof value === "string") {
+    return value.split(/\s+/).map((item) => item.trim()).filter(Boolean);
+  }
+  return [];
+};
+var parseExternalSkillMarkdown = (markdown) => {
+  const { frontmatter, body } = extractFrontmatter(markdown);
+  return {
+    name: asOptionalTrimmedString(frontmatter?.name),
+    description: asOptionalTrimmedString(frontmatter?.description),
+    compatibility: asOptionalTrimmedString(frontmatter?.compatibility),
+    allowedTools: normalizeAllowedTools(frontmatter?.["allowed-tools"]),
+    metadata: frontmatter?.metadata && typeof frontmatter.metadata === "object" ? Object.fromEntries(
+      Object.entries(frontmatter.metadata).filter(([, value]) => typeof value === "string").map(([key, value]) => [key, String(value)])
+    ) : void 0,
+    body
+  };
+};
+
+export {
+  normalizeStringArray,
+  normalizeSkillModalities,
+  parseSkillDocProtocol,
+  resolvePageSkillMetadata,
+  buildSkillDocMarkdown,
+  parseExternalSkillMarkdown
+};

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

@@ -27,7 +27,7 @@ import {
   hasAssistantVisibleOutput,
   resolveEmptyAssistantFallbackMessage,
   resolveEmptyAssistantOutcome
-} from "./chunk-AA2YUJNV.js";
+} from "./chunk-P66M7LSQ.js";
 import {
   createThinkParserState,
   createToolCallAccumulator,
@@ -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) {
@@ -5903,10 +6132,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 +6170,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-Z7COG62J.js → chunk-INXNBCEY.js}

@@ -1,6 +1,6 @@
 import {
   updateContentTitle
-} from "./chunk-QI3CHZUT.js";
+} from "./chunk-OCJNJUR4.js";
 import {
   require_date_fns
 } from "./chunk-M76ECQRD.js";
@@ -367,7 +367,7 @@ async function saveDocState(arg, { dispatch, getState }) {
   }
 }
 async function createDocState(args, thunkApi) {
-  const { createPageAction } = await import("./createPageAction-NPC3LYNK.js");
+  const { createPageAction } = await import("./createPageAction-TJWVDPZD.js");
   return createPageAction(args, thunkApi);
 }
 function subscribe(listener) {