memeloop 0.0.1 → 0.1.1

package/dist/mobile.cjs

@@ -0,0 +1,2711 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mobile.ts
+var mobile_exports = {};
+__export(mobile_exports, {
+  createFetchLLMProvider: () => createFetchLLMProvider,
+  getBuiltinLoopProfile: () => getBuiltinLoopProfile,
+  getBuiltinLoopProfiles: () => getBuiltinLoopProfiles,
+  resolveAgentToolLoopTerminalState: () => resolveAgentToolLoopTerminalState,
+  runAgentToolLoopTurn: () => runAgentToolLoopTurn
+});
+module.exports = __toCommonJS(mobile_exports);
+
+// src/llm/fetchProvider.ts
+var import_ai = require("ai");
+function createFetchLLMProvider(config) {
+  return {
+    name: config.name,
+    ...config.modelId !== void 0 ? { modelId: config.modelId } : {},
+    // Store the factory so hosts can introspect or extend
+    model: config.createModel,
+    async chat(request) {
+      const body = typeof request === "object" && request !== null ? request : {};
+      const model = config.createModel(body.model);
+      const specificationVersion = model?.specificationVersion;
+      if (model === null || typeof model !== "object" || !["v2", "v3", "v4"].includes(String(specificationVersion))) {
+        throw new Error(
+          `LLM provider '${config.name}' returned an incompatible AI SDK model for '${typeof body.model === "string" ? body.model : config.modelId ?? "default"}' (expected specificationVersion v2, v3, or v4; received ${String(specificationVersion)})`
+        );
+      }
+      const systemMessages = (body.messages ?? []).filter((message) => message.role === "system").map((message) => message.content);
+      const messages = (body.messages ?? []).filter((message) => message.role !== "system").map((message) => {
+        const role = message.role === "tool" ? "user" : message.role;
+        return {
+          role,
+          content: message.content
+        };
+      });
+      const system = body.system ?? (systemMessages.length > 0 ? systemMessages.join("\n\n") : void 0);
+      const temperature = body.temperature;
+      const abortSignal = body.abortSignal;
+      const maxOutputTokens = body.max_tokens;
+      if (body.stream !== false) {
+        let streamingError;
+        const result2 = (0, import_ai.streamText)({
+          model,
+          instructions: system,
+          messages,
+          maxOutputTokens,
+          temperature,
+          abortSignal,
+          onError: ({ error }) => {
+            streamingError = error;
+          }
+        });
+        return (async function* () {
+          for await (const chunk of result2.textStream) {
+            yield chunk;
+          }
+          if (streamingError !== void 0) {
+            throw streamingError instanceof Error ? streamingError : new Error("The model stream failed", { cause: streamingError });
+          }
+        })();
+      }
+      const result = await (0, import_ai.generateText)({
+        model,
+        instructions: system,
+        messages,
+        maxOutputTokens,
+        temperature,
+        abortSignal
+      });
+      return result.text;
+    }
+  };
+}
+
+// src/conversation/parts.ts
+function tryParseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function parseLegacyToolResultContent(content) {
+  const match = /(?:<functions_result>\s*)?Tool:\s*(.+?)\nParameters:\s*(.+?)\n(Error|Result):\s*([\s\S]*?)\s*(?:<\/functions_result>|$)/su.exec(content.trim());
+  if (!match) return null;
+  const [, rawToolName, rawParameters, kind, rawBody] = match;
+  const parsedParameters = tryParseJson(rawParameters.trim());
+  const result = rawBody.trim();
+  return {
+    type: "tool-result",
+    toolName: rawToolName.trim(),
+    parameters: parsedParameters,
+    result,
+    isError: kind === "Error",
+    payload: tryParseJson(result)
+  };
+}
+function isTextPart(part) {
+  return part.type === "text";
+}
+function isReasoningPart(part) {
+  return part.type === "reasoning";
+}
+function isToolCallPart(part) {
+  return part.type === "tool-call";
+}
+function isAttachmentPart(part) {
+  return part.type === "attachment";
+}
+function isToolResultPart(part) {
+  return part.type === "tool-result";
+}
+function buildToolResultSummary(part) {
+  const prefix = part.isError ? "Error" : "Result";
+  const suffix = part.result.trim();
+  if (suffix.length === 0) return `${prefix} from ${part.toolName}`;
+  return `${prefix} from ${part.toolName}: ${suffix}`;
+}
+function projectChatMessageParts(parts) {
+  const text = parts.filter(isTextPart).map((part) => part.text.trim()).filter(Boolean);
+  const reasoning = parts.filter(isReasoningPart).map((part) => part.text.trim()).filter(Boolean);
+  const toolCalls = parts.filter(isToolCallPart).map((part) => ({ id: part.toolCallId, toolName: part.toolName, arguments: part.arguments }));
+  const attachments = parts.filter(isAttachmentPart).map((part) => part.attachment);
+  const toolResults = parts.filter(isToolResultPart);
+  let content = text.join("\n\n");
+  if (content.length === 0 && toolResults.length > 0) {
+    content = toolResults.map(buildToolResultSummary).join("\n\n");
+  }
+  if (content.length === 0 && toolCalls.length > 0) {
+    content = toolCalls.map((part) => `Tool call: ${part.toolName}`).join("\n\n");
+  }
+  return {
+    content,
+    reasoning_content: reasoning.length > 0 ? reasoning.join("\n\n") : void 0,
+    toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+    attachments: attachments.length > 0 ? attachments : void 0
+  };
+}
+function buildLegacyChatMessageParts(input) {
+  const parts = [];
+  if (input.role !== "tool" && typeof input.content === "string" && input.content.trim().length > 0) {
+    parts.push({ type: "text", text: input.content });
+  }
+  if (typeof input.reasoning_content === "string" && input.reasoning_content.trim().length > 0) {
+    parts.push({ type: "reasoning", text: input.reasoning_content });
+  }
+  if (input.toolCalls) {
+    for (const toolCall of input.toolCalls) {
+      parts.push({
+        type: "tool-call",
+        toolCallId: toolCall.id,
+        toolName: toolCall.toolName,
+        arguments: toolCall.arguments
+      });
+    }
+  }
+  if (input.attachments) {
+    for (const attachment of input.attachments) {
+      parts.push({ type: "attachment", attachment });
+    }
+  }
+  if (input.role === "tool") {
+    const metadata = input.metadata ?? {};
+    const parsed = typeof input.content === "string" ? parseLegacyToolResultContent(input.content) : null;
+    const toolName = typeof metadata.toolId === "string" && metadata.toolId.length > 0 ? metadata.toolId : parsed?.toolName ?? "tool";
+    const result = parsed?.result ?? (typeof input.content === "string" ? input.content : "");
+    const payload = parsed?.payload ?? tryParseJson(result);
+    parts.push({
+      type: "tool-result",
+      toolName,
+      parameters: metadata.toolParameters ?? parsed?.parameters,
+      result,
+      isError: metadata.isError === true || parsed?.isError === true,
+      payload,
+      detailRef: input.detailRef
+    });
+  }
+  return parts;
+}
+function getChatMessageParts(message) {
+  return message.parts ?? buildLegacyChatMessageParts(message);
+}
+
+// src/conversation/factory.ts
+function createChatMessage(input) {
+  const now = Date.now();
+  const parts = input.parts ?? buildLegacyChatMessageParts({
+    role: input.role,
+    content: input.content,
+    reasoning_content: input.reasoning_content,
+    toolCalls: input.toolCalls,
+    attachments: input.attachments,
+    detailRef: input.detailRef,
+    metadata: input.metadata
+  });
+  const projection = projectChatMessageParts(parts);
+  return {
+    messageId: input.messageId,
+    conversationId: input.conversationId,
+    originNodeId: input.originNodeId ?? "unknown",
+    timestamp: now,
+    lamportClock: input.lamportClock ?? now,
+    role: input.role,
+    parts: parts.length > 0 ? parts : void 0,
+    content: input.content ?? projection.content,
+    contentType: input.contentType ?? "text/plain",
+    metadata: input.metadata,
+    duration: input.duration,
+    toolCalls: input.toolCalls ?? projection.toolCalls,
+    reasoning_content: input.reasoning_content ?? projection.reasoning_content,
+    hidden: input.hidden,
+    attachments: input.attachments ?? projection.attachments,
+    detailRef: input.detailRef
+  };
+}
+
+// src/tools/pluginRegistry.ts
+var defaultPluginRegistry = /* @__PURE__ */ new Map();
+var activeOverride = null;
+function getActivePluginRegistry() {
+  return activeOverride ?? defaultPluginRegistry;
+}
+function createHookSlot() {
+  const handlers = [];
+  return {
+    handlers,
+    tapAsync(_name, function_) {
+      handlers.push(function_);
+    },
+    async promise(context) {
+      for (const function_ of handlers) {
+        await new Promise((resolve) => {
+          function_(context, resolve);
+        });
+      }
+    }
+  };
+}
+function createAgentFrameworkHooks() {
+  return {
+    processPrompts: createHookSlot(),
+    finalizePrompts: createHookSlot(),
+    postProcess: createHookSlot(),
+    userMessageReceived: createHookSlot(),
+    agentStatusChanged: createHookSlot(),
+    toolExecuted: createHookSlot(),
+    responseUpdate: createHookSlot(),
+    responseComplete: createHookSlot()
+  };
+}
+var hookHandlers = {};
+async function runProcessPromptsHooks(_hooks, context) {
+  const slot = _hooks.processPrompts;
+  const fns = slot?.handlers ?? hookHandlers.processPrompts ?? [];
+  for (const function_ of fns) {
+    await new Promise((resolve) => {
+      function_(context, resolve);
+    });
+  }
+  return context;
+}
+async function runResponseCompleteHooks(hooks, context) {
+  await hooks.responseComplete.promise(context);
+}
+async function runPostProcessHooks(hooks, context) {
+  await hooks.postProcess.promise(context);
+}
+function resolvePromptPluginMap(context) {
+  const fromTools = context.tools?.getPromptPlugins?.();
+  if (fromTools) return fromTools;
+  return getActivePluginRegistry();
+}
+async function createHooksWithPlugins(agentFrameworkConfig, options) {
+  const reg = options?.pluginRegistry ?? getActivePluginRegistry();
+  const hooks = createAgentFrameworkHooks();
+  if (agentFrameworkConfig.plugins) {
+    for (const pluginConfig of agentFrameworkConfig.plugins) {
+      const { toolId } = pluginConfig;
+      const plugin = reg.get(toolId);
+      if (plugin) {
+        plugin(hooks);
+      }
+    }
+  }
+  return {
+    hooks,
+    pluginConfigs: agentFrameworkConfig.plugins ?? []
+  };
+}
+
+// src/promptUtilities/responseConcat.ts
+function cloneResponses(responses) {
+  return structuredClone(responses);
+}
+async function responseConcat(agentFrameworkConfig, llmResponse, agentFrameworkContext, messages) {
+  const responses = Array.isArray(agentFrameworkConfig?.response) ? cloneResponses(agentFrameworkConfig.response) : [];
+  const toolConfigs = (Array.isArray(agentFrameworkConfig.plugins) ? agentFrameworkConfig.plugins : []).filter((t) => t.enabled !== false);
+  const hooks = createAgentFrameworkHooks();
+  const pluginMap = resolvePromptPluginMap(agentFrameworkContext);
+  for (const tool of toolConfigs) {
+    const builtInTool = pluginMap.get(tool.toolId);
+    if (builtInTool) {
+      builtInTool(hooks);
+    }
+  }
+  let yieldNextRoundTo;
+  let toolCallInfo;
+  for (const tool of toolConfigs) {
+    const responseContext = {
+      agentFrameworkContext,
+      messages,
+      prompts: [],
+      toolConfig: tool,
+      llmResponse,
+      responses,
+      metadata: {},
+      actions: {}
+    };
+    await runPostProcessHooks(hooks, responseContext);
+    if (responseContext.actions?.yieldNextRoundTo) {
+      yieldNextRoundTo = responseContext.actions.yieldNextRoundTo;
+      if (responseContext.actions.toolCalling) {
+        toolCallInfo = responseContext.actions.toolCalling;
+      }
+    }
+  }
+  const processedResponse = flattenResponses(responses);
+  return {
+    processedResponse: processedResponse || llmResponse,
+    yieldNextRoundTo,
+    toolCallInfo
+  };
+}
+function flattenResponses(responses) {
+  if (responses.length === 0) {
+    return "";
+  }
+  return responses.filter((response) => response.enabled !== false).map((response) => response.text || "").join("\n\n").trim();
+}
+
+// src/promptUtilities/responsePatternUtility.ts
+var import_json5 = __toESM(require("json5"), 1);
+var MAX_FALLBACK_INPUT_LENGTH = 1e3;
+var TOOL_PARAMETER_PARSE_ERROR_KEY = "__memeloopToolParameterParseError";
+function parseToolParameters(parametersText) {
+  if (!parametersText || !parametersText.trim()) {
+    return {};
+  }
+  const trimmedText = parametersText.trim();
+  try {
+    return JSON.parse(trimmedText);
+  } catch {
+  }
+  try {
+    return import_json5.default.parse(trimmedText);
+  } catch {
+  }
+  return {
+    [TOOL_PARAMETER_PARSE_ERROR_KEY]: `Invalid tool arguments JSON. Return one valid JSON object inside the tool tag. Received: ${trimmedText.substring(0, MAX_FALLBACK_INPUT_LENGTH)}`
+  };
+}
+function extractFunctionCallsParameters(text) {
+  const parameters = {};
+  const parameterRegex = /<parameter\s+name="([^"]+)"[^>]*>([^<]*)<\/parameter>/g;
+  let m;
+  while ((m = parameterRegex.exec(text)) !== null) {
+    parameters[m[1]] = m[2].trim();
+  }
+  return parameters;
+}
+var toolPatterns = [
+  {
+    name: "tool_use",
+    pattern: /<tool_use\s+name="([^"]+)"[^>]*>(.*?)<\/tool_use>/gis,
+    extractToolId: (match) => match[1],
+    extractParams: (match) => match[2],
+    extractOriginalText: (match) => match[0]
+  },
+  {
+    name: "function_call",
+    pattern: /<function_call\s+name="([^"]+)"[^>]*>(.*?)<\/function_call>/gis,
+    extractToolId: (match) => match[1],
+    extractParams: (match) => match[2],
+    extractOriginalText: (match) => match[0]
+  },
+  {
+    name: "function_calls_invoke",
+    pattern: /<invoke\s+name="([^"]+)"[^>]*>(.*?)<\/invoke>/gis,
+    extractToolId: (match) => match[1],
+    extractParams: (match) => JSON.stringify(extractFunctionCallsParameters(match[2])),
+    extractOriginalText: (match) => match[0]
+  }
+];
+function matchAllToolCallings(responseText) {
+  const calls = [];
+  const parallel = /<parallel_tool_calls>/i.test(responseText);
+  try {
+    for (const toolPattern of toolPatterns) {
+      toolPattern.pattern.lastIndex = 0;
+      let match;
+      while ((match = toolPattern.pattern.exec(responseText)) !== null) {
+        calls.push({
+          found: true,
+          toolId: toolPattern.extractToolId(match),
+          parameters: parseToolParameters(toolPattern.extractParams(match)),
+          originalText: toolPattern.extractOriginalText(match)
+        });
+      }
+    }
+  } catch {
+  }
+  return { calls, parallel };
+}
+
+// src/storage/nextLamport.ts
+async function nextLamportClockForConversation(storage, conversationId) {
+  if (typeof storage.getMaxLamportClockForConversation === "function") {
+    const max2 = await storage.getMaxLamportClockForConversation(conversationId);
+    return max2 + 1;
+  }
+  const msgs = await storage.getMessages(conversationId, { mode: "full-content" });
+  let max = 0;
+  for (const m of msgs) {
+    if (typeof m.lamportClock === "number" && m.lamportClock > max) {
+      max = m.lamportClock;
+    }
+  }
+  return max + 1;
+}
+
+// src/loopAPI/hooks/registry.ts
+var HookRegistry = class {
+  hookRegistry = /* @__PURE__ */ new Map();
+  hookOrder = /* @__PURE__ */ new Map();
+  /**
+   * Register a hook handler for a specific lifecycle event.
+   */
+  registerHook(type, handler, name) {
+    const key = name ?? `hook:${Date.now().toString(36)}:${Math.random().toString(36).slice(2, 8)}`;
+    const handlers = this.hookOrder.get(type) ?? [];
+    handlers.push(handler);
+    this.hookOrder.set(type, handlers);
+    const map = this.hookRegistry.get(type) ?? /* @__PURE__ */ new Map();
+    map.set(key, handler);
+    this.hookRegistry.set(type, map);
+  }
+  /**
+   * Unregister a specific hook handler by name.
+   */
+  unregisterHook(type, name) {
+    const map = this.hookRegistry.get(type);
+    if (!map) return false;
+    const deleted = map.delete(name);
+    if (deleted) {
+      this.hookOrder.set(type, Array.from(map.values()));
+    }
+    return deleted;
+  }
+  /**
+   * Execute all registered hooks for a given type in registration order.
+   */
+  async executeHooks(type, context, data) {
+    const handlers = this.hookOrder.get(type);
+    if (!handlers || handlers.length === 0) {
+      return { allowed: true };
+    }
+    let currentData = data;
+    let mergedModified;
+    let permissionAction;
+    for (const handler of handlers) {
+      try {
+        const result = await handler(context, currentData);
+        if (result.modified) {
+          mergedModified = { ...mergedModified ?? {}, ...result.modified };
+          currentData = { ...currentData, ...result.modified };
+        }
+        if (result.permissionAction && result.permissionAction !== "allow") {
+          permissionAction = result.permissionAction;
+        }
+        if (!result.allowed) {
+          return {
+            ...result,
+            modified: mergedModified ?? result.modified,
+            permissionAction: permissionAction ?? result.permissionAction
+          };
+        }
+      } catch (error) {
+        return {
+          allowed: false,
+          reason: error instanceof Error ? error.message : "Hook execution failed",
+          modified: mergedModified,
+          permissionAction
+        };
+      }
+    }
+    const finalResult = { allowed: true };
+    if (mergedModified) finalResult.modified = mergedModified;
+    if (permissionAction) finalResult.permissionAction = permissionAction;
+    return finalResult;
+  }
+  /**
+   * Check if any hooks are registered for a given type.
+   */
+  hasHooks(type) {
+    const map = this.hookRegistry.get(type);
+    return map != null && map.size > 0;
+  }
+  /**
+   * Remove all registered hooks of all types.
+   */
+  clearHooks() {
+    this.hookRegistry.clear();
+    this.hookOrder.clear();
+  }
+  /**
+   * List all hook types that have at least one registered handler.
+   */
+  listRegisteredHookTypes() {
+    const types = [];
+    for (const [type, map] of this.hookRegistry) {
+      if (map.size > 0) {
+        types.push(type);
+      }
+    }
+    return types;
+  }
+  /**
+   * Get the count of registered handlers for a hook type.
+   */
+  getHookCount(type) {
+    const map = this.hookRegistry.get(type);
+    return map?.size ?? 0;
+  }
+};
+var defaultHookRegistry = new HookRegistry();
+async function executeHooks(type, context, data) {
+  return defaultHookRegistry.executeHooks(type, context, data);
+}
+function hasHooks(type) {
+  return defaultHookRegistry.hasHooks(type);
+}
+
+// src/loopAPI/agent-tool-loop/compaction.ts
+function countTurns(messages) {
+  let turns = 0;
+  for (const message of messages) {
+    if (message.role === "user") {
+      turns++;
+    }
+  }
+  return turns;
+}
+function estimateTokens(messages) {
+  let total = 0;
+  for (const message of messages) {
+    const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+    total += content.length / 3.5;
+  }
+  return Math.ceil(total);
+}
+function buildTruncationSummary(dropped, totalDropped) {
+  const turns = countTurns(dropped);
+  const oldest = dropped[0];
+  const newest = dropped[dropped.length - 1];
+  const oldestTime = oldest?.timestamp ? new Date(oldest.timestamp).toISOString() : "unknown";
+  const newestTime = newest?.timestamp ? new Date(newest.timestamp).toISOString() : "unknown";
+  return `[context-summary] ${totalDropped} earlier messages (${turns} turns, ${oldestTime} \u2192 ${newestTime}) were compacted. Key topics: see recent messages below.`;
+}
+function createSummaryMessage(conversationId, summaryText, baseMessage) {
+  return {
+    messageId: `${conversationId}:compacted:${Date.now().toString(36)}`,
+    conversationId,
+    originNodeId: baseMessage.originNodeId,
+    timestamp: Date.now(),
+    lamportClock: -1,
+    // Will be replaced by AgentToolLoop
+    role: "assistant",
+    content: summaryText,
+    metadata: { compacted: true }
+  };
+}
+function compactMessages(messages, options = {}) {
+  const recentTurnsToKeep = options.recentTurnsToKeep ?? 4;
+  if (messages.length <= recentTurnsToKeep * 2) {
+    return { messages, compacted: false, droppedCount: 0, summaryText: "" };
+  }
+  const userIndices = [];
+  for (let index = 0; index < messages.length; index++) {
+    if (messages[index].role === "user") {
+      userIndices.push(index);
+    }
+  }
+  if (userIndices.length <= recentTurnsToKeep) {
+    return { messages, compacted: false, droppedCount: 0, summaryText: "" };
+  }
+  const keepStartIndex = userIndices[userIndices.length - recentTurnsToKeep];
+  const dropped = messages.slice(0, keepStartIndex);
+  const kept = messages.slice(keepStartIndex);
+  if (dropped.length === 0) {
+    return { messages, compacted: false, droppedCount: 0, summaryText: "" };
+  }
+  const conversationId = messages[0]?.conversationId ?? "unknown";
+  const summaryText = buildTruncationSummary(dropped, dropped.length);
+  const summaryMessage = createSummaryMessage(conversationId, summaryText, messages[0]);
+  const compacted = [summaryMessage, ...kept];
+  return {
+    messages: compacted,
+    compacted: true,
+    droppedCount: dropped.length,
+    summaryText
+  };
+}
+function shouldCompact(messages, threshold) {
+  const t = threshold ?? 50;
+  return messages.length > t;
+}
+async function autoCompact(messages, options = {}) {
+  const recentTurnsToKeep = options.recentTurnsToKeep ?? 4;
+  if (options.maxTokens && options.maxTokens > 0) {
+    const currentTokens = estimateTokens(messages);
+    if (currentTokens <= options.maxTokens) {
+      return { messages, compacted: false, droppedCount: 0, summaryText: "" };
+    }
+  }
+  if (options.useLlmSummary !== false && options.llmProvider?.model != null) {
+    try {
+      const result = await llmCompact(messages, options.llmProvider, recentTurnsToKeep);
+      if (result) return result;
+    } catch {
+    }
+  }
+  return compactMessages(messages, { ...options });
+}
+async function llmCompact(messages, llmProvider, recentTurnsToKeep) {
+  const userIndices = [];
+  for (let index = 0; index < messages.length; index++) {
+    if (messages[index].role === "user") {
+      userIndices.push(index);
+    }
+  }
+  if (userIndices.length <= recentTurnsToKeep) {
+    return null;
+  }
+  const keepStartIndex = userIndices[userIndices.length - recentTurnsToKeep];
+  const toSummarize = messages.slice(0, keepStartIndex);
+  const kept = messages.slice(keepStartIndex);
+  if (toSummarize.length === 0) return null;
+  const conversationId = messages[0]?.conversationId ?? "unknown";
+  const conversationText = toSummarize.map((m) => {
+    const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+    const toolId = typeof m.metadata?.toolId === "string" ? m.metadata.toolId : "unknown";
+    const roleLabel = m.role === "tool" ? `[tool: ${toolId}]` : `[${m.role}]`;
+    if (m.role === "tool" && content.length > 500) {
+      return `${roleLabel} ${content.slice(0, 500)}... (truncated)`;
+    }
+    return `${roleLabel} ${content}`;
+  }).join("\n\n");
+  const prompt = `Summarize the following conversation excerpt. Be concise but capture key decisions, action items, tool calls, and important context. Focus on information useful for continuing the conversation.
+
+<conversation>
+${conversationText.slice(0, 8e3)}
+</conversation>
+
+Provide a brief summary (3-5 paragraphs) of the key points.`;
+  try {
+    const summaryText = await generateSummary(llmProvider, prompt);
+    if (!summaryText || summaryText.length < 10) return null;
+    const summaryMessage = createSummaryMessage(
+      conversationId,
+      `[context-summary] ${summaryText}`,
+      messages[0]
+    );
+    return {
+      messages: [summaryMessage, ...kept],
+      compacted: true,
+      droppedCount: toSummarize.length,
+      summaryText
+    };
+  } catch {
+    return null;
+  }
+}
+async function generateSummary(llmProvider, prompt) {
+  if (typeof llmProvider.chat !== "function") return null;
+  const raw = llmProvider.chat({ messages: [{ role: "user", content: prompt }] });
+  let resolved = raw;
+  if (resolved != null && typeof resolved.then === "function") {
+    resolved = await resolved;
+  }
+  if (resolved != null && typeof resolved[Symbol.asyncIterator] === "function") {
+    let text = "";
+    for await (const chunk of resolved) {
+      text += chunkToText(chunk);
+    }
+    return text || null;
+  }
+  if (typeof resolved === "string") return resolved;
+  return null;
+}
+function chunkToText(chunk) {
+  if (typeof chunk === "string") return chunk;
+  if (chunk != null && typeof chunk === "object" && "content" in chunk) {
+    const content = chunk.content;
+    return typeof content === "string" ? content : JSON.stringify(content);
+  }
+  return JSON.stringify(chunk);
+}
+
+// src/loopAPI/agent-tool-loop/historyCompaction.ts
+function compactHistory(history, options) {
+  const maxMessages = options?.contextCompaction?.maxMessages ?? 0;
+  if (maxMessages <= 0 || history.length <= maxMessages) return history;
+  const dropped = history.length - maxMessages;
+  const tail = history.slice(-maxMessages);
+  const summaryMessage = {
+    ...tail[0],
+    messageId: `${tail[0]?.conversationId ?? "unknown"}:summary:${Date.now().toString(36)}`,
+    role: "assistant",
+    content: `[context-summary] ${dropped} earlier messages were compacted.`
+  };
+  if (options?.contextCompaction?.replayLastUserMessage === false) return tail;
+  const lastUser = [...history].reverse().find((message) => message.role === "user");
+  if (!lastUser) return [summaryMessage, ...tail];
+  if (tail.some((message) => message.messageId === lastUser.messageId)) return tail;
+  return [summaryMessage, lastUser, ...tail];
+}
+function asChatMessages(value) {
+  if (!Array.isArray(value)) return void 0;
+  if (!value.every((message) => message != null && typeof message === "object")) return void 0;
+  return value;
+}
+function buildCompactedStep(conversationId, iteration, droppedCount, summaryText) {
+  return {
+    type: "thinking",
+    data: {
+      status: "compacted",
+      conversationId,
+      droppedCount: typeof droppedCount === "number" ? droppedCount : 0,
+      summaryText: typeof summaryText === "string" ? summaryText : "",
+      iteration
+    }
+  };
+}
+async function persistSummaryMessage(context, conversationId, summaryMessage) {
+  if (!summaryMessage) return;
+  const lamportSummary = await nextLamportClockForConversation(context.storage, conversationId);
+  await context.storage.appendMessage({
+    ...summaryMessage,
+    lamportClock: lamportSummary
+  });
+}
+async function maybeApplyContextCompactionHook(options) {
+  const { context, conversationId, iteration, history, agentToolLoopOptions } = options;
+  if (!hasHooks("ContextCompaction")) {
+    return { handled: false, history, steps: [] };
+  }
+  const hookResult = await executeHooks("ContextCompaction", context, {
+    conversationId,
+    iteration,
+    history,
+    autoCompact: agentToolLoopOptions?.autoCompact,
+    contextCompaction: agentToolLoopOptions?.contextCompaction
+  });
+  const modified = hookResult.modified;
+  const modifiedHistory = asChatMessages(modified?.history);
+  const nextHistory = modifiedHistory ?? history;
+  const skipDefault = !hookResult.allowed || modifiedHistory != null || modified?.skipDefault === true;
+  if (!skipDefault) {
+    return { handled: false, history: nextHistory, steps: [] };
+  }
+  const steps = modified?.compacted === true ? [buildCompactedStep(conversationId, iteration, modified.droppedCount, modified.summaryText)] : [];
+  if (modified?.persistSummaryMessage === true) {
+    await persistSummaryMessage(context, conversationId, nextHistory[0]);
+  }
+  return { handled: true, history: nextHistory, steps };
+}
+async function applyBuiltInAutoCompact(options) {
+  const { context, conversationId, iteration, agentToolLoopOptions } = options;
+  let history = options.history;
+  const autoCompactOptions = agentToolLoopOptions?.autoCompact;
+  if (!autoCompactOptions) {
+    return { history, steps: [] };
+  }
+  const threshold = autoCompactOptions.threshold ?? 50;
+  if (!shouldCompact(history, threshold)) {
+    return { history, steps: [] };
+  }
+  try {
+    const result = await autoCompact(history, {
+      recentTurnsToKeep: autoCompactOptions.recentTurnsToKeep ?? 4,
+      maxTokens: autoCompactOptions.maxTokens ?? 0,
+      llmProvider: context.llmProvider
+    });
+    if (!result.compacted) {
+      return { history, steps: [] };
+    }
+    history = result.messages;
+    await persistSummaryMessage(context, conversationId, result.messages[0]);
+    return {
+      history,
+      steps: [
+        buildCompactedStep(conversationId, iteration, result.droppedCount, result.summaryText)
+      ]
+    };
+  } catch (error) {
+    if (context.logger?.warn) {
+      context.logger.warn("[agentToolLoop] auto-compact failed:", error);
+    } else {
+      console.warn("[agentToolLoop] auto-compact failed:", error);
+    }
+    return { history, steps: [] };
+  }
+}
+async function prepareIterationHistory(options) {
+  const { agentToolLoopOptions } = options;
+  const hookResult = await maybeApplyContextCompactionHook({
+    ...options,
+    history: options.rawHistory
+  });
+  if (hookResult.handled) {
+    return hookResult;
+  }
+  const autoCompactResult = await applyBuiltInAutoCompact({
+    ...options,
+    history: hookResult.history
+  });
+  return {
+    history: compactHistory(autoCompactResult.history, agentToolLoopOptions),
+    steps: autoCompactResult.steps
+  };
+}
+
+// src/loopAPI/agent-tool-loop/llmStream.ts
+function isAsyncIterable(value) {
+  return value != null && typeof value[Symbol.asyncIterator] === "function";
+}
+function chunkToText2(chunk) {
+  if (typeof chunk === "string") return chunk;
+  if (chunk != null && typeof chunk === "object" && "content" in chunk) {
+    const content = chunk.content;
+    return typeof content === "string" ? content : JSON.stringify(content);
+  }
+  return JSON.stringify(chunk);
+}
+async function* streamLlm(context, request) {
+  const chatFunction = context.llmProvider.chat;
+  if (typeof chatFunction !== "function") {
+    throw new Error(
+      "LLM provider does not support legacy chat() method. Use AI SDK's streamText instead."
+    );
+  }
+  const raw = chatFunction(request);
+  let resolved = raw;
+  if (resolved != null && typeof resolved.then === "function") {
+    resolved = await resolved;
+  }
+  if (isAsyncIterable(resolved)) {
+    for await (const chunk of resolved) {
+      yield chunk;
+    }
+    return;
+  }
+  yield resolved;
+}
+
+// src/promptUtilities/promptConcat.ts
+function collectPromptSourcePaths(prompts, basePath = "agentFrameworkConfig.prompts") {
+  const out = {};
+  function walk(nodes, prefix) {
+    nodes.forEach((n, index) => {
+      const p = `${prefix}.${index}`;
+      if (n.id) {
+        out[n.id] = p;
+      }
+      if (n.children?.length) {
+        walk(n.children, `${p}.children`);
+      }
+    });
+  }
+  walk(prompts, basePath);
+  return out;
+}
+var logger = {
+  debug: (..._arguments) => {
+  },
+  info: (..._arguments) => {
+  },
+  warn: (..._arguments) => {
+  },
+  error: (..._arguments) => {
+  }
+};
+function flattenPrompts(prompts) {
+  const result = [];
+  function processPrompt(prompt) {
+    let text = prompt.text ?? "";
+    if (prompt.children) {
+      for (const child of prompt.children) {
+        if (!child.role) {
+          text += processPrompt(child);
+        }
+      }
+    }
+    return text;
+  }
+  function collectRolePrompts(nodes) {
+    for (const prompt of nodes) {
+      if (prompt.enabled === false) continue;
+      const content = processPrompt(prompt);
+      if (content.trim() || prompt.role) {
+        result.push({
+          role: prompt.role ?? "system",
+          content: content.trim()
+        });
+      }
+      if (prompt.children) {
+        collectRolePrompts(prompt.children);
+      }
+    }
+  }
+  collectRolePrompts(prompts);
+  return result;
+}
+async function* promptConcatStream(agentConfig, messages, agentFrameworkContext, options) {
+  const frameworkConfig = agentConfig.agentFrameworkConfig;
+  const promptConfigs = frameworkConfig?.prompts ?? [];
+  const plugins = frameworkConfig?.plugins ?? [];
+  const hooks = createAgentFrameworkHooks();
+  const pluginMap = resolvePromptPluginMap(agentFrameworkContext);
+  for (const plugin of plugins) {
+    const entry = pluginMap.get(plugin.toolId);
+    if (entry) entry(hooks);
+  }
+  let processedContext = { prompts: promptConfigs };
+  for (let index = 0; index < plugins.length; index++) {
+    const plugin = plugins[index];
+    processedContext = await runProcessPromptsHooks(hooks, {
+      prompts: processedContext.prompts,
+      messages,
+      toolConfig: plugin,
+      pluginIndex: index,
+      agentFrameworkContext
+    });
+  }
+  const processed = processedContext.prompts;
+  const flat = flattenPrompts(processed);
+  const last = messages[messages.length - 1];
+  if (last && last.role === "user") {
+    const content = last.content;
+    const fileMeta = last.metadata?.file;
+    if (fileMeta?.path && options?.readAttachmentFile) {
+      try {
+        const buf = await options.readAttachmentFile(fileMeta.path);
+        flat.push({
+          role: "user",
+          content: [
+            { type: "image", image: buf },
+            { type: "text", text: content }
+          ]
+        });
+      } catch (error) {
+        logger.error("failed to read attached file", { error, path: fileMeta.path });
+      }
+    } else if (fileMeta?.path && !options?.readAttachmentFile) {
+      flat.push({
+        role: "user",
+        content: `[attached path: ${fileMeta.path}]
+${content}`
+      });
+    } else {
+      flat.push({ role: "user", content });
+    }
+  }
+  const state = {
+    processedPrompts: processed,
+    flatPrompts: flat,
+    step: "complete",
+    isComplete: true,
+    sourcePaths: collectPromptSourcePaths(processed)
+  };
+  yield state;
+  return state;
+}
+
+// src/promptUtilities/utilities.ts
+function filterOldMessagesByDuration(messages, maxAgeMs, now = Date.now()) {
+  if (maxAgeMs <= 0) return messages;
+  const cutoff = now - maxAgeMs;
+  return messages.filter((m) => typeof m.timestamp === "number" && m.timestamp >= cutoff);
+}
+
+// src/loopAPI/agent-tool-loop/toolResultMessage.ts
+function formatToolResultMessage(toolName, parameters, body, isError) {
+  return `<functions_result>
+Tool: ${toolName}
+Parameters: ${JSON.stringify(parameters)}
+${isError ? "Error" : "Result"}: ${body}
+</functions_result>`;
+}
+
+// src/loopAPI/agent-tool-loop/modelMessages.ts
+function chatMessageToModelMessage(message) {
+  const role = message.role === "agent" || message.role === "error" ? "assistant" : message.role === "tool" ? "tool" : message.role === "user" ? "user" : "assistant";
+  if (role === "tool") {
+    const toolResults = getChatMessageParts(message).filter(isToolResultPart);
+    if (toolResults.length > 0) {
+      return {
+        role,
+        content: toolResults.map(
+          (part) => formatToolResultMessage(
+            part.toolName,
+            part.parameters && typeof part.parameters === "object" ? part.parameters : {},
+            part.result,
+            part.isError === true
+          )
+        ).join("\n\n")
+      };
+    }
+  }
+  return {
+    role,
+    content: message.content
+  };
+}
+async function resolveAgentDefinitionModel(context, definitionId) {
+  if (context.resolveAgentDefinition) {
+    return context.resolveAgentDefinition(definitionId);
+  }
+  return context.storage.getAgentDefinition(definitionId);
+}
+async function inferDefinitionId(storage, conversationId) {
+  try {
+    const meta = await storage.getConversationMeta(conversationId);
+    if (meta?.definitionId) return meta.definitionId;
+  } catch {
+  }
+  const parts = conversationId.split(":");
+  if (parts.length >= 2) {
+    return parts.slice(0, -1).join(":");
+  }
+  return conversationId;
+}
+async function buildLlmMessages(context, conversationId, history) {
+  const definitionId = await inferDefinitionId(context.storage, conversationId);
+  const definition = await resolveAgentDefinitionModel(context, definitionId);
+  const fw = definition?.agentFrameworkConfig;
+  const maxHistoryAgeMs = context.agentToolLoop?.maxHistoryAgeMs ?? 0;
+  const historyForPrompt = maxHistoryAgeMs > 0 ? filterOldMessagesByDuration(history, maxHistoryAgeMs) : history;
+  if (fw?.prompts && Array.isArray(fw.prompts) && fw.prompts.length > 0) {
+    const readAttachmentFile = context.agentToolLoop?.readAttachmentFile;
+    const gen = promptConcatStream(
+      {
+        agentFrameworkConfig: {
+          prompts: fw.prompts,
+          plugins: fw.plugins ?? [],
+          response: []
+        }
+      },
+      historyForPrompt,
+      context,
+      readAttachmentFile ? { readAttachmentFile } : void 0
+    );
+    let lastFlat = [];
+    for await (const state of gen) {
+      lastFlat = state.flatPrompts;
+    }
+    const withoutTrailingUser = lastFlat.length > 0 && lastFlat[lastFlat.length - 1]?.role === "user" ? lastFlat.slice(0, -1) : lastFlat;
+    return [...withoutTrailingUser, ...historyForPrompt.map(chatMessageToModelMessage)];
+  }
+  const systemText = typeof definition?.systemPrompt === "string" ? definition.systemPrompt.trim() : "";
+  if (systemText.length > 0) {
+    return [
+      { role: "system", content: systemText },
+      ...historyForPrompt.map(chatMessageToModelMessage)
+    ];
+  }
+  return historyForPrompt.map(chatMessageToModelMessage);
+}
+
+// src/orchestration/drivers/unknownEffect.ts
+var DEFAULT_MAX_ATTEMPTS = 3;
+function attemptsOf(operation) {
+  return operation.status?.attempts ?? 0;
+}
+function maxAttemptsOf(operation) {
+  return operation.spec.retry?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+}
+function reconcileUnknownEffect(operation, evidence) {
+  if (evidence.resultObserved) {
+    return { action: "succeeded", reason: "result was observed before the disconnect; only the ack was lost" };
+  }
+  if (operation.spec.retry?.nonRetryable) {
+    return { action: "manual-intervention", reason: "operation is marked nonRetryable and its effect is unknown" };
+  }
+  const attempts = attemptsOf(operation);
+  const maxAttempts = maxAttemptsOf(operation);
+  const withinBudget = attempts < maxAttempts;
+  if (operation.spec.effect === "read") {
+    if (withinBudget) {
+      return { action: "retry", reason: `read effect has no side effects (attempt ${attempts + 1}/${maxAttempts})` };
+    }
+    return { action: "verification-required", reason: `read retry budget exhausted (${attempts}/${maxAttempts})` };
+  }
+  if (operation.spec.idempotencyKey) {
+    if (withinBudget) {
+      return {
+        action: "retry",
+        reason: `idempotencyKey deduplicates repeated delivery (attempt ${attempts + 1}/${maxAttempts})`
+      };
+    }
+    return {
+      action: "verification-required",
+      reason: `idempotent retry budget exhausted (${attempts}/${maxAttempts}); verify before further attempts`
+    };
+  }
+  return {
+    action: "verification-required",
+    reason: `effect '${operation.spec.effect}' without idempotencyKey must be verified before any retry`
+  };
+}
+
+// src/orchestration/errors.ts
+var OrchestrationError = class extends Error {
+  code;
+  retryable;
+  retryAfterMs;
+  reason;
+  details;
+  constructor(data) {
+    super(data.message);
+    this.name = "OrchestrationError";
+    this.code = data.code;
+    this.retryable = data.retryable;
+    this.retryAfterMs = data.retryAfterMs;
+    this.reason = data.reason;
+    this.details = data.details;
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      retryable: this.retryable,
+      retryAfterMs: this.retryAfterMs,
+      reason: this.reason,
+      details: this.details
+    };
+  }
+};
+
+// src/orchestration/resources.ts
+var TOOL_OPERATION_API_VERSION = "execution.memeloop.io/v1alpha1";
+var TOOL_OPERATION_KIND = "ToolOperation";
+function createToolOperationManifest(name, spec) {
+  return {
+    apiVersion: TOOL_OPERATION_API_VERSION,
+    kind: TOOL_OPERATION_KIND,
+    metadata: { name },
+    spec
+  };
+}
+
+// src/tools/structuredToolResult.ts
+var MEMELOOP_STRUCTURED_TOOL_KEY = "__memeloopToolResult";
+function truncateToolSummary(s, max = 2e3) {
+  if (s.length <= max) return s;
+  return `${s.slice(0, max - 3)}...`;
+}
+function extractMemeloopStructuredToolPayload(raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  const o = raw;
+  const payload = o[MEMELOOP_STRUCTURED_TOOL_KEY];
+  if (payload === null || typeof payload !== "object") return null;
+  const p = payload;
+  if (typeof p.summary !== "string" || p.summary.length === 0) return null;
+  const awaitSessionId = typeof p.awaitSessionId === "string" && p.awaitSessionId.length > 0 ? p.awaitSessionId : void 0;
+  return {
+    summary: p.summary,
+    detailRef: p.detailRef,
+    awaitSessionId
+  };
+}
+
+// src/loopAPI/agent-tool-loop/toolCallRunner.ts
+var TOOL_OPERATION_DEFAULT_TIMEOUT_MS = 6e4;
+var TOOL_OPERATION_POLL_INTERVAL_MS = 250;
+var toolOperationCounter = 0;
+var toolResultMessageCounter = 0;
+function isTerminalToolOperationPhase(phase) {
+  return phase === "Completed" || phase === "Failed" || phase === "Cancelled";
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "undefined";
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`);
+  return `{${entries.join(",")}}`;
+}
+function fnv1aHex(input) {
+  let hash = 2166136261;
+  for (let index = 0; index < input.length; index += 1) {
+    hash = Math.imul(hash ^ input.charCodeAt(index), 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function isTransientGetError(error) {
+  return error instanceof OrchestrationError && (error.code === "UNAVAILABLE" || error.code === "TIMEOUT" || error.code === "INTERNAL");
+}
+async function waitForToolOperationTerminal(client, reference, timeoutMs, applied) {
+  const deadline = Date.now() + timeoutMs;
+  let last = applied ?? null;
+  while (Date.now() < deadline) {
+    let resource;
+    try {
+      resource = await client.get(reference);
+    } catch (error) {
+      if (!isTransientGetError(error)) throw error;
+      const basis = last ?? applied;
+      if (!basis) throw error;
+      const decision = reconcileUnknownEffect(basis, { resultObserved: false });
+      if (decision.action === "retry") {
+      } else {
+        throw new Error(
+          `ToolOperation ${reference.name ?? "<unknown>"} effect unknown after transport failure: ${decision.action} \u2014 ${decision.reason}`
+        );
+      }
+    }
+    if (resource) {
+      last = resource;
+      if (isTerminalToolOperationPhase(last.status?.phase)) {
+        return last;
+      }
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, TOOL_OPERATION_POLL_INTERVAL_MS);
+    });
+  }
+  if (last) {
+    return last;
+  }
+  throw new Error(`ToolOperation ${reference.name ?? "<unknown>"} was not observed before timeout`);
+}
+function toolOperationRow(resource) {
+  const status = resource.status;
+  if (status?.phase === "Completed") {
+    const value = status.result?.value;
+    if (value != null && typeof value === "object") {
+      const structured = extractMemeloopStructuredToolPayload(value);
+      if (structured) {
+        return {
+          text: structured.summary,
+          isError: false,
+          detailRef: structured.detailRef,
+          awaitSessionId: structured.awaitSessionId
+        };
+      }
+      if ("error" in value && typeof value.error === "string") {
+        return { text: value.error, isError: true };
+      }
+      if ("result" in value && value.result != null) {
+        return {
+          text: typeof value.result === "string" ? value.result : JSON.stringify(value.result),
+          payload: typeof value.result === "string" ? void 0 : value.result,
+          isError: false
+        };
+      }
+    }
+    return { text: typeof value === "string" ? value : JSON.stringify(value), isError: false };
+  }
+  if (status?.phase === "Failed" || status?.phase === "Cancelled") {
+    return {
+      text: status.result?.error?.message ?? `ToolOperation ${status.phase}`,
+      isError: true
+    };
+  }
+  return {
+    text: `ToolOperation did not reach a terminal phase (last phase: ${status?.phase ?? "unknown"})`,
+    isError: true
+  };
+}
+async function executeToolOperation(context, conversationId, call, occurrence) {
+  const client = context.orchestration;
+  if (!client) return null;
+  try {
+    const caps = await client.getCapabilities();
+    if (!caps.resourceKinds.includes(TOOL_OPERATION_KIND) || !caps.operations.includes("apply") || !caps.operations.includes("get")) {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  const timeoutMs = context.agentToolLoop?.toolOperationTimeoutMs ?? TOOL_OPERATION_DEFAULT_TIMEOUT_MS;
+  const idempotencyKey = `${conversationId}:${fnv1aHex(stableStringify({
+    toolId: call.toolId,
+    parameters: call.parameters
+  }))}:${occurrence}`;
+  toolOperationCounter += 1;
+  const operation = createToolOperationManifest(
+    `${call.toolId}-${Date.now().toString(36)}-${toolOperationCounter.toString(36)}`,
+    {
+      toolRef: { kind: "BuiltinTool", name: call.toolId },
+      effect: context.tools.getToolEffect?.(call.toolId) ?? "execute",
+      arguments: call.parameters,
+      idempotencyKey,
+      timeoutMs,
+      policy: { auditLevel: "metadata" }
+    }
+  );
+  try {
+    const applied = await client.apply(operation);
+    if (applied.apiVersion !== TOOL_OPERATION_API_VERSION || applied.kind !== TOOL_OPERATION_KIND) {
+      return { text: "ToolOperation apply returned an unexpected resource kind", isError: true };
+    }
+    let resource = applied;
+    if (!isTerminalToolOperationPhase(resource.status?.phase)) {
+      const reference = {
+        apiVersion: applied.apiVersion,
+        kind: applied.kind,
+        name: applied.metadata.name,
+        namespace: applied.metadata.namespace
+      };
+      resource = await waitForToolOperationTerminal(client, reference, timeoutMs, resource);
+    }
+    return toolOperationRow(resource);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { text: `ToolOperation execution error: ${message}`, isError: true };
+  }
+}
+async function executeRegistryTool(context, toolId, parameters) {
+  const normalizedId = toolId.includes("-") ? toolId.replace(/-([a-z])/g, (_m, c) => c.toUpperCase()) : toolId;
+  const impl = context.tools.getTool(toolId) ?? context.tools.getTool(normalizedId);
+  if (typeof impl !== "function") {
+    return {
+      text: `No tool registered for "${toolId}".`,
+      isError: true
+    };
+  }
+  try {
+    const raw = await impl(parameters);
+    if (raw != null && typeof raw === "object") {
+      const o = raw;
+      if (typeof o.error === "string" && o.error.length > 0) {
+        return { text: o.error, isError: true };
+      }
+      if ("result" in o) {
+        return {
+          text: typeof o.result === "string" ? o.result : JSON.stringify(o.result),
+          payload: typeof o.result === "string" ? void 0 : o.result,
+          isError: false
+        };
+      }
+      const structured = extractMemeloopStructuredToolPayload(raw);
+      if (structured) {
+        return {
+          text: structured.summary,
+          isError: false,
+          detailRef: structured.detailRef,
+          awaitSessionId: structured.awaitSessionId
+        };
+      }
+    }
+    return { text: typeof raw === "string" ? raw : JSON.stringify(raw), isError: false };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (context.logger?.warn) {
+      context.logger.warn("[agentToolLoop] tool execution error", toolId, message);
+    } else {
+      console.warn("[agentToolLoop] tool execution error", toolId, message);
+    }
+    return { text: message, isError: true };
+  }
+}
+async function executeWithGuards(context, options, conversationId, recentToolCalls, call) {
+  const parameterParseError = call.parameters[TOOL_PARAMETER_PARSE_ERROR_KEY];
+  if (typeof parameterParseError === "string") {
+    return { text: parameterParseError, isError: true };
+  }
+  const signature = `${call.toolId}:${JSON.stringify(call.parameters)}`;
+  recentToolCalls.push(signature);
+  const threshold = Math.max(2, options?.doomLoopThreshold ?? 3);
+  const last = recentToolCalls.slice(-threshold);
+  if (last.length === threshold && last.every((x) => x === signature)) {
+    return { text: "Blocked by doom-loop guard", isError: true };
+  }
+  const occurrence = recentToolCalls.filter((entry) => entry === signature).length;
+  const row = await executeToolOperation(context, conversationId, call, occurrence) ?? await executeRegistryTool(context, call.toolId, call.parameters);
+  if (hasHooks("PostToolUse")) {
+    await executeHooks("PostToolUse", context, {
+      toolId: call.toolId,
+      parameters: call.parameters,
+      result: row.text,
+      isError: row.isError,
+      conversationId
+    });
+  }
+  return row;
+}
+async function persistToolResult(context, conversationId, call, row) {
+  toolResultMessageCounter += 1;
+  const lamportTool = await nextLamportClockForConversation(context.storage, conversationId);
+  await context.storage.appendMessage(createChatMessage({
+    // Counter suffix keeps message identity unique for identical calls within
+    // the same millisecond (parallel tools or fast consecutive rounds).
+    messageId: `${conversationId}:t:${call.toolId}:${Date.now().toString(36)}:${toolResultMessageCounter.toString(36)}`,
+    conversationId,
+    originNodeId: "local",
+    lamportClock: lamportTool,
+    role: "tool",
+    parts: [{
+      type: "tool-result",
+      toolName: call.toolId,
+      parameters: call.parameters,
+      result: row.text,
+      isError: row.isError,
+      payload: row.payload,
+      detailRef: row.detailRef
+    }],
+    detailRef: row.detailRef,
+    metadata: {
+      isToolResult: true,
+      isError: row.isError,
+      toolId: call.toolId,
+      toolParameters: call.parameters
+    }
+  }));
+}
+async function persistTerminalAwaitCompletion(context, options, conversationId, call, row) {
+  const sid = row.awaitSessionId;
+  const wait = options?.waitForTerminalSession;
+  if (!sid || !wait || row.isError) return;
+  const done = await wait(sid);
+  const lamportTool = await nextLamportClockForConversation(context.storage, conversationId);
+  const body = truncateToolSummary(
+    `[terminal.await done] session=${sid}
+exitCode: ${done.exitCode ?? "null"}
+---
+${done.truncatedOutput}`
+  );
+  await context.storage.appendMessage(createChatMessage({
+    messageId: `${conversationId}:t:${call.toolId}:await:${Date.now().toString(36)}:${toolResultMessageCounter.toString(36)}`,
+    conversationId,
+    originNodeId: "local",
+    lamportClock: lamportTool,
+    role: "tool",
+    parts: [{
+      type: "tool-result",
+      toolName: call.toolId,
+      parameters: call.parameters,
+      result: body,
+      detailRef: row.detailRef ? { ...row.detailRef, exitCode: done.exitCode ?? row.detailRef.exitCode } : void 0
+    }],
+    detailRef: row.detailRef ? { ...row.detailRef, exitCode: done.exitCode ?? row.detailRef.exitCode } : void 0,
+    metadata: {
+      isToolResult: true,
+      toolId: call.toolId,
+      toolParameters: call.parameters,
+      awaitSessionId: sid
+    }
+  }));
+}
+function toolStep(row, parallel) {
+  return {
+    type: "tool",
+    data: {
+      toolId: row.call.toolId,
+      parameters: row.call.parameters,
+      parallel,
+      result: row.text,
+      isError: row.isError
+    }
+  };
+}
+async function* runRegistryToolCalls(options) {
+  const { context, agentToolLoopOptions, conversationId, calls, parallel, recentToolCalls } = options;
+  if (parallel) {
+    const results = await Promise.all(
+      calls.map(
+        async (call) => ({
+          call,
+          ...await executeWithGuards(
+            context,
+            agentToolLoopOptions,
+            conversationId,
+            recentToolCalls,
+            call
+          )
+        })
+      )
+    );
+    for (const row of results) {
+      yield toolStep(row, true);
+    }
+    for (const row of results) {
+      await persistToolResult(context, conversationId, row.call, row);
+    }
+    for (const row of results) {
+      await persistTerminalAwaitCompletion(
+        context,
+        agentToolLoopOptions,
+        conversationId,
+        row.call,
+        row
+      );
+    }
+    return;
+  }
+  for (const call of calls) {
+    const row = await executeWithGuards(
+      context,
+      agentToolLoopOptions,
+      conversationId,
+      recentToolCalls,
+      call
+    );
+    yield toolStep({ call, ...row }, false);
+    await persistToolResult(context, conversationId, call, row);
+    await persistTerminalAwaitCompletion(context, agentToolLoopOptions, conversationId, call, row);
+  }
+}
+
+// src/permission/engine.ts
+function matchPattern(toolName, pattern) {
+  if (pattern === toolName) return true;
+  if (pattern === "*") return true;
+  const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\*/g, ".*");
+  return new RegExp(`^${escaped}$`).test(toolName);
+}
+function mergePermissionSets(sets) {
+  const merged = /* @__PURE__ */ new Map();
+  merged.set("allow", /* @__PURE__ */ new Map());
+  merged.set("deny", /* @__PURE__ */ new Map());
+  merged.set("ask", /* @__PURE__ */ new Map());
+  for (const set of sets) {
+    for (const rule of set.rules) {
+      for (const [action, map] of merged) {
+        if (action !== rule.action) {
+          map.delete(rule.toolPattern);
+        }
+      }
+      merged.get(rule.action).set(rule.toolPattern, rule.action);
+    }
+  }
+  return {
+    allow: [...merged.get("allow").keys()],
+    deny: [...merged.get("deny").keys()],
+    ask: [...merged.get("ask").keys()]
+  };
+}
+function checkPermission(toolName, merged) {
+  const isWildcard = (p) => p.includes("*");
+  for (const pattern of merged.deny) {
+    if (!isWildcard(pattern) && matchPattern(toolName, pattern)) return "deny";
+  }
+  for (const pattern of merged.ask) {
+    if (!isWildcard(pattern) && matchPattern(toolName, pattern)) return "ask";
+  }
+  for (const pattern of merged.allow) {
+    if (!isWildcard(pattern) && matchPattern(toolName, pattern)) return "allow";
+  }
+  for (const pattern of merged.deny) {
+    if (isWildcard(pattern) && matchPattern(toolName, pattern)) return "deny";
+  }
+  for (const pattern of merged.ask) {
+    if (isWildcard(pattern) && matchPattern(toolName, pattern)) return "ask";
+  }
+  for (const pattern of merged.allow) {
+    if (isWildcard(pattern) && matchPattern(toolName, pattern)) return "allow";
+  }
+  const hasAnyRules = merged.allow.length > 0 || merged.deny.length > 0 || merged.ask.length > 0;
+  return hasAnyRules ? "deny" : "allow";
+}
+
+// src/orchestration/security/admission.ts
+function defaultPermissionActionForTrustClass(trustClass) {
+  return trustClass === "restricted" || trustClass === "quarantine" ? "deny" : "allow";
+}
+
+// src/tools/approval.ts
+var pendingApprovals = /* @__PURE__ */ new Map();
+var approvalListeners = /* @__PURE__ */ new Set();
+function requestApproval(request, timeoutMs = 6e4) {
+  return new Promise((resolve) => {
+    pendingApprovals.set(request.approvalId, { request, resolve });
+    for (const listener of approvalListeners) {
+      try {
+        listener(request);
+      } catch {
+      }
+    }
+    if (timeoutMs > 0) {
+      setTimeout(() => {
+        if (pendingApprovals.has(request.approvalId)) {
+          pendingApprovals.delete(request.approvalId);
+          resolve("deny");
+        }
+      }, timeoutMs);
+    }
+  });
+}
+
+// src/loopAPI/agent-tool-loop/toolUseGate.ts
+function buildLayeredPermissions(options, definitionId, userSet) {
+  const globalPerms = options?.toolPermissions;
+  const sets = [];
+  if (globalPerms?.default) {
+    sets.push({
+      source: "default",
+      rules: [{ toolPattern: "*", action: globalPerms.default }]
+    });
+  }
+  const scoped = globalPerms?.perAgent?.[definitionId];
+  if (scoped) {
+    if (scoped.default) {
+      sets.push({
+        source: `agent:${definitionId}:default`,
+        rules: [{ toolPattern: "*", action: scoped.default }]
+      });
+    }
+    if (scoped.rules && scoped.rules.length > 0) {
+      sets.push({
+        source: `agent:${definitionId}`,
+        rules: scoped.rules.map((r) => ({ toolPattern: r.pattern, action: r.action }))
+      });
+    }
+  }
+  if (userSet && userSet.rules.length > 0) {
+    sets.push(userSet);
+  }
+  if (globalPerms?.rules && globalPerms.rules.length > 0) {
+    sets.push({
+      source: "session",
+      rules: globalPerms.rules.map((r) => ({ toolPattern: r.pattern, action: r.action }))
+    });
+  }
+  if (!sets.some((s) => s.rules.some((r) => r.toolPattern === "*"))) {
+    sets.unshift({
+      source: "implied-default",
+      rules: [{ toolPattern: "*", action: defaultPermissionActionForTrustClass(options?.trustClass) }]
+    });
+  }
+  return mergePermissionSets(sets);
+}
+function createPermissionPreToolUseHook(options, definitionId, userSet) {
+  const mergedPermissions = buildLayeredPermissions(options, definitionId, userSet);
+  return async (_context, data) => {
+    const toolId = typeof data.toolId === "string" ? data.toolId : "";
+    const action = checkPermission(toolId, mergedPermissions);
+    if (action === "allow") {
+      return { allowed: true, permissionAction: "allow" };
+    }
+    return {
+      allowed: true,
+      permissionAction: action,
+      reason: action === "deny" ? "Denied by tool permission" : void 0
+    };
+  };
+}
+function applyModifiedCall(call, modified) {
+  if (!modified) return call;
+  const toolId = typeof modified.toolId === "string" ? modified.toolId : call.toolId;
+  const parameters = modified.parameters != null && typeof modified.parameters === "object" ? modified.parameters : call.parameters;
+  return { ...call, toolId, parameters };
+}
+function normalizePreToolUseResult(result) {
+  if (!result.allowed) {
+    return { action: "deny", reason: result.reason ?? "Blocked by PreToolUse hook" };
+  }
+  if (result.permissionAction === "ask" || result.permissionAction === "deny") {
+    return { action: result.permissionAction, reason: result.reason };
+  }
+  return { action: "allow", reason: result.reason };
+}
+async function persistDeniedToolResult(context, conversationId, call, errorText) {
+  const lamportTool = await nextLamportClockForConversation(context.storage, conversationId);
+  await context.storage.appendMessage(createChatMessage({
+    messageId: `${conversationId}:t:${call.toolId}:${Date.now().toString(36)}`,
+    conversationId,
+    originNodeId: "local",
+    lamportClock: lamportTool,
+    role: "tool",
+    parts: [{
+      type: "tool-result",
+      toolName: call.toolId,
+      parameters: call.parameters,
+      result: errorText,
+      isError: true
+    }],
+    metadata: {
+      isToolResult: true,
+      isError: true,
+      toolId: call.toolId,
+      toolParameters: call.parameters
+    }
+  }));
+}
+async function* resolveAskAction(conversationId, call) {
+  yield {
+    type: "permission_request",
+    data: { tool: call.toolId, args: call.parameters }
+  };
+  const decision = await requestApproval(
+    {
+      approvalId: `${conversationId}:${Date.now().toString(36)}:${call.toolId}`,
+      agentId: conversationId,
+      toolName: call.toolId,
+      parameters: call.parameters,
+      created: /* @__PURE__ */ new Date()
+    },
+    6e4
+  );
+  return decision === "allow" ? "allow" : "deny";
+}
+async function runPreToolUseHook(context, data) {
+  if (!hasHooks("PreToolUse")) return { allowed: true };
+  return executeHooks("PreToolUse", context, data);
+}
+async function* gateToolCallsWithPreToolUse(context, options, definitionId, conversationId, calls) {
+  const permissionHook = createPermissionPreToolUseHook(options, definitionId);
+  const allowedCalls = [];
+  for (const originalCall of calls) {
+    let call = originalCall;
+    const permissionResult = await permissionHook(context, {
+      toolId: call.toolId,
+      parameters: call.parameters,
+      conversationId
+    });
+    call = applyModifiedCall(call, permissionResult.modified);
+    let { action, reason } = normalizePreToolUseResult(permissionResult);
+    if (action === "ask") {
+      action = yield* resolveAskAction(conversationId, call);
+      reason = action === "deny" ? "Tool approval denied or timed out" : reason;
+    }
+    if (action === "deny") {
+      const errorText = reason ?? "Denied by tool permission";
+      yield {
+        type: "tool",
+        data: {
+          toolId: call.toolId,
+          parameters: call.parameters,
+          parallel: false,
+          result: errorText,
+          isError: true
+        }
+      };
+      await persistDeniedToolResult(context, conversationId, call, errorText);
+      continue;
+    }
+    const hookResult = await runPreToolUseHook(context, {
+      toolId: call.toolId,
+      parameters: call.parameters,
+      conversationId
+    });
+    call = applyModifiedCall(call, hookResult.modified);
+    ({ action, reason } = normalizePreToolUseResult(hookResult));
+    if (action === "ask") {
+      action = yield* resolveAskAction(conversationId, call);
+      reason = action === "deny" ? "Tool approval denied or timed out" : reason;
+    }
+    if (action === "deny") {
+      const errorText = reason ?? "Blocked by PreToolUse hook";
+      yield {
+        type: "tool",
+        data: {
+          toolId: call.toolId,
+          parameters: call.parameters,
+          parallel: false,
+          result: errorText,
+          isError: true
+        }
+      };
+      await persistDeniedToolResult(context, conversationId, call, errorText);
+      continue;
+    }
+    allowedCalls.push(call);
+  }
+  return allowedCalls;
+}
+
+// src/loopAPI/agent-tool-loop/turnPrimitives.ts
+var DEFAULT_MAX_ITERATIONS = 256;
+function toolCallHandledInAgentMessages(agentMessages, assistantContent, call) {
+  let assistantIndex = -1;
+  for (let index = agentMessages.length - 1; index >= 0; index -= 1) {
+    const message = agentMessages[index];
+    if (message.role === "assistant" && message.content === assistantContent) {
+      assistantIndex = index;
+      break;
+    }
+  }
+  if (assistantIndex < 0) return false;
+  const after = agentMessages.slice(assistantIndex + 1);
+  return after.some(
+    (message) => message.role === "tool" && (message.metadata?.toolId === call.toolId || typeof message.content === "string" && message.content.includes(`Tool: ${call.toolId}`))
+  );
+}
+function resolveMaxIterations(context) {
+  const configured = context.agentToolLoop?.maxIterations;
+  return configured != null && configured > 0 ? configured : DEFAULT_MAX_ITERATIONS;
+}
+function pluginToolCallSignature(calls) {
+  return calls.map((call) => `${call.toolId}:${JSON.stringify(call.parameters)}`).join("|");
+}
+async function blockRepeatedPluginToolCalls(context, input, state, calls, hookContext) {
+  if (calls.length === 0) return { blocked: false };
+  const signature = pluginToolCallSignature(calls);
+  state.recentToolCalls.push(signature);
+  const threshold = Math.max(2, context.agentToolLoop?.doomLoopThreshold ?? 3);
+  const last = state.recentToolCalls.slice(-threshold);
+  if (last.length !== threshold || !last.every((entry) => entry === signature)) {
+    return { blocked: false };
+  }
+  const message = `Blocked by doom-loop guard: the model repeated the same tool call ${threshold} times. Change the arguments or approach before trying again.`;
+  const firstCall = calls[0];
+  const lamportClock = await nextLamportClockForConversation(
+    context.storage,
+    input.conversationId
+  );
+  const toolMessage = createChatMessage({
+    messageId: `${input.conversationId}:t:doom-loop:${state.iteration}:${Date.now().toString(36)}`,
+    conversationId: input.conversationId,
+    originNodeId: "local",
+    lamportClock,
+    role: "tool",
+    parts: [{
+      type: "tool-result",
+      toolName: firstCall.toolId,
+      parameters: firstCall.parameters,
+      result: message,
+      isError: true
+    }],
+    metadata: {
+      isToolResult: true,
+      isError: true,
+      toolId: firstCall.toolId,
+      toolParameters: firstCall.parameters,
+      doomLoopBlocked: true
+    }
+  });
+  hookContext.agent.messages.push(toolMessage);
+  await context.storage.appendMessage(toolMessage);
+  return { blocked: true, message };
+}
+function createAgentToolLoopState(context) {
+  return {
+    iteration: 0,
+    maxIterations: resolveMaxIterations(context),
+    recentToolCalls: [],
+    agentStarted: false,
+    agentStopped: false
+  };
+}
+function markAgentToolLoopStop(state, reason) {
+  state.stopReason ??= reason;
+}
+function finishAgentToolLoopThinking(state, reason, data) {
+  markAgentToolLoopStop(state, reason);
+  return { type: "thinking", data };
+}
+async function startAgentToolLoopTurn(context, input, state) {
+  const now = Date.now();
+  const lamportClock = await nextLamportClockForConversation(
+    context.storage,
+    input.conversationId
+  );
+  const hostUserMessage = input.userMessage;
+  const userMessage = context.normalizeMessage?.({
+    ...hostUserMessage,
+    messageId: hostUserMessage?.messageId ?? `${input.conversationId}:${now.toString(36)}`,
+    conversationId: input.conversationId,
+    originNodeId: hostUserMessage?.originNodeId ?? "local",
+    timestamp: hostUserMessage?.timestamp ?? now,
+    lamportClock: hostUserMessage?.lamportClock ?? lamportClock,
+    role: "user",
+    content: hostUserMessage?.content ?? input.message
+  }) ?? {
+    ...hostUserMessage,
+    messageId: hostUserMessage?.messageId ?? `${input.conversationId}:${now.toString(36)}`,
+    conversationId: input.conversationId,
+    originNodeId: hostUserMessage?.originNodeId ?? "local",
+    timestamp: hostUserMessage?.timestamp ?? now,
+    lamportClock: hostUserMessage?.lamportClock ?? lamportClock,
+    role: "user",
+    content: hostUserMessage?.content ?? input.message
+  };
+  if (input.resumeSession && input.resumeSession.length > 0) {
+    await context.storage.insertMessagesIfAbsent(input.resumeSession);
+  }
+  await context.storage.appendMessage(userMessage);
+  if (hasHooks("UserPromptSubmit")) {
+    const hookResult = await executeHooks("UserPromptSubmit", context, {
+      message: input.message,
+      conversationId: input.conversationId
+    });
+    if (!hookResult.allowed) {
+      return {
+        action: "stop",
+        step: {
+          type: "thinking",
+          data: {
+            status: "blocked",
+            conversationId: input.conversationId,
+            reason: hookResult.reason ?? "Blocked by UserPromptSubmit hook"
+          }
+        }
+      };
+    }
+  }
+  const initialDefinitionId = await inferDefinitionId(context.storage, input.conversationId);
+  if (hasHooks("AgentStart")) {
+    const hookResult = await executeHooks("AgentStart", context, {
+      conversationId: input.conversationId,
+      definitionId: initialDefinitionId
+    });
+    if (!hookResult.allowed) {
+      return {
+        action: "stop",
+        step: {
+          type: "thinking",
+          data: {
+            status: "blocked",
+            conversationId: input.conversationId,
+            reason: hookResult.reason ?? "Blocked by AgentStart hook"
+          }
+        }
+      };
+    }
+  }
+  state.agentStarted = true;
+  return { action: "continue" };
+}
+async function* runAgentToolLoopIteration(context, input, state) {
+  const options = context.agentToolLoop ?? {};
+  const enableToolLoop = options.enableToolLoop !== false;
+  const fallbackRegistry = options.fallbackRegistryTools !== false;
+  const checkpointOptions = options.sessionCheckpoint;
+  if (state.iteration >= state.maxIterations) {
+    yield finishAgentToolLoopThinking(state, "max-iterations", {
+      status: "max-iterations",
+      conversationId: input.conversationId,
+      maxIterations: state.maxIterations
+    });
+    return { action: "stop", reason: "max-iterations" };
+  }
+  state.iteration += 1;
+  const iteration = state.iteration;
+  if (options.isCancelled?.(input.conversationId)) {
+    yield finishAgentToolLoopThinking(state, "cancelled", {
+      status: "cancelled",
+      conversationId: input.conversationId
+    });
+    return { action: "stop", reason: "cancelled" };
+  }
+  const rawHistory = await context.storage.getMessages(input.conversationId, {
+    mode: "full-content"
+  });
+  const { history, steps: compactionSteps } = await prepareIterationHistory({
+    context,
+    conversationId: input.conversationId,
+    iteration,
+    rawHistory,
+    agentToolLoopOptions: options
+  });
+  for (const step of compactionSteps) {
+    yield step;
+  }
+  const runtimeAgent = context.resolveAgentRuntimeView ? await context.resolveAgentRuntimeView(input.conversationId, history) : { id: input.conversationId, messages: history };
+  const hookContext = {
+    ...context,
+    agent: runtimeAgent,
+    persistAgentMessage: async (message) => {
+      await context.storage.appendMessage(message);
+    }
+  };
+  yield {
+    type: "thinking",
+    data: {
+      status: "calling-llm",
+      conversationId: input.conversationId,
+      messageCount: history.length,
+      iteration
+    }
+  };
+  const messages = await buildLlmMessages(hookContext, input.conversationId, history);
+  const request = { conversationId: input.conversationId, messages };
+  const assistantMessageId = `${input.conversationId}:a:${iteration}:${Date.now().toString(36)}`;
+  const assistantLamportClock = await nextLamportClockForConversation(
+    context.storage,
+    input.conversationId
+  );
+  const buildAssistantMessage = (content) => context.normalizeMessage?.({
+    messageId: assistantMessageId,
+    conversationId: input.conversationId,
+    originNodeId: "local",
+    timestamp: Date.now(),
+    lamportClock: assistantLamportClock,
+    role: "assistant",
+    content
+  }) ?? {
+    messageId: assistantMessageId,
+    conversationId: input.conversationId,
+    originNodeId: "local",
+    timestamp: Date.now(),
+    lamportClock: assistantLamportClock,
+    role: "assistant",
+    content
+  };
+  const updateAssistantView = (message) => {
+    const existingIndex = hookContext.agent.messages.findIndex(
+      (item) => item.messageId === message.messageId
+    );
+    if (existingIndex >= 0) {
+      hookContext.agent.messages[existingIndex] = message;
+    } else {
+      hookContext.agent.messages.push(message);
+    }
+  };
+  let assistantText = "";
+  for await (const chunk of streamLlm(context, request)) {
+    assistantText += chunkToText2(chunk);
+    const transientAssistantMessage = buildAssistantMessage(assistantText);
+    updateAssistantView(transientAssistantMessage);
+    try {
+      await context.onTransientMessage?.(transientAssistantMessage);
+    } catch (error) {
+      context.logger?.warn?.("[agentToolLoop] transient message subscriber failed:", error);
+    }
+    yield { type: "message", data: chunk };
+  }
+  const definitionId = await inferDefinitionId(context.storage, input.conversationId);
+  const agentDefinition = await resolveAgentDefinitionModel(context, definitionId);
+  const frameworkConfig = agentDefinition?.agentFrameworkConfig;
+  const hasPlugins = Boolean(
+    frameworkConfig?.plugins && Array.isArray(frameworkConfig.plugins) && frameworkConfig.plugins.length > 0
+  );
+  const assistantMessage = buildAssistantMessage(assistantText);
+  updateAssistantView(assistantMessage);
+  await hookContext.persistAgentMessage?.(assistantMessage);
+  const { calls, parallel } = matchAllToolCallings(assistantText);
+  if (hasPlugins && frameworkConfig) {
+    const doomLoop = await blockRepeatedPluginToolCalls(
+      context,
+      input,
+      state,
+      calls,
+      hookContext
+    );
+    if (doomLoop.blocked) {
+      yield {
+        type: "tool",
+        data: {
+          toolId: calls[0].toolId,
+          parameters: calls[0].parameters,
+          parallel,
+          result: doomLoop.message,
+          isError: true
+        }
+      };
+      yield finishAgentToolLoopThinking(state, "error", {
+        status: "blocked",
+        conversationId: input.conversationId,
+        reason: doomLoop.message
+      });
+      return { action: "stop", reason: "error" };
+    }
+    const { hooks } = await createHooksWithPlugins(
+      frameworkConfig,
+      {
+        pluginRegistry: resolvePromptPluginMap(context)
+      }
+    );
+    const responseCompletePayload = {
+      agentFrameworkContext: hookContext,
+      response: { status: "done", content: assistantText },
+      agentFrameworkConfig: frameworkConfig,
+      requestId: void 0,
+      toolConfig: { id: "_memeloop", toolId: "_memeloop" },
+      actions: {}
+    };
+    await runResponseCompleteHooks(hooks, responseCompletePayload);
+    await context.storage.insertMessagesIfAbsent(hookContext.agent.messages);
+    const postProcess = await responseConcat(
+      frameworkConfig,
+      assistantText,
+      hookContext,
+      hookContext.agent.messages
+    );
+    const yieldTarget = responseCompletePayload.actions?.yieldNextRoundTo ?? postProcess.yieldNextRoundTo;
+    if (yieldTarget === "human") {
+      yield finishAgentToolLoopThinking(state, "completed", {
+        status: "input-required",
+        conversationId: input.conversationId
+      });
+      return { action: "stop", reason: "completed" };
+    }
+    if (yieldTarget === "self") {
+      return { action: "continue" };
+    }
+  }
+  if (calls.length === 0) {
+    markAgentToolLoopStop(state, "completed");
+    return { action: "stop", reason: "completed" };
+  }
+  if (!enableToolLoop) {
+    markAgentToolLoopStop(state, "completed");
+    return { action: "stop", reason: "completed" };
+  }
+  const pending = calls.filter(
+    (call) => !toolCallHandledInAgentMessages(hookContext.agent.messages, assistantText, call)
+  );
+  if (pending.length === 0) {
+    if (hasPlugins && calls.length > 0) {
+      return { action: "continue" };
+    }
+    markAgentToolLoopStop(state, "completed");
+    return { action: "stop", reason: "completed" };
+  }
+  if (!fallbackRegistry && hasPlugins) {
+    return { action: "continue" };
+  }
+  const allowedCalls = yield* gateToolCallsWithPreToolUse(
+    context,
+    options,
+    definitionId,
+    input.conversationId,
+    pending
+  );
+  if (allowedCalls.length === 0) {
+    return { action: "continue" };
+  }
+  yield* runRegistryToolCalls({
+    context,
+    agentToolLoopOptions: options,
+    conversationId: input.conversationId,
+    calls: allowedCalls,
+    parallel,
+    recentToolCalls: state.recentToolCalls
+  });
+  if (checkpointOptions?.enabled) {
+    const checkpointStore = checkpointOptions.store;
+    if (!checkpointStore) {
+      if (context.logger?.warn) {
+        context.logger.warn("[agentToolLoop] checkpoint enabled without a checkpoint store");
+      } else {
+        console.warn("[agentToolLoop] checkpoint enabled without a checkpoint store");
+      }
+      return { action: "continue" };
+    }
+    try {
+      const allMessages = await context.storage.getMessages(input.conversationId, {
+        mode: "full-content"
+      });
+      await checkpointStore.saveCheckpoint(input.conversationId, allMessages);
+    } catch (error) {
+      if (context.logger?.warn) {
+        context.logger.warn("[agentToolLoop] checkpoint save failed:", error);
+      } else {
+        console.warn("[agentToolLoop] checkpoint save failed:", error);
+      }
+    }
+  }
+  return { action: "continue" };
+}
+async function stopAgentToolLoopTurn(context, input, state, reason) {
+  if (reason) markAgentToolLoopStop(state, reason);
+  if (state.agentStarted && !state.agentStopped && state.stopReason && hasHooks("AgentStop")) {
+    state.agentStopped = true;
+    await executeHooks("AgentStop", context, {
+      conversationId: input.conversationId,
+      reason: state.stopReason
+    });
+  }
+}
+
+// src/loopAPI/agent-tool-loop/directRunner.ts
+function createAgentToolLoopRunner(context) {
+  return async function* agentToolLoopRunner(input) {
+    const state = createAgentToolLoopState(context);
+    try {
+      const start = await startAgentToolLoopTurn(context, input, state);
+      if (start.step) yield start.step;
+      if (start.action === "stop") return;
+      while (true) {
+        const result = yield* runAgentToolLoopIteration(context, input, state);
+        if (result.action === "stop") return;
+      }
+    } catch (error) {
+      await stopAgentToolLoopTurn(context, input, state, "error");
+      throw error;
+    } finally {
+      await stopAgentToolLoopTurn(context, input, state);
+    }
+  };
+}
+
+// src/loopAPI/agent-tool-loop/runner.ts
+function resolveAgentToolLoopTerminalState(step, current) {
+  if (step.type !== "thinking") return current;
+  const data = step.data;
+  if (data.status === "input-required") return "input-required";
+  if (data.status === "cancelled") return "canceled";
+  if (data.status === "max-iterations") return "completed";
+  if (data.status === "blocked") return "failed";
+  if (data.status === "calling-llm") return "working";
+  return current;
+}
+async function runAgentToolLoopTurn(context, input, callbacks = {}) {
+  const agentToolLoop = callbacks.agentToolLoop ?? createAgentToolLoopRunner(context);
+  let terminalState = "completed";
+  let stepCount = 0;
+  for await (const step of agentToolLoop(input)) {
+    stepCount += 1;
+    terminalState = resolveAgentToolLoopTerminalState(step, terminalState);
+    await callbacks.onStep?.(step);
+    if (step.type === "thinking" && step.data && typeof step.data === "object") {
+      const data = step.data;
+      const status = data.status;
+      if (typeof status === "string") {
+        await callbacks.onProgress?.(status, data, step);
+      }
+    }
+  }
+  return {
+    state: terminalState === "working" || terminalState === "submitted" ? "completed" : terminalState,
+    stepCount
+  };
+}
+
+// src/loopProfiles/builtinProfileSources.ts
+var builtinProfileSources = {
+  "code-assistant": [
+    "{",
+    '  "id": "memeloop:code-assistant",',
+    '  "name": "\u4EE3\u7801\u52A9\u624B",',
+    '  "description": "\u4E13\u6CE8\u4E8E\u4EE3\u7801\u7F16\u5199\u3001\u91CD\u6784\u548C\u8C03\u8BD5\u7684\u52A9\u624B\u3002",',
+    '  "loopId": "agent-tool-loop",',
+    '  "systemPrompt": "You are a senior software engineer helping the user write and refactor code.",',
+    '  "tools": [',
+    '    "workspacesList",',
+    '    "modelContextProtocol",',
+    '    "spawnAgent",',
+    '    "askQuestion",',
+    '    "getErrors",',
+    '    "webFetch"',
+    "  ],",
+    '  "plugins": [',
+    '    { "id": "builtin:mcp-client" },',
+    '    { "id": "builtin:mcp-forward" },',
+    '    { "id": "builtin:spawn-agent" },',
+    '    { "id": "builtin:ask-question" }',
+    "  ],",
+    '  "agentTools": [',
+    "    {",
+    '      "toolId": "workspacesList",',
+    '      "parameters": {',
+    '        "workspacesListParam": { "targetId": "builtin-system", "position": "after" }',
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "modelContextProtocol",',
+    '      "parameters": {',
+    '        "modelContextProtocolParam": {',
+    '          "serverUrl": "http://127.0.0.1:38385/mcp",',
+    '          "timeoutSecond": 30,',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" },',
+    '          "toolResultDuration": 1',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "spawnAgent",',
+    '      "parameters": {',
+    '        "spawnAgentParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" },',
+    '          "toolResultDuration": 2,',
+    '          "defaultTimeoutMs": 120000',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "askQuestion",',
+    '      "parameters": {',
+    '        "askQuestionParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" }',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "getErrors",',
+    '      "parameters": {',
+    '        "getErrorsParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" }',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "webFetch",',
+    '      "parameters": {',
+    '        "webFetchParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" },',
+    '          "toolResultDuration": 1',
+    "        }",
+    "      }",
+    "    }",
+    "  ],",
+    '  "agentFrameworkConfig": {',
+    '    "prompts": [',
+    "      {",
+    '        "id": "builtin-system",',
+    '        "role": "system",',
+    '        "text": "You are a senior software engineer helping the user write and refactor code. Prefer small, safe edits; use file.read and file.search before changing code; use terminal.execute for build/tests when appropriate."',
+    "      }",
+    "    ],",
+    '    "plugins": [{ "toolId": "fullReplacement" }],',
+    '    "response": []',
+    "  },",
+    '  "modelConfig": {',
+    '    "provider": "memeloop",',
+    '    "model": "claude-opus-4.6",',
+    '    "temperature": 0.2,',
+    '    "maxTokens": 4096',
+    "  },",
+    '  "version": "1.0.0"',
+    "}",
+    ""
+  ].join("\n"),
+  "frontend-ui-ux": [
+    "{",
+    '  "id": "memeloop:frontend-ui-ux",',
+    '  "name": "Frontend UI/UX",',
+    '  "description": "Designer-turned-developer who crafts stunning UI/UX even without design mockups.",',
+    '  "loopId": "agent-tool-loop",',
+    '  "systemPrompt": "You are a designer-turned-developer who crafts stunning UI/UX even without design mockups.\\n\\nWhen working on frontend tasks:\\n- Prioritize visual polish and user experience above all else\\n- Use consistent spacing, typography, and color schemes\\n- Apply modern design patterns: rounded corners, subtle shadows, smooth transitions\\n- Ensure responsive design across mobile, tablet, and desktop breakpoints\\n- Prefer accessible patterns: semantic HTML, ARIA labels, keyboard navigation\\n- Optimize for perceived performance: skeleton loaders, optimistic updates, progressive enhancement\\n- Use component composition over monolithic layouts\\n- Match the existing design system when extending an existing UI",',
+    '  "tools": [',
+    '    "workspacesList",',
+    '    "wikiSearch",',
+    '    "wikiOperation",',
+    '    "modelContextProtocol",',
+    '    "spawnAgent",',
+    '    "askQuestion",',
+    '    "webFetch"',
+    "  ],",
+    '  "plugins": [',
+    '    { "id": "builtin:mcp-client" },',
+    '    { "id": "builtin:mcp-forward" },',
+    '    { "id": "builtin:spawn-agent" },',
+    '    { "id": "builtin:ask-question" }',
+    "  ],",
+    '  "agentTools": [',
+    "    {",
+    '      "toolId": "workspacesList",',
+    '      "parameters": {',
+    '        "workspacesListParam": { "targetId": "builtin-system", "position": "after" }',
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "wikiSearch",',
+    '      "parameters": {',
+    '        "wikiSearchParam": {',
+    '          "sourceType": "wiki",',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" },',
+    '          "toolResultDuration": 1',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "wikiOperation",',
+    '      "parameters": {',
+    '        "wikiOperationParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" },',
+    '          "toolResultDuration": 1',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "modelContextProtocol",',
+    '      "parameters": {',
+    '        "modelContextProtocolParam": {',
+    '          "serverUrl": "http://127.0.0.1:38385/mcp",',
+    '          "timeoutSecond": 30,',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" },',
+    '          "toolResultDuration": 1',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "spawnAgent",',
+    '      "parameters": {',
+    '        "spawnAgentParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" },',
+    '          "toolResultDuration": 2,',
+    '          "defaultTimeoutMs": 120000',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "askQuestion",',
+    '      "parameters": {',
+    '        "askQuestionParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" }',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "webFetch",',
+    '      "parameters": {',
+    '        "webFetchParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" },',
+    '          "toolResultDuration": 1',
+    "        }",
+    "      }",
+    "    }",
+    "  ],",
+    '  "agentFrameworkConfig": {',
+    '    "prompts": [',
+    "      {",
+    '        "id": "builtin-system",',
+    '        "role": "system",',
+    '        "text": "You are a designer-turned-developer who crafts stunning UI/UX even without design mockups.\\n\\nWhen working on frontend tasks:\\n- Prioritize visual polish and user experience above all else\\n- Use consistent spacing, typography, and color schemes\\n- Apply modern design patterns: rounded corners, subtle shadows, smooth transitions\\n- Ensure responsive design across mobile, tablet, and desktop breakpoints\\n- Prefer accessible patterns: semantic HTML, ARIA labels, keyboard navigation\\n- Optimize for perceived performance: skeleton loaders, optimistic updates, progressive enhancement\\n- Use component composition over monolithic layouts\\n- Match the existing design system when extending an existing UI"',
+    "      }",
+    "    ],",
+    '    "plugins": [],',
+    '    "response": []',
+    "  },",
+    '  "modelConfig": {',
+    '    "provider": "memeloop",',
+    '    "model": "claude-opus-4.6",',
+    '    "temperature": 0.3,',
+    '    "maxTokens": 4096',
+    "  },",
+    '  "version": "1.0.0"',
+    "}",
+    ""
+  ].join("\n"),
+  "general-assistant": [
+    "{",
+    '  "id": "memeloop:general-assistant",',
+    '  "name": "\u901A\u7528\u52A9\u624B",',
+    '  "description": "\u53EF\u9760\u7684\u901A\u7528\u667A\u80FD\u4F53\uFF0C\u7528\u4E8E\u5BF9\u8BDD\u3001Wiki \u77E5\u8BC6\u5DE5\u4F5C\u3001\u76EE\u6807\u63A8\u8FDB\u548C\u65E5\u5E38\u8BA1\u7B97\u673A\u64CD\u4F5C\u3002",',
+    '  "loopId": "agent-tool-loop",',
+    `  "systemPrompt": "You are MemeLoop, a reliable general-purpose agent for conversation, knowledge work, goal completion, and everyday computer tasks.\\n\\nOperating contract:\\n- Treat the user request as the active goal. For a task with three or more meaningful steps, use the planning tool actually listed in the tool instructions (for example manage-todo or todoWrite) to create a short plan, keep exactly one item in progress, and update it as work advances. Continue until the goal is achieved or genuinely blocked.\\n- Use tools for actions and for facts that must be read from the user's environment. Never claim that an action succeeded without a successful tool result. Never invent search results, file contents, counts, or completion evidence.\\n- Use the exact tool name and parameter schema shown in the tool list. When calling a tool, output ONLY one tool call in this exact XML format:\\n<tool_use name=\\"TOOL_NAME\\">{\\"param\\":\\"value\\"}</tool_use>\\n  The JSON must be valid. Never wrap the call in markdown or add text before or after it. After the tool result, reassess the goal and continue.\\n- If a tool fails, read the error and change the arguments or approach. Do not repeat an identical failed call more than once, and do not retry the same approach more than twice.\\n- For Wiki work, use an injected available workspace name or ID; do not guess one. Search before relying on stored knowledge. For wiki-search, exact-title filter syntax is [title[Exact Title]], tag syntax is [tag[Tag]], and semantic search uses searchType \\"vector\\" with query. A filter search uses searchType \\"filter\\" with filter. After a write, verify important content with a valid exact-title search. If verification fails, report that honestly.\\n- Save durable facts, decisions, plans, and user-requested memories to Wiki when useful. Do not store credentials or other sensitive data unless the user explicitly asks.\\n- For UI or computer actions, inspect the current state before acting, prefer reversible changes, verify the resulting state, and ask before destructive actions or consequential external communication.\\n- Do not ask for confirmation before an explicitly requested reversible action when the target is already known. Ask a concise question only when missing information materially changes the result. Otherwise make safe, explicit assumptions and proceed.\\n- In the final response, lead with the outcome, cite concrete verification, and state any remaining limitation briefly.",`,
+    '  "tools": [',
+    '    "workspacesList",',
+    '    "wikiSearch",',
+    '    "wikiOperation",',
+    '    "modelContextProtocol",',
+    '    "spawnAgent",',
+    '    "askQuestion"',
+    "  ],",
+    '  "plugins": [',
+    '    { "id": "builtin:mcp-client" },',
+    '    { "id": "builtin:mcp-forward" },',
+    '    { "id": "builtin:spawn-agent" },',
+    '    { "id": "builtin:ask-question" },',
+    '    { "id": "builtin:todo-write" }',
+    "  ],",
+    '  "agentTools": [',
+    "    {",
+    '      "toolId": "workspacesList",',
+    '      "parameters": {',
+    '        "workspacesListParam": { "targetId": "builtin-system", "position": "after" }',
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "wikiSearch",',
+    '      "parameters": {',
+    '        "wikiSearchParam": {',
+    '          "sourceType": "wiki",',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" },',
+    '          "toolResultDuration": 1',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "wikiOperation",',
+    '      "parameters": {',
+    '        "wikiOperationParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" },',
+    '          "toolResultDuration": 1',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "modelContextProtocol",',
+    '      "parameters": {',
+    '        "modelContextProtocolParam": {',
+    '          "serverUrl": "http://127.0.0.1:38385/mcp",',
+    '          "timeoutSecond": 30,',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" },',
+    '          "toolResultDuration": 1',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "spawnAgent",',
+    '      "parameters": {',
+    '        "spawnAgentParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" },',
+    '          "toolResultDuration": 2,',
+    '          "defaultTimeoutMs": 120000',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "askQuestion",',
+    '      "parameters": {',
+    '        "askQuestionParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" }',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "todo",',
+    '      "parameters": {',
+    '        "todoParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" },',
+    '          "todoInjectionTargetId": "builtin-system",',
+    '          "toolResultDuration": 1',
+    "        }",
+    "      }",
+    "    }",
+    "  ],",
+    '  "agentFrameworkConfig": {',
+    '    "prompts": [',
+    "      {",
+    '        "id": "builtin-system",',
+    '        "role": "system",',
+    `        "text": "You are MemeLoop, a reliable general-purpose agent for conversation, knowledge work, goal completion, and everyday computer tasks.\\n\\nOperating contract:\\n- Treat the user request as the active goal. For a task with three or more meaningful steps, use the planning tool actually listed in the tool instructions (for example manage-todo or todoWrite) to create a short plan, keep exactly one item in progress, and update it as work advances. Continue until the goal is achieved or genuinely blocked.\\n- Use tools for actions and for facts that must be read from the user's environment. Never claim that an action succeeded without a successful tool result. Never invent search results, file contents, counts, or completion evidence.\\n- Use the exact tool name and parameter schema shown in the tool list. When calling a tool, output ONLY one tool call in this exact XML format:\\n<tool_use name=\\"TOOL_NAME\\">{\\"param\\":\\"value\\"}</tool_use>\\n  The JSON must be valid. Never wrap the call in markdown or add text before or after it. After the tool result, reassess the goal and continue.\\n- If a tool fails, read the error and change the arguments or approach. Do not repeat an identical failed call more than once, and do not retry the same approach more than twice.\\n- For Wiki work, use an injected available workspace name or ID; do not guess one. Search before relying on stored knowledge. For wiki-search, exact-title filter syntax is [title[Exact Title]], tag syntax is [tag[Tag]], and semantic search uses searchType \\"vector\\" with query. A filter search uses searchType \\"filter\\" with filter. After a write, verify important content with a valid exact-title search. If verification fails, report that honestly.\\n- Save durable facts, decisions, plans, and user-requested memories to Wiki when useful. Do not store credentials or other sensitive data unless the user explicitly asks.\\n- For UI or computer actions, inspect the current state before acting, prefer reversible changes, verify the resulting state, and ask before destructive actions or consequential external communication.\\n- Do not ask for confirmation before an explicitly requested reversible action when the target is already known. Ask a concise question only when missing information materially changes the result. Otherwise make safe, explicit assumptions and proceed.\\n- In the final response, lead with the outcome, cite concrete verification, and state any remaining limitation briefly."`,
+    "      }",
+    "    ],",
+    '    "plugins": [{ "toolId": "fullReplacement" }],',
+    '    "response": []',
+    "  },",
+    '  "modelConfig": {',
+    '    "provider": "memeloop",',
+    '    "model": "claude-opus-4.6",',
+    '    "temperature": 0.5,',
+    '    "maxTokens": 4096',
+    "  },",
+    '  "version": "1.1.0"',
+    "}",
+    ""
+  ].join("\n"),
+  "git-master": [
+    "{",
+    '  "id": "memeloop:git-master",',
+    '  "name": "Git Master",',
+    '  "description": "Expert git workflow management with safety-first approach.",',
+    '  "loopId": "agent-tool-loop",',
+    '  "systemPrompt": "You are an expert in git workflow management. Follow these rules:\\n\\nGit Safety Protocol:\\n- NEVER update the git config\\n- NEVER run destructive/irreversible git commands (push --force, hard reset, etc.) unless the user explicitly requests them\\n- NEVER skip hooks (--no-verify, --no-gpg-sign, etc.) unless the user explicitly requests it\\n- NEVER force push to main/master; warn the user if they request it\\n- Avoid git commit --amend. ONLY use --amend when ALL conditions are met:\\n  (1) User explicitly requested amend, OR the commit succeeded and pre-commit hooks auto-modified files that need including\\n  (2) HEAD commit was created by you in this conversation\\n  (3) Commit has NOT been pushed to remote\\n- If commit FAILED or was REJECTED by hook, NEVER amend \u2014 fix the issue and create a NEW commit\\n- If you already pushed to remote, NEVER amend unless user explicitly requests it (requires force push)\\n\\nCommitting:\\n- NEVER commit changes unless the user explicitly asks\\n- Run: git status, git diff, git log (recent commits)\\n- Analyze all staged changes and draft a concise commit message\\n- Summarize nature of changes: add/update/fix/refactor/test/docs\\n- Do NOT commit files that likely contain secrets\\n\\nPull Requests:\\n- Check branch status, divergence from base, full commit history\\n- Create PR with descriptive title and summary body\\n- Return the PR URL when done",',
+    '  "tools": ["workspacesList", "git", "askQuestion"],',
+    '  "plugins": [{ "id": "builtin:ask-question" }],',
+    '  "agentTools": [',
+    "    {",
+    '      "toolId": "workspacesList",',
+    '      "parameters": {',
+    '        "workspacesListParam": { "targetId": "builtin-system", "position": "after" }',
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "git",',
+    '      "parameters": {',
+    '        "gitParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" }',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "askQuestion",',
+    '      "parameters": {',
+    '        "askQuestionParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" }',
+    "        }",
+    "      }",
+    "    }",
+    "  ],",
+    '  "agentFrameworkConfig": {',
+    '    "prompts": [',
+    "      {",
+    '        "id": "builtin-system",',
+    '        "role": "system",',
+    '        "text": "You are an expert in git workflow management. Follow these rules:\\n\\nGit Safety Protocol:\\n- NEVER update the git config\\n- NEVER run destructive/irreversible git commands (push --force, hard reset, etc.) unless the user explicitly requests them\\n- NEVER skip hooks (--no-verify, --no-gpg-sign, etc.) unless the user explicitly requests it\\n- NEVER force push to main/master; warn the user if they request it\\n- Avoid git commit --amend. ONLY use --amend when ALL conditions are met:\\n  (1) User explicitly requested amend, OR the commit succeeded and pre-commit hooks auto-modified files that need including\\n  (2) HEAD commit was created by you in this conversation\\n  (3) Commit has NOT been pushed to remote\\n- If commit FAILED or was REJECTED by hook, NEVER amend \u2014 fix the issue and create a NEW commit\\n- If you already pushed to remote, NEVER amend unless user explicitly requests it (requires force push)\\n\\nCommitting:\\n- NEVER commit changes unless the user explicitly asks\\n- Run: git status, git diff, git log (recent commits)\\n- Analyze all staged changes and draft a concise commit message\\n- Summarize nature of changes: add/update/fix/refactor/test/docs\\n- Do NOT commit files that likely contain secrets\\n\\nPull Requests:\\n- Check branch status, divergence from base, full commit history\\n- Create PR with descriptive title and summary body\\n- Return the PR URL when done"',
+    "      }",
+    "    ],",
+    '    "plugins": [],',
+    '    "response": []',
+    "  },",
+    '  "modelConfig": {',
+    '    "provider": "memeloop",',
+    '    "model": "claude-opus-4.6",',
+    '    "temperature": 0.2,',
+    '    "maxTokens": 4096',
+    "  },",
+    '  "version": "1.0.0"',
+    "}",
+    ""
+  ].join("\n"),
+  playwright: [
+    "{",
+    '  "id": "memeloop:playwright",',
+    '  "name": "Playwright",',
+    '  "description": "Browser automation via Playwright for verification, browsing, information gathering, web scraping, testing, and screenshots.",',
+    '  "loopId": "agent-tool-loop",',
+    '  "systemPrompt": "You have access to Playwright for browser automation. Use it for:\\n\\nBrowser Automation:\\n- Navigate to URLs and verify page content\\n- Fill forms, click buttons, and interact with page elements\\n- Take screenshots of specific elements or full pages\\n- Extract data from web pages (scraping)\\n- Test web application functionality end-to-end\\n- Automate browser workflows\\n- Log into websites and maintain sessions\\n\\nBest Practices:\\n- Use specific selectors (data-testid, id, or unique CSS selectors) over fragile XPath\\n- Wait for elements to be visible before interacting\\n- Handle page navigation and loading states explicitly\\n- Take screenshots at key steps for debugging\\n- Clean up browser resources when done\\n- Handle timeouts and error states gracefully\\n\\nAvailable Playwright MCP Tools:\\n- browser_navigate: Navigate to a URL\\n- browser_click: Click an element\\n- browser_type: Type into an input field\\n- browser_snapshot: Take accessibility snapshot of page\\n- browser_take_screenshot: Capture screenshot\\n- browser_fill_form: Fill multiple form fields at once\\n- browser_evaluate: Execute JavaScript in page context\\n- browser_select_option: Select from dropdown\\n- browser_drag: Drag and drop elements\\n- browser_hover: Hover over an element\\n- browser_press_key: Press a keyboard key\\n- browser_handle_dialog: Handle browser dialogs (alert/confirm/prompt)\\n- browser_close: Close the browser",',
+    '  "tools": ["modelContextProtocol", "askQuestion"],',
+    '  "plugins": [',
+    '    { "id": "builtin:mcp-client" },',
+    '    { "id": "builtin:mcp-forward" },',
+    '    { "id": "builtin:ask-question" }',
+    "  ],",
+    '  "agentTools": [',
+    "    {",
+    '      "toolId": "modelContextProtocol",',
+    '      "parameters": {',
+    '        "modelContextProtocolParam": {',
+    '          "serverUrl": "http://127.0.0.1:38385/mcp",',
+    '          "timeoutSecond": 30,',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" },',
+    '          "toolResultDuration": 1',
+    "        }",
+    "      }",
+    "    },",
+    "    {",
+    '      "toolId": "askQuestion",',
+    '      "parameters": {',
+    '        "askQuestionParam": {',
+    '          "toolListPosition": { "targetId": "builtin-system", "position": "after" }',
+    "        }",
+    "      }",
+    "    }",
+    "  ],",
+    '  "agentFrameworkConfig": {',
+    '    "prompts": [',
+    "      {",
+    '        "id": "builtin-system",',
+    '        "role": "system",',
+    '        "text": "You have access to Playwright for browser automation. Use it for:\\n\\nBrowser Automation:\\n- Navigate to URLs and verify page content\\n- Fill forms, click buttons, and interact with page elements\\n- Take screenshots of specific elements or full pages\\n- Extract data from web pages (scraping)\\n- Test web application functionality end-to-end\\n- Automate browser workflows\\n- Log into websites and maintain sessions\\n\\nBest Practices:\\n- Use specific selectors (data-testid, id, or unique CSS selectors) over fragile XPath\\n- Wait for elements to be visible before interacting\\n- Handle page navigation and loading states explicitly\\n- Take screenshots at key steps for debugging\\n- Clean up browser resources when done\\n- Handle timeouts and error states gracefully\\n\\nAvailable Playwright MCP Tools:\\n- browser_navigate: Navigate to a URL\\n- browser_click: Click an element\\n- browser_type: Type into an input field\\n- browser_snapshot: Take accessibility snapshot of page\\n- browser_take_screenshot: Capture screenshot\\n- browser_fill_form: Fill multiple form fields at once\\n- browser_evaluate: Execute JavaScript in page context\\n- browser_select_option: Select from dropdown\\n- browser_drag: Drag and drop elements\\n- browser_hover: Hover over an element\\n- browser_press_key: Press a keyboard key\\n- browser_handle_dialog: Handle browser dialogs (alert/confirm/prompt)\\n- browser_close: Close the browser"',
+    "      }",
+    "    ],",
+    '    "plugins": [],',
+    '    "response": []',
+    "  },",
+    '  "modelConfig": {',
+    '    "provider": "memeloop",',
+    '    "model": "claude-opus-4.6",',
+    '    "temperature": 0.3,',
+    '    "maxTokens": 4096',
+    "  },",
+    '  "version": "1.0.0"',
+    "}",
+    ""
+  ].join("\n")
+};
+
+// src/loopProfiles/loadBuiltins.ts
+function loadProfile(name) {
+  const source = builtinProfileSources[name];
+  if (!source) {
+    throw new Error(`Builtin profile not found: ${name}`);
+  }
+  return JSON.parse(source);
+}
+function getBuiltinLoopProfiles() {
+  return [
+    loadProfile("general-assistant"),
+    loadProfile("code-assistant"),
+    loadProfile("frontend-ui-ux"),
+    loadProfile("git-master"),
+    loadProfile("playwright")
+  ];
+}
+function getBuiltinLoopProfile(id) {
+  return getBuiltinLoopProfiles().find((p) => p.id === id);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFetchLLMProvider,
+  getBuiltinLoopProfile,
+  getBuiltinLoopProfiles,
+  resolveAgentToolLoopTerminalState,
+  runAgentToolLoopTurn
+});
+//# sourceMappingURL=mobile.cjs.map