memeloop 0.0.1 → 0.1.0

package/dist/chunk-QFHAAIIM.js

@@ -0,0 +1,2657 @@
+import {
+  createChatMessage,
+  getChatMessageParts,
+  isToolResultPart
+} from "./chunk-WAI6BODI.js";
+import {
+  TOOL_OPERATION_API_VERSION,
+  TOOL_OPERATION_KIND,
+  createToolOperationManifest
+} from "./chunk-BGPU4RR7.js";
+import {
+  OrchestrationError
+} from "./chunk-FWSY5HOA.js";
+
+// 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 defaultAdmissionPolicyForTrustClass(trustClass) {
+  switch (trustClass) {
+    case "restricted":
+    case "quarantine":
+      return { defaultAction: "deny", rules: [] };
+    default:
+      return { defaultAction: "allow", rules: [] };
+  }
+}
+function resolveAdmissionPolicy(profile, trustClass) {
+  const base = defaultAdmissionPolicyForTrustClass(trustClass);
+  const overlay = profile?.spec.toolAdmission;
+  if (!overlay) return base;
+  const defaultAction = trustClass === "trusted" ? overlay.defaultAction ?? base.defaultAction : "deny";
+  return {
+    defaultAction,
+    rules: [...overlay.rules ?? [], ...base.rules ?? []]
+  };
+}
+function defaultPermissionActionForTrustClass(trustClass) {
+  return trustClass === "restricted" || trustClass === "quarantine" ? "deny" : "allow";
+}
+function evaluateToolAdmission(policy, operation) {
+  const toolName = operation.spec.toolRef.name;
+  const effect = operation.spec.effect;
+  for (const rule of policy.rules ?? []) {
+    if (!matchPattern(toolName, rule.toolPattern)) continue;
+    if (rule.effects && !rule.effects.includes(effect)) continue;
+    return {
+      action: rule.action,
+      source: "rule",
+      reason: rule.reason,
+      matchedRule: rule
+    };
+  }
+  return { action: policy.defaultAction, source: "default" };
+}
+
+// src/orchestration/drivers/unknownEffect.ts
+var TOOL_OPERATION_CONDITION_EFFECT_UNKNOWN = "EffectUnknown";
+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`
+  };
+}
+function effectUnknownCondition(decision, at) {
+  return {
+    type: TOOL_OPERATION_CONDITION_EFFECT_UNKNOWN,
+    status: "True",
+    reason: decision.action,
+    message: decision.reason,
+    lastTransitionTime: at
+  };
+}
+function applyUnknownEffectDecision(operation, decision, at = (/* @__PURE__ */ new Date()).toISOString()) {
+  const conditions = [
+    ...(operation.status?.conditions ?? []).filter((c) => c.type !== TOOL_OPERATION_CONDITION_EFFECT_UNKNOWN),
+    effectUnknownCondition(decision, at)
+  ];
+  const base = {
+    ...operation.status,
+    conditions
+  };
+  if (decision.action === "retry") {
+    return { ...operation, status: { ...base, phase: "Pending" } };
+  }
+  if (decision.action === "succeeded") {
+    return {
+      ...operation,
+      status: { ...base, phase: "Completed", completedAt: at }
+    };
+  }
+  return { ...operation, status: { ...base, phase: "Running" } };
+}
+
+// src/tools/pluginRegistry.ts
+var defaultPluginRegistry = /* @__PURE__ */ new Map();
+var pluginRegistry = defaultPluginRegistry;
+var activeOverride = null;
+function getActivePluginRegistry() {
+  return activeOverride ?? defaultPluginRegistry;
+}
+function runWithPluginRegistry(registry, function_) {
+  const previous = activeOverride;
+  activeOverride = registry;
+  try {
+    return function_();
+  } finally {
+    activeOverride = previous;
+  }
+}
+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);
+}
+async function runToolExecutedHooks(hooks, context) {
+  await hooks.toolExecuted.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/responsePatternUtility.ts
+import JSON5 from "json5";
+var MAX_FALLBACK_INPUT_LENGTH = 1e3;
+function parseToolParameters(parametersText) {
+  if (!parametersText || !parametersText.trim()) {
+    return {};
+  }
+  const trimmedText = parametersText.trim();
+  try {
+    return JSON.parse(trimmedText);
+  } catch {
+  }
+  try {
+    return JSON5.parse(trimmedText);
+  } catch {
+  }
+  return { input: 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 matchToolCalling(responseText) {
+  try {
+    for (const toolPattern of toolPatterns) {
+      toolPattern.pattern.lastIndex = 0;
+      const match = toolPattern.pattern.exec(responseText);
+      if (match) {
+        const toolId = toolPattern.extractToolId(match);
+        const parametersText = toolPattern.extractParams(match);
+        const originalText = toolPattern.extractOriginalText(match);
+        return {
+          found: true,
+          toolId,
+          parameters: parseToolParameters(parametersText),
+          originalText
+        };
+      }
+    }
+    return { found: false };
+  } catch {
+    return { found: false };
+  }
+}
+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();
+function getDefaultHookRegistry() {
+  return defaultHookRegistry;
+}
+function registerHook(type, handler, name) {
+  defaultHookRegistry.registerHook(type, handler, name);
+}
+function unregisterHook(type, name) {
+  return defaultHookRegistry.unregisterHook(type, name);
+}
+async function executeHooks(type, context, data) {
+  return defaultHookRegistry.executeHooks(type, context, data);
+}
+function hasHooks(type) {
+  return defaultHookRegistry.hasHooks(type);
+}
+function clearHooks() {
+  defaultHookRegistry.clearHooks();
+}
+function listRegisteredHookTypes() {
+  return defaultHookRegistry.listRegisteredHookTypes();
+}
+function getHookCount(type) {
+  return defaultHookRegistry.getHookCount(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/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 findPromptById(prompts, id) {
+  for (let index = 0; index < prompts.length; index++) {
+    const prompt = prompts[index];
+    if (prompt.id === id) {
+      return { prompt, parent: prompts, index };
+    }
+    if (prompt.children) {
+      const found = findPromptById(prompt.children, id);
+      if (found) return found;
+    }
+  }
+  return void 0;
+}
+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/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/tools/approval.ts
+var pendingApprovals = /* @__PURE__ */ new Map();
+var approvalListeners = /* @__PURE__ */ new Set();
+function onApprovalRequest(listener) {
+  approvalListeners.add(listener);
+  return () => {
+    approvalListeners.delete(listener);
+  };
+}
+function evaluateApproval(approval, toolName, parameters) {
+  if (!approval || approval.mode === "auto") {
+    return "allow";
+  }
+  const callContent = JSON.stringify({ tool: toolName, parameters });
+  if (approval.denyPatterns?.length) {
+    for (const pattern of approval.denyPatterns) {
+      try {
+        if (new RegExp(pattern, "i").test(callContent)) {
+          return "deny";
+        }
+      } catch {
+      }
+    }
+  }
+  if (approval.allowPatterns?.length) {
+    for (const pattern of approval.allowPatterns) {
+      try {
+        if (new RegExp(pattern, "i").test(callContent)) {
+          return "allow";
+        }
+      } catch {
+      }
+    }
+  }
+  return "pending";
+}
+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);
+    }
+  });
+}
+function resolveApproval(approvalId, decision) {
+  const pending = pendingApprovals.get(approvalId);
+  if (pending) {
+    pendingApprovals.delete(approvalId);
+    pending.resolve(decision);
+  }
+}
+function getPendingApprovals() {
+  return [...pendingApprovals.values()].map((p) => p.request);
+}
+function cancelPendingApprovals(agentId) {
+  for (const [id, pending] of pendingApprovals) {
+    if (pending.request.agentId === agentId) {
+      pendingApprovals.delete(id);
+      pending.resolve("deny");
+    }
+  }
+}
+
+// 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/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/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/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 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/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 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(context, 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 { 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/registry.ts
+function normalizePluginSelections(selected) {
+  if (!selected) return void 0;
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of selected) {
+    if (typeof entry === "string") {
+      result.set(entry, { id: entry, enabled: true });
+      continue;
+    }
+    if (entry.enabled === false) continue;
+    result.set(entry.id, entry);
+  }
+  return result;
+}
+var LoopRegistryImpl = class {
+  loops = /* @__PURE__ */ new Map();
+  profiles = /* @__PURE__ */ new Map();
+  plugins = /* @__PURE__ */ new Map();
+  // ── Loop registration ──
+  registerLoop(definition) {
+    if (!definition.id) throw new Error("Loop definition must have an id");
+    this.loops.set(definition.id, definition);
+  }
+  getLoop(id) {
+    return this.loops.get(id);
+  }
+  listLoops() {
+    return Array.from(this.loops.values());
+  }
+  // ── Profile registration ──
+  registerProfile(profile) {
+    if (!profile.id) throw new Error("Loop profile must have an id");
+    this.profiles.set(profile.id, profile);
+  }
+  getProfile(id) {
+    return this.profiles.get(id);
+  }
+  listProfiles() {
+    return Array.from(this.profiles.values());
+  }
+  // ── Plugin registration ──
+  registerPlugin(plugin) {
+    if (!plugin.id) throw new Error("Loop plugin must have an id");
+    this.plugins.set(plugin.id, plugin);
+  }
+  getPlugin(id) {
+    return this.plugins.get(id);
+  }
+  listPlugins() {
+    return Array.from(this.plugins.values());
+  }
+  installPluginsForLoop(loopId, target, selected) {
+    const selectedEntries = normalizePluginSelections(selected);
+    for (const plugin of this.plugins.values()) {
+      const entry = selectedEntries?.get(plugin.id);
+      if (selectedEntries && !entry) continue;
+      if (plugin.targetLoopId && plugin.targetLoopId !== "*" && plugin.targetLoopId !== loopId) {
+        continue;
+      }
+      if (plugin.install) {
+        plugin.install(target, entry?.config);
+      }
+    }
+  }
+  installPluginsForProfile(profile, target) {
+    this.installPluginsForLoop(profile.loopId ?? "agent-tool-loop", target, profile.plugins ?? []);
+  }
+  createRunnerForProfile(profile, context = {}) {
+    const loopId = profile.loopId ?? "agent-tool-loop";
+    this.installPluginsForProfile(profile, context);
+    return this.createRunner(loopId, { ...context, profile });
+  }
+  // ── Lifecycle ──
+  createRunner(loopId, context = {}) {
+    const definition = this.loops.get(loopId);
+    if (!definition) return null;
+    return definition.createRunner(context);
+  }
+  reset() {
+    this.loops.clear();
+    this.profiles.clear();
+    this.plugins.clear();
+  }
+};
+var defaultRegistry = null;
+function getLoopRegistry() {
+  if (!defaultRegistry) {
+    defaultRegistry = new LoopRegistryImpl();
+  }
+  return defaultRegistry;
+}
+function resetLoopRegistry() {
+  if (defaultRegistry) {
+    defaultRegistry.reset();
+  }
+  defaultRegistry = null;
+}
+
+// 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": "\u901A\u7528\u81EA\u7136\u8BED\u8A00\u52A9\u7406\uFF0C\u7528\u4E8E\u65E5\u5E38\u95EE\u7B54\u548C\u7B80\u5355\u4EFB\u52A1\u3002",',
+    '  "loopId": "agent-tool-loop",',
+    '  "systemPrompt": "You are a helpful general-purpose assistant. When you need to use a tool, output ONLY the tool call in this exact XML format:\\n<tool_use name=\\"TOOL_NAME\\">{\\"param\\":\\"value\\"}</tool_use>\\nNever wrap tool calls in markdown code blocks or add explanatory text before/after the tool call in the same message. After receiving the tool result, continue responding normally.",',
+    '  "tools": [',
+    '    "workspacesList",',
+    '    "wikiSearch",',
+    '    "wikiOperation",',
+    '    "modelContextProtocol",',
+    '    "spawnAgent",',
+    '    "askQuestion"',
+    "  ],",
+    '  "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" }',
+    "        }",
+    "      }",
+    "    }",
+    "  ],",
+    '  "agentFrameworkConfig": {',
+    '    "prompts": [',
+    "      {",
+    '        "id": "builtin-system",',
+    '        "role": "system",',
+    '        "text": "You are a helpful general-purpose assistant. When you need to use a tool, output ONLY the tool call in this exact XML format:\\n<tool_use name=\\"TOOL_NAME\\">{\\"param\\":\\"value\\"}</tool_use>\\nNever wrap tool calls in markdown code blocks or add explanatory text before/after the tool call in the same message. After receiving the tool result, continue responding normally."',
+    "      }",
+    "    ],",
+    '    "plugins": [{ "toolId": "fullReplacement" }],',
+    '    "response": []',
+    "  },",
+    '  "modelConfig": {',
+    '    "provider": "memeloop",',
+    '    "model": "claude-opus-4.6",',
+    '    "temperature": 0.5,',
+    '    "maxTokens": 4096',
+    "  },",
+    '  "version": "1.0.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);
+}
+function registerBuiltinLoopProfiles() {
+  const registry = getLoopRegistry();
+  for (const profile of getBuiltinLoopProfiles()) {
+    registry.registerProfile(profile);
+  }
+}
+
+export {
+  matchPattern,
+  mergePermissionSets,
+  checkPermission,
+  defaultAdmissionPolicyForTrustClass,
+  resolveAdmissionPolicy,
+  defaultPermissionActionForTrustClass,
+  evaluateToolAdmission,
+  TOOL_OPERATION_CONDITION_EFFECT_UNKNOWN,
+  reconcileUnknownEffect,
+  applyUnknownEffectDecision,
+  pluginRegistry,
+  getActivePluginRegistry,
+  runWithPluginRegistry,
+  createAgentFrameworkHooks,
+  runProcessPromptsHooks,
+  runResponseCompleteHooks,
+  runPostProcessHooks,
+  runToolExecutedHooks,
+  resolvePromptPluginMap,
+  createHooksWithPlugins,
+  matchToolCalling,
+  matchAllToolCallings,
+  nextLamportClockForConversation,
+  HookRegistry,
+  getDefaultHookRegistry,
+  registerHook,
+  unregisterHook,
+  executeHooks,
+  hasHooks,
+  clearHooks,
+  listRegisteredHookTypes,
+  getHookCount,
+  compactMessages,
+  shouldCompact,
+  autoCompact,
+  findPromptById,
+  flattenPrompts,
+  promptConcatStream,
+  MEMELOOP_STRUCTURED_TOOL_KEY,
+  truncateToolSummary,
+  extractMemeloopStructuredToolPayload,
+  onApprovalRequest,
+  evaluateApproval,
+  requestApproval,
+  resolveApproval,
+  getPendingApprovals,
+  cancelPendingApprovals,
+  createAgentToolLoopState,
+  startAgentToolLoopTurn,
+  runAgentToolLoopIteration,
+  stopAgentToolLoopTurn,
+  createAgentToolLoopRunner,
+  getLoopRegistry,
+  resetLoopRegistry,
+  getBuiltinLoopProfiles,
+  getBuiltinLoopProfile,
+  registerBuiltinLoopProfiles
+};
+//# sourceMappingURL=chunk-QFHAAIIM.js.map