memeloop 0.0.1 → 0.1.0

package/dist/chunk-XHRBV6I3.js

@@ -0,0 +1,3637 @@
+import {
+  containsSecrets
+} from "./chunk-AZFYDWIN.js";
+import {
+  MEMELOOP_STRUCTURED_TOOL_KEY,
+  createAgentToolLoopRunner,
+  createAgentToolLoopState,
+  getActivePluginRegistry,
+  getBuiltinLoopProfile,
+  getLoopRegistry,
+  nextLamportClockForConversation,
+  runAgentToolLoopIteration,
+  startAgentToolLoopTurn,
+  stopAgentToolLoopTurn,
+  truncateToolSummary
+} from "./chunk-QFHAAIIM.js";
+import {
+  AGENT_WORKLOAD_API_VERSION,
+  AGENT_WORKLOAD_KIND,
+  agentRunReference,
+  agentWorkloadReference,
+  createAgentRunManifest,
+  createAgentWorkloadManifest,
+  createArtifactRecordManifest,
+  isAgentRun,
+  isAgentWorkload
+} from "./chunk-BGPU4RR7.js";
+import {
+  OrchestrationError,
+  toOrchestrationErrorData
+} from "./chunk-FWSY5HOA.js";
+
+// src/orchestration/agentClient.ts
+function requireName(name, generateName, label) {
+  if (name) return name;
+  if (generateName) return `${generateName}${Math.random().toString(36).slice(2, 8)}`;
+  throw new OrchestrationError({ code: "INVALID", message: `${label} requires name or generateName`, retryable: false });
+}
+var CANCELLATION_POLL_INTERVAL_MS = 50;
+function cancellationError(lastResourceVersion) {
+  return new OrchestrationError({
+    code: "CANCELLED",
+    message: "condition wait cancelled",
+    retryable: false,
+    details: { lastResourceVersion }
+  });
+}
+function throwIfCancelled(options, lastResourceVersion) {
+  if (options.signal?.aborted || options.isCancelled?.() === true) {
+    throw cancellationError(lastResourceVersion);
+  }
+}
+function abortableDelay(ms, signal, lastResourceVersion) {
+  if (!signal) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timeout);
+      signal.removeEventListener("abort", onAbort);
+      reject(cancellationError(lastResourceVersion));
+    };
+    const timeout = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted) onAbort();
+  });
+}
+async function waitInterval(ms, options, lastResourceVersion) {
+  if (!options.isCancelled) {
+    await abortableDelay(ms, options.signal, lastResourceVersion);
+    return;
+  }
+  for (let remaining = ms; remaining > 0; remaining -= CANCELLATION_POLL_INTERVAL_MS) {
+    throwIfCancelled(options, lastResourceVersion);
+    await abortableDelay(Math.min(remaining, CANCELLATION_POLL_INTERVAL_MS), options.signal, lastResourceVersion);
+  }
+  throwIfCancelled(options, lastResourceVersion);
+}
+async function waitForCondition(get, condition, options) {
+  const intervalMs = Math.max(100, options.interval ?? 1e3);
+  const timeoutMs = options.timeout ?? 3e4;
+  const deadline = Date.now() + timeoutMs;
+  let lastResourceVersion = "0";
+  while (true) {
+    throwIfCancelled(options, lastResourceVersion);
+    const resource = await get();
+    throwIfCancelled(options, lastResourceVersion);
+    if (resource) {
+      lastResourceVersion = resource.metadata?.resourceVersion ?? "0";
+      const match = resource.status?.conditions?.find(
+        (candidate) => candidate.type === condition.type && candidate.status === condition.status
+      );
+      if (match) {
+        return { observedResourceVersion: lastResourceVersion, matched: true };
+      }
+    }
+    if (Date.now() + intervalMs > deadline) {
+      throw new OrchestrationError({
+        code: "TIMEOUT",
+        message: `condition ${condition.type}=${condition.status} not met within ${timeoutMs}ms`,
+        retryable: true,
+        details: { lastResourceVersion }
+      });
+    }
+    await waitInterval(intervalMs, options, lastResourceVersion);
+  }
+}
+function createAgentClient(client, defaultNamespace) {
+  function resolveNamespace(namespace) {
+    return namespace ?? defaultNamespace;
+  }
+  return {
+    async createWorkload(options) {
+      const name = requireName(options.name, options.generateName, "AgentWorkload");
+      const manifest = createAgentWorkloadManifest(name, {
+        profileId: options.profileId,
+        scriptReference: options.scriptReference,
+        promptReference: options.promptReference,
+        trust: options.trust,
+        placement: options.placement,
+        modelPolicy: options.modelPolicy,
+        toolPolicy: options.toolPolicy,
+        networkPolicy: options.networkPolicy,
+        storagePolicy: options.storagePolicy,
+        completionPolicy: options.completionPolicy,
+        ownerReferences: options.ownerReferences
+      });
+      const result = await client.apply(manifest, {
+        idempotencyKey: options.idempotencyKey,
+        fieldManager: "memeloop-agent-client"
+      });
+      if (!isAgentWorkload(result)) {
+        throw new OrchestrationError({ code: "UNKNOWN_EFFECT", message: "apply returned a non-AgentWorkload resource", retryable: false });
+      }
+      return result;
+    },
+    async getWorkload(name, namespace) {
+      const result = await client.get(agentWorkloadReference(name, resolveNamespace(namespace)));
+      return result && isAgentWorkload(result) ? result : null;
+    },
+    async deleteWorkload(name, namespace) {
+      await client.delete(agentWorkloadReference(name, resolveNamespace(namespace)));
+    },
+    async waitForWorkloadCondition(name, condition, options = {}) {
+      return waitForCondition(
+        () => this.getWorkload(name, defaultNamespace),
+        condition,
+        options
+      );
+    },
+    async createRun(options) {
+      const name = requireName(options.name, options.generateName, "AgentRun");
+      const manifest = createAgentRunManifest(name, {
+        workloadRef: agentWorkloadReference(options.workloadName, options.workloadNamespace ?? defaultNamespace),
+        promptReference: options.promptReference,
+        retry: options.retry,
+        timeoutMs: options.timeoutMs
+      });
+      const result = await client.apply(manifest, {
+        idempotencyKey: options.idempotencyKey,
+        fieldManager: "memeloop-agent-client"
+      });
+      if (!isAgentRun(result)) {
+        throw new OrchestrationError({ code: "UNKNOWN_EFFECT", message: "apply returned a non-AgentRun resource", retryable: false });
+      }
+      return result;
+    },
+    async getRun(name, namespace) {
+      const result = await client.get(agentRunReference(name, resolveNamespace(namespace)));
+      return result && isAgentRun(result) ? result : null;
+    },
+    async deleteRun(name, namespace) {
+      await client.delete(agentRunReference(name, resolveNamespace(namespace)));
+    },
+    async waitForRunCondition(name, condition, options = {}) {
+      return waitForCondition(
+        () => this.getRun(name, defaultNamespace),
+        condition,
+        options
+      );
+    }
+  };
+}
+
+// src/tools/schemaRegistry.ts
+import { zodToJsonSchema } from "zod-to-json-schema";
+var toolSchemas = /* @__PURE__ */ new Map();
+var toolMetadata = /* @__PURE__ */ new Map();
+function toolSchemaToJsonSchema(value) {
+  const native = value?.toJSONSchema?.();
+  if (native) return structuredClone(native);
+  if (value !== null && typeof value === "object" && "_def" in value) {
+    const converted = zodToJsonSchema(value, {
+      $refStrategy: "none"
+    });
+    return structuredClone(converted);
+  }
+  if (value !== null && typeof value === "object" && !Array.isArray(value) && ("type" in value || "properties" in value || "$ref" in value || "oneOf" in value || "anyOf" in value)) {
+    return structuredClone(value);
+  }
+  throw new TypeError(
+    "Tool parameter schema must be a Zod schema or a portable JSON Schema"
+  );
+}
+function registerToolParameterSchema(toolId, schema, metadata) {
+  toolSchemas.set(toolId, schema);
+  if (metadata) {
+    toolMetadata.set(toolId, metadata);
+  }
+}
+function getToolParameterSchema(toolId) {
+  return toolSchemas.get(toolId);
+}
+function getToolMetadata(toolId) {
+  return toolMetadata.get(toolId);
+}
+
+// src/orchestration/scripts/scriptRuntime.ts
+var BUILTIN_RUNTIME_CLASSES = {
+  "trusted-process": {
+    isolation: "process",
+    cpuLimitMillis: 2e3,
+    memoryLimitBytes: 512 * 1024 * 1024,
+    // 512 MiB
+    timeLimitMs: 3e5,
+    // 5 min
+    supportsCancellation: true,
+    supportedTrustClasses: ["trusted"],
+    networkAccess: "full"
+  },
+  "restricted-process": {
+    isolation: "process",
+    cpuLimitMillis: 1e3,
+    memoryLimitBytes: 128 * 1024 * 1024,
+    // 128 MiB
+    timeLimitMs: 12e4,
+    // 2 min
+    supportsCancellation: true,
+    supportedTrustClasses: ["trusted", "restricted"],
+    networkAccess: "outbound-only"
+  },
+  "quarantine-process": {
+    isolation: "process",
+    cpuLimitMillis: 500,
+    // A Node VM plus the trusted worker bootstrap needs more than 32 MiB RSS;
+    // the Linux host enforces this value as cgroup MemoryMax, not only V8 heap.
+    memoryLimitBytes: 96 * 1024 * 1024,
+    // 96 MiB
+    timeLimitMs: 3e4,
+    // 30 sec
+    supportsCancellation: true,
+    supportedTrustClasses: ["quarantine"],
+    networkAccess: "none"
+  }
+};
+function selectRuntimeClass(trustClass, available = Object.keys(BUILTIN_RUNTIME_CLASSES)) {
+  const exact = available.find((name2) => {
+    const spec2 = BUILTIN_RUNTIME_CLASSES[name2];
+    return spec2?.supportedTrustClasses.includes(trustClass);
+  });
+  if (!exact) {
+    throw new Error("No RuntimeClass available for trust class: " + trustClass);
+  }
+  const name = exact;
+  const spec = BUILTIN_RUNTIME_CLASSES[name];
+  return {
+    runtimeClass: name,
+    isolation: spec.isolation,
+    cpuLimitMillis: spec.cpuLimitMillis ?? 500,
+    memoryLimitBytes: spec.memoryLimitBytes ?? 32 * 1024 * 1024,
+    timeLimitMs: spec.timeLimitMs ?? 3e4,
+    networkAccess: spec.networkAccess
+  };
+}
+
+// src/orchestration/scripts/scriptAdmission.ts
+var TRUST_PROFILES = {
+  trusted: {
+    maxScriptBytes: 1048576,
+    // 1 MiB
+    allowedInterfaces: ["resource", "loop-runtime", "tool-execution", "model-provider", "network", "storage", "credential-broker", "artifact"],
+    forbiddenImports: [],
+    requireDefaultExport: true,
+    allowUntrustedInputs: false
+  },
+  restricted: {
+    maxScriptBytes: 256e3,
+    // 256 KiB
+    allowedInterfaces: ["resource", "loop-runtime", "model-provider"],
+    forbiddenImports: ["node:fs", "node:child_process", "node:net", "node:http", "node:https"],
+    requireDefaultExport: true,
+    allowUntrustedInputs: false
+  },
+  quarantine: {
+    maxScriptBytes: 64e3,
+    // 64 KiB
+    allowedInterfaces: ["loop-runtime"],
+    // No network, no file system, no model provider
+    forbiddenImports: ["node:fs", "node:child_process", "node:net", "node:http", "node:https", "node:os", "node:crypto"],
+    requireDefaultExport: true,
+    allowUntrustedInputs: false
+  }
+};
+var COMPATIBLE_CHECKPOINT_VERSIONS = /* @__PURE__ */ new Set(["loops.memeloop.io/v1alpha1"]);
+function defaultRequestedInterfacesForTrustClass(trustClass) {
+  return [...TRUST_PROFILES[trustClass].allowedInterfaces];
+}
+function maxScriptBytesForTrustClass(trustClass) {
+  return TRUST_PROFILES[trustClass].maxScriptBytes;
+}
+function admitScript(request) {
+  const profile = TRUST_PROFILES[request.authorTrust];
+  const approvedInterfaces = [];
+  if (request.script.sizeBytes > profile.maxScriptBytes) {
+    return {
+      admitted: false,
+      reason: `Script size ${request.script.sizeBytes} exceeds ${request.authorTrust} limit ${profile.maxScriptBytes}`,
+      approvedInterfaces: [],
+      checkpointCompatible: false,
+      retryable: true
+    };
+  }
+  if (!request.script.valid) {
+    return {
+      admitted: false,
+      reason: `Script validation failed: ${request.script.errors.join("; ")}`,
+      approvedInterfaces: [],
+      checkpointCompatible: false,
+      retryable: true
+    };
+  }
+  if (profile.requireDefaultExport && !request.script.hasDefaultExport) {
+    return {
+      admitted: false,
+      reason: "Script must export a default async generator",
+      approvedInterfaces: [],
+      checkpointCompatible: false,
+      retryable: true
+    };
+  }
+  for (const imp of request.script.imports) {
+    if (profile.forbiddenImports.includes(imp) || profile.forbiddenImports.includes(imp.replace(/^node:/, ""))) {
+      return {
+        admitted: false,
+        reason: `Import '${imp}' not allowed for ${request.authorTrust} scripts`,
+        approvedInterfaces: [],
+        checkpointCompatible: false,
+        retryable: false
+      };
+    }
+  }
+  for (const iface of request.requestedInterfaces) {
+    if (!profile.allowedInterfaces.includes(iface)) {
+      return {
+        admitted: false,
+        reason: `Interface '${iface}' not allowed for ${request.authorTrust} scripts`,
+        approvedInterfaces: [],
+        checkpointCompatible: false,
+        retryable: false
+      };
+    }
+    approvedInterfaces.push(iface);
+  }
+  let checkpointCompatible = true;
+  if (request.expectedCheckpointDigest && request.checkpointApiVersion) {
+    if (!COMPATIBLE_CHECKPOINT_VERSIONS.has(request.checkpointApiVersion)) {
+      checkpointCompatible = false;
+    }
+    if (request.expectedCheckpointDigest !== request.script.digest) {
+      checkpointCompatible = false;
+    }
+  }
+  return {
+    admitted: true,
+    reason: `Admitted as ${request.authorTrust}`,
+    approvedInterfaces,
+    checkpointCompatible,
+    retryable: false
+  };
+}
+
+// src/orchestration/scripts/scriptValidation.ts
+import { parse } from "acorn";
+var MAX_SCRIPT_BYTES = 1048576;
+function isAstNode(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function walkAst(node, visit) {
+  visit(node);
+  for (const key of Object.keys(node)) {
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        if (isAstNode(child)) walkAst(child, visit);
+      }
+    } else if (isAstNode(value)) {
+      walkAst(value, visit);
+    }
+  }
+}
+function isAsyncGeneratorFunction(node) {
+  if (!node) return false;
+  return (node.type === "FunctionDeclaration" || node.type === "FunctionExpression") && node.async === true && node.generator === true;
+}
+function getStaticImportSource(node) {
+  const source = node.source;
+  if (source && source.type === "Literal" && typeof source.value === "string") {
+    return source.value;
+  }
+  return void 0;
+}
+function isCommonJsExportAssignment(node) {
+  if (node.type !== "AssignmentExpression") return false;
+  const left = node.left;
+  if (!left || left.type !== "MemberExpression" || left.computed === true) return false;
+  const object = left.object;
+  const property = left.property;
+  if (!object || object.type !== "Identifier" || !property || property.type !== "Identifier") {
+    return false;
+  }
+  if (object.name === "exports") return true;
+  return object.name === "module" && property.name === "exports";
+}
+async function digestNormalizedScript(normalizedSource) {
+  const encoded = new TextEncoder().encode(normalizedSource);
+  const hash = await crypto.subtle.digest("SHA-256", encoded);
+  return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function validateScript(source) {
+  const errors = [];
+  const imports = [];
+  let hasDefaultExport = false;
+  let hasNonLiteralDynamicImport = false;
+  const normalized = normalizeScript(source);
+  const encoded = new TextEncoder().encode(normalized);
+  if (encoded.length > MAX_SCRIPT_BYTES) {
+    errors.push(`Script exceeds ${MAX_SCRIPT_BYTES} bytes (got ${encoded.length})`);
+  }
+  if (normalized.trim().length === 0) {
+    errors.push("Script is empty");
+  }
+  const digest = await digestNormalizedScript(normalized);
+  let program;
+  if (normalized.trim().length > 0) {
+    try {
+      program = parse(normalized, { ecmaVersion: "latest", sourceType: "module" });
+    } catch (error) {
+      errors.push(`Syntax error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (program) {
+    const topLevel = Array.isArray(program.body) ? program.body : [];
+    for (const statement of topLevel) {
+      if (statement.type !== "ExportDefaultDeclaration") continue;
+      const declaration = statement.declaration;
+      if (isAsyncGeneratorFunction(declaration)) {
+        hasDefaultExport = true;
+      } else if (declaration?.type === "Identifier") {
+        const identifier = declaration;
+        hasDefaultExport = topLevel.some((candidate) => {
+          if (isAsyncGeneratorFunction(candidate) && candidate.id?.name === identifier.name) {
+            return true;
+          }
+          if (candidate.type === "VariableDeclaration" && Array.isArray(candidate.declarations)) {
+            return candidate.declarations.some(
+              (declarator) => declarator.id?.name === identifier.name && isAsyncGeneratorFunction(declarator.init)
+            );
+          }
+          return false;
+        });
+      }
+    }
+    walkAst(program, (node) => {
+      if (node.type === "ImportDeclaration") {
+        const specifier = getStaticImportSource(node);
+        if (specifier !== void 0) imports.push(specifier);
+      } else if (node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") {
+        const specifier = getStaticImportSource(node);
+        if (specifier !== void 0) imports.push(specifier);
+      } else if (node.type === "ImportExpression") {
+        const specifier = getStaticImportSource(node);
+        if (specifier !== void 0) {
+          imports.push(specifier);
+        } else {
+          hasNonLiteralDynamicImport = true;
+        }
+      } else if (isCommonJsExportAssignment(node)) {
+        errors.push("CommonJS module.exports not supported (use ESM export)");
+      }
+    });
+  }
+  for (const specifier of imports) {
+    if (isForbiddenImport(specifier)) {
+      errors.push(`Forbidden import: ${specifier}`);
+    }
+  }
+  if (hasNonLiteralDynamicImport) {
+    errors.push("Dynamic import() with a non-literal argument is not allowed (defeats admission control)");
+  }
+  if (!hasDefaultExport) {
+    errors.push("Script must export a default async generator function");
+  }
+  return {
+    valid: errors.length === 0,
+    digest,
+    imports,
+    hasDefaultExport,
+    hasNonLiteralDynamicImport,
+    errors,
+    sizeBytes: encoded.length
+  };
+}
+function normalizeScript(source) {
+  return source.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n").map((line) => line.trimEnd()).join("\n").trim() + "\n";
+}
+function isForbiddenImport(spec) {
+  const builtins = /* @__PURE__ */ new Set([
+    "fs",
+    "path",
+    "child_process",
+    "net",
+    "http",
+    "https",
+    "os",
+    "crypto",
+    "tls",
+    "dgram",
+    "dns",
+    "readline",
+    "repl",
+    "stream",
+    "timers",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "worker_threads",
+    "zlib",
+    "assert",
+    "buffer",
+    "querystring",
+    "string_decoder"
+  ]);
+  const base = spec.replace(/^node:/, "");
+  if (builtins.has(base) && spec !== "node:events") return true;
+  if (spec.startsWith("@libp2p/") || spec.startsWith("@chainsafe/libp2p") || spec === "libp2p") {
+    return true;
+  }
+  if (spec === "memeloop" || spec.startsWith("memeloop/")) return true;
+  return false;
+}
+
+// src/orchestration/scripts/scriptDeploymentPipeline.ts
+var LIFECYCLE_TO_COMPLETION_POLICY = {
+  "run-once": "complete",
+  service: "daemon",
+  schedule: "detach"
+};
+function remoteDeploymentToWorkloadManifest(deployment, options = {}) {
+  const manifest = createAgentWorkloadManifest(options.name ?? deployment.artifactRef.name, {
+    scriptReference: deployment.artifactRef.contentDigest,
+    trust: deployment.trustClass,
+    runtimeClass: deployment.runtimeClass,
+    completionPolicy: LIFECYCLE_TO_COMPLETION_POLICY[deployment.lifecycle],
+    ...deployment.nodeSelector ? { placement: { nodeSelector: deployment.nodeSelector } } : {},
+    ...deployment.env ? { env: deployment.env } : {},
+    ...deployment.networkPolicy ? { networkPolicy: deployment.networkPolicy } : {},
+    ...deployment.storagePolicy ? { storagePolicy: deployment.storagePolicy } : {},
+    ...options.ownerReferences ? { ownerReferences: options.ownerReferences } : {}
+  });
+  const namespace = options.namespace ?? deployment.artifactRef.namespace;
+  if (namespace !== void 0) {
+    manifest.metadata.namespace = namespace;
+  }
+  return manifest;
+}
+async function deployGeneratedScript(request, options = {}) {
+  const validation = await validateScript(request.source);
+  if (!validation.valid) {
+    return {
+      deployed: false,
+      reason: `Script validation failed: ${validation.errors.join("; ")}`,
+      validation
+    };
+  }
+  const admission = admitScript({
+    script: validation,
+    authorTrust: request.authorTrust,
+    requestedInterfaces: request.requestedInterfaces,
+    expectedCheckpointDigest: request.expectedCheckpointDigest,
+    checkpointApiVersion: request.checkpointApiVersion
+  });
+  if (!admission.admitted) {
+    return { deployed: false, reason: admission.reason, validation, admission };
+  }
+  if (request.expectedCheckpointDigest !== void 0 && !admission.checkpointCompatible) {
+    return {
+      deployed: false,
+      reason: "Checkpoint is incompatible with this script digest/API version; an explicit converter or restart policy is required",
+      validation,
+      admission
+    };
+  }
+  for (const [name, value] of Object.entries(request.env ?? {})) {
+    if (containsSecrets(value)) {
+      return {
+        deployed: false,
+        reason: `Environment variable '${name}' carries a secret-shaped value; workload env must never contain credentials (plan 24.35)`,
+        validation,
+        admission
+      };
+    }
+  }
+  const contentDigest = `sha256:${validation.digest}`;
+  const artifactName = `script-${validation.digest}`;
+  const artifact = createArtifactRecordManifest(artifactName, {
+    contentHash: contentDigest,
+    sizeBytes: validation.sizeBytes,
+    mimeType: "text/javascript",
+    producer: { trust: request.authorTrust },
+    trust: request.authorTrust
+  });
+  if (request.namespace !== void 0) {
+    artifact.metadata.namespace = request.namespace;
+  }
+  await options.artifactStore?.putArtifact(artifact, normalizeScript(request.source));
+  const runtimeClass = selectRuntimeClass(request.authorTrust, options.availableRuntimeClasses);
+  const deployment = {
+    artifactRef: {
+      apiVersion: artifact.apiVersion,
+      kind: "ArtifactRecord",
+      name: artifactName,
+      namespace: artifact.metadata.namespace,
+      contentDigest
+    },
+    trustClass: request.authorTrust,
+    lifecycle: request.lifecycle,
+    runtimeClass: runtimeClass.runtimeClass,
+    nodeSelector: request.nodeSelector,
+    env: request.env,
+    networkPolicy: request.networkPolicy,
+    storagePolicy: request.storagePolicy
+  };
+  return {
+    deployed: true,
+    reason: admission.reason,
+    validation,
+    admission,
+    artifact,
+    runtimeClass,
+    deployment
+  };
+}
+function createScriptLoadGate(config) {
+  return {
+    async admitScriptLoad(request) {
+      const validation = await validateScript(request.normalizedSource);
+      if (!validation.valid) {
+        return { allowed: false, reason: `Script validation failed: ${validation.errors.join("; ")}` };
+      }
+      if (validation.digest !== request.digest) {
+        return { allowed: false, reason: "Digest mismatch between loader and validated source" };
+      }
+      const admission = admitScript({
+        script: validation,
+        authorTrust: config.authorTrust,
+        requestedInterfaces: config.requestedInterfaces,
+        expectedCheckpointDigest: config.expectedCheckpointDigest,
+        checkpointApiVersion: config.checkpointApiVersion
+      });
+      if (!admission.admitted) {
+        return { allowed: false, reason: admission.reason };
+      }
+      if (config.expectedCheckpointDigest !== void 0 && !admission.checkpointCompatible) {
+        return {
+          allowed: false,
+          reason: "Checkpoint is incompatible with this script digest/API version; an explicit converter or restart policy is required"
+        };
+      }
+      const runtimeClass = selectRuntimeClass(config.authorTrust, config.availableRuntimeClasses);
+      return {
+        allowed: true,
+        trustClass: config.authorTrust,
+        runtimeClass: runtimeClass.runtimeClass,
+        checkpointCompatible: admission.checkpointCompatible
+      };
+    }
+  };
+}
+function createScriptDeploymentClient(config) {
+  const interfaceCeiling = config.requestedInterfaces ?? defaultRequestedInterfacesForTrustClass(config.authorTrust);
+  function requireOrchestration() {
+    if (!config.orchestration) {
+      throw new OrchestrationError({
+        code: "UNSUPPORTED",
+        message: "script deployment scheduling requires a host-configured orchestration facade",
+        retryable: false
+      });
+    }
+    return config.orchestration;
+  }
+  return {
+    async deploy(request) {
+      const result = await deployGeneratedScript(
+        {
+          source: request.source,
+          authorTrust: config.authorTrust,
+          requestedInterfaces: request.requestedInterfaces ?? interfaceCeiling,
+          lifecycle: request.lifecycle,
+          nodeSelector: request.nodeSelector,
+          env: request.env,
+          networkPolicy: request.networkPolicy,
+          storagePolicy: request.storagePolicy,
+          expectedCheckpointDigest: request.expectedCheckpointDigest,
+          checkpointApiVersion: request.checkpointApiVersion,
+          namespace: request.namespace ?? config.namespace
+        },
+        {
+          artifactStore: config.artifactStore,
+          availableRuntimeClasses: config.availableRuntimeClasses
+        }
+      );
+      if (result.deployed && result.deployment && config.orchestration) {
+        const manifest = remoteDeploymentToWorkloadManifest(result.deployment, {
+          namespace: request.namespace ?? config.namespace
+        });
+        const workload = await config.orchestration.apply(manifest, {
+          idempotencyKey: result.deployment.artifactRef.contentDigest,
+          fieldManager: config.fieldManager ?? "memeloop/script-deployment"
+        });
+        return { ...result, workload };
+      }
+      return result;
+    },
+    async waitForScheduled(name, options = {}) {
+      const orchestration = requireOrchestration();
+      const { namespace, ...waitOptions2 } = options;
+      return waitForCondition(
+        () => orchestration.get({
+          apiVersion: AGENT_WORKLOAD_API_VERSION,
+          kind: AGENT_WORKLOAD_KIND,
+          name,
+          namespace: namespace ?? config.namespace
+        }),
+        { type: "Scheduled", status: "True" },
+        waitOptions2
+      );
+    },
+    async deleteDeployment(name, namespace) {
+      const orchestration = requireOrchestration();
+      await orchestration.delete({
+        apiVersion: AGENT_WORKLOAD_API_VERSION,
+        kind: AGENT_WORKLOAD_KIND,
+        name,
+        namespace: namespace ?? config.namespace
+      });
+    }
+  };
+}
+
+// src/loops/agent-agent-loop/builtinLoopSources.ts
+var AgentAgentLoopArtifactResourceLifecycleScriptId = "builtin:agent-agent-loop/artifact-resource-lifecycle";
+var AgentAgentLoopDeclarativeAgentRunScriptId = "builtin:agent-agent-loop/declarative-agent-run";
+var AgentAgentLoopQualityGateScriptId = "builtin:agent-agent-loop/quality-gate";
+var BUILTIN_AGENT_AGENT_LOOP_ARTIFACT_RESOURCE_LIFECYCLE_SCRIPT_ID = AgentAgentLoopArtifactResourceLifecycleScriptId;
+var BUILTIN_AGENT_AGENT_LOOP_DECLARATIVE_AGENT_RUN_SCRIPT_ID = AgentAgentLoopDeclarativeAgentRunScriptId;
+var BUILTIN_AGENT_AGENT_LOOP_QUALITY_GATE_SCRIPT_ID = AgentAgentLoopQualityGateScriptId;
+var builtinAgentAgentLoopSources = {
+  [AgentAgentLoopArtifactResourceLifecycleScriptId]: [
+    "// @ts-check",
+    "",
+    "function resourceName(value) {",
+    '  const normalized = value.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");',
+    '  return (normalized || "artifact").slice(0, 56);',
+    "}",
+    "",
+    "/** @param {import('../../loopAPI/agent-agent-loop/loop.js').AgentAgentScriptContext} ctx */",
+    "export default async function run(ctx) {",
+    "  if (!ctx.orchestration) {",
+    '    throw new Error("artifact-resource-lifecycle requires the orchestration resource facade");',
+    "  }",
+    "",
+    "  const metadata = ctx.profile?.metadata ?? {};",
+    '  const contentHash = typeof metadata.contentHash === "string"',
+    "    ? metadata.contentHash",
+    '    : "sha256:0000000000000000000000000000000000000000000000000000000000000000";',
+    "  const artifactName = resourceName(`script-${ctx.input.conversationId}`);",
+    "  const query = {",
+    '    apiVersion: "artifacts.memeloop.io/v1alpha1",',
+    '    kind: "ArtifactRecord",',
+    '    namespace: "default",',
+    "  };",
+    "  const abortController = new AbortController();",
+    "  const events = ctx.orchestration.watch(query, {",
+    '    resourceVersion: "0",',
+    "    sendInitialEvents: true,",
+    "    allowBookmarks: true,",
+    "    timeoutMs: 5_000,",
+    "    signal: abortController.signal,",
+    "  })[Symbol.asyncIterator]();",
+    "  const nextEvent = events.next();",
+    "",
+    "  try {",
+    "    const artifact = await ctx.orchestration.apply({",
+    "      apiVersion: query.apiVersion,",
+    "      kind: query.kind,",
+    "      metadata: {",
+    "        name: artifactName,",
+    "        namespace: query.namespace,",
+    '        labels: { "memeloop.io/artifact-purpose": "generated-script" },',
+    "      },",
+    "      spec: {",
+    "        contentHash,",
+    '        mimeType: "text/javascript",',
+    '        producer: { trust: "restricted" },',
+    '        trust: "restricted",',
+    "      },",
+    "    }, {",
+    '      fieldManager: "agent-agent-script-example",',
+    "      idempotencyKey: `${ctx.input.conversationId}:artifact`,",
+    "    });",
+    "",
+    "    const observed = await nextEvent;",
+    '    if (observed.done || observed.value.type !== "ADDED") {',
+    '      throw new Error("artifact watch ended before observing the created resource");',
+    "    }",
+    "",
+    "    const reference = {",
+    "      apiVersion: artifact.apiVersion,",
+    "      kind: artifact.kind,",
+    "      name: artifact.metadata.name,",
+    "      namespace: artifact.metadata.namespace,",
+    "      uid: artifact.metadata.uid,",
+    "    };",
+    "    const fetched = await ctx.orchestration.get(reference, {",
+    "      resourceVersion: artifact.metadata.resourceVersion,",
+    "    });",
+    "    const listed = await ctx.orchestration.list(query, {",
+    "      resourceVersion: artifact.metadata.resourceVersion,",
+    '      resourceVersionMatch: "not-older-than",',
+    "      limit: 10,",
+    "    });",
+    "    if (!fetched || !listed.items.some((item) => item.metadata.uid === artifact.metadata.uid)) {",
+    '      throw new Error("created artifact was not readable through the resource facade");',
+    "    }",
+    "",
+    "    await ctx.orchestration.delete(reference, {",
+    "      idempotencyKey: `${ctx.input.conversationId}:artifact-delete`,",
+    "      preconditions: {",
+    "        uid: artifact.metadata.uid,",
+    "        resourceVersion: artifact.metadata.resourceVersion,",
+    "      },",
+    "    });",
+    "    ctx.finish(`verified artifact lifecycle ${artifact.metadata.name}@${observed.value.resourceVersion}`);",
+    "  } finally {",
+    "    abortController.abort();",
+    "    await events.return?.();",
+    "  }",
+    "}",
+    ""
+  ].join("\n"),
+  [AgentAgentLoopDeclarativeAgentRunScriptId]: [
+    "// @ts-check",
+    "",
+    "function resourceName(value) {",
+    '  const normalized = value.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");',
+    '  return (normalized || "agent-run").slice(0, 48);',
+    "}",
+    "",
+    "/** @param {import('../../loopAPI/agent-agent-loop/loop.js').AgentAgentScriptContext} ctx */",
+    "export default async function run(ctx) {",
+    "  if (!ctx.agentClient) {",
+    '    throw new Error("declarative-agent-run requires the orchestration resource facade");',
+    "  }",
+    "",
+    "  const metadata = ctx.profile?.metadata ?? {};",
+    '  const childProfileId = typeof metadata.childProfileId === "string"',
+    "    ? metadata.childProfileId",
+    "    : ctx.agents[0]?.profileId;",
+    "  if (!childProfileId) {",
+    '    throw new Error("declarative-agent-run requires metadata.childProfileId or one configured agent");',
+    "  }",
+    "",
+    "  const baseName = resourceName(`child-${ctx.input.conversationId}`);",
+    "  const workloadName = `${baseName}-workload`;",
+    "  const runName = `${baseName}-run`;",
+    "  const workload = await ctx.agentClient.createWorkload({",
+    "    name: workloadName,",
+    "    profileId: childProfileId,",
+    "    promptReference: `conversation:${ctx.input.conversationId}:input`,",
+    '    trust: "restricted",',
+    "    placement: {",
+    '      nodeSelector: { "memeloop.io/worker-pool": "restricted" },',
+    "      antiAffinity: [ctx.input.conversationId],",
+    "    },",
+    "    modelPolicy: {",
+    '      modelClass: "local-model",',
+    "      budget: { maxTokens: 8_192 },",
+    "    },",
+    "    toolPolicy: {",
+    '      defaultAction: "deny",',
+    '      allowedToolClasses: ["read-only"],',
+    "    },",
+    "    networkPolicy: {",
+    '      networkClass: "restricted-egress",',
+    '      egress: "restricted",',
+    "    },",
+    "    storagePolicy: {",
+    '      storageClass: "ephemeral",',
+    "    },",
+    '    completionPolicy: "complete",',
+    "    idempotencyKey: `${ctx.input.conversationId}:workload`,",
+    "  });",
+    "  const agentRun = await ctx.agentClient.createRun({",
+    "    name: runName,",
+    "    workloadName: workload.metadata.name,",
+    "    workloadNamespace: workload.metadata.namespace,",
+    "    promptReference: `conversation:${ctx.input.conversationId}:input`,",
+    "    timeoutMs: 120_000,",
+    "    idempotencyKey: `${ctx.input.conversationId}:run`,",
+    "  });",
+    "",
+    "  if (metadata.waitForCompletion === true) {",
+    "    await ctx.agentClient.waitForRunCondition(",
+    "      agentRun.metadata.name,",
+    '      { type: "Completed", status: "True" },',
+    "      { timeout: 5_000, interval: 100 },",
+    "    );",
+    "  }",
+    "",
+    "  ctx.finish(`scheduled ${workload.metadata.name}/${agentRun.metadata.name}`);",
+    "}",
+    ""
+  ].join("\n"),
+  [AgentAgentLoopQualityGateScriptId]: [
+    "// @ts-check",
+    "",
+    "function positiveInteger(value, fallback) {",
+    "  const number = Number(value);",
+    "  return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;",
+    "}",
+    "",
+    "function asEntries(value, fallback) {",
+    "  return Array.isArray(value) && value.length > 0 ? value : fallback;",
+    "}",
+    "",
+    "function withConversationIds(ctx, entries, phase, iteration) {",
+    "  return entries.map((entry, index) => {",
+    '    const record = typeof entry === "string" ? { profile: entry } : entry;',
+    "    return {",
+    "      ...record,",
+    "      conversationId:",
+    "        record.conversationId ?? `${ctx.input.conversationId}:${phase}:${iteration}:${index}`,",
+    "    };",
+    "  });",
+    "}",
+    "",
+    "function resultText(ctx, result) {",
+    "  return result.text || ctx.formatAgentResults(result, { includeFailureSection: true });",
+    "}",
+    "",
+    "function reviewText(ctx, result) {",
+    "  return ctx.formatAgentResults(result, { includeFailureSection: true });",
+    "}",
+    "",
+    "function approved(result) {",
+    "  return (",
+    "    result.failures.length === 0 &&",
+    "    result.results.length > 0 &&",
+    "    result.results.every((item) => /^\\s*APPROVED\\b/imu.test(item.text))",
+    "  );",
+    "}",
+    "",
+    "function feedbackBlock(ctx, history) {",
+    '  if (history.length === 0) return "No prior review feedback.";',
+    "  return history",
+    "    .map((entry) =>",
+    "      [",
+    "        `Iteration ${entry.iteration}`,",
+    "        `Attempt:\\n${resultText(ctx, entry.attempt)}`,",
+    "        `Review:\\n${reviewText(ctx, entry.review)}`,",
+    '      ].join("\\n\\n"),',
+    "    )",
+    '    .join("\\n\\n---\\n\\n");',
+    "}",
+    "",
+    "function workerPrompt(ctx, goal, iteration, previousAttempt, history) {",
+    "  if (!previousAttempt) return goal;",
+    "  return [",
+    '    "Continue working on the original goal until the reviewer can approve it.",',
+    '    "Do not summarize the review. Produce the corrected deliverable itself.",',
+    "    `Original goal:\\n${goal}`,",
+    "    `Previous deliverable:\\n${resultText(ctx, previousAttempt)}`,",
+    "    `Review history:\\n${feedbackBlock(ctx, history)}`,",
+    "    `This is revision attempt ${iteration}.`,",
+    '  ].join("\\n\\n");',
+    "}",
+    "",
+    "function reviewPrompt(ctx, goal, attempt, history) {",
+    "  return [",
+    '    "You are the quality gate for this delegated agent run.",',
+    '    "Return APPROVED on the first line only when the deliverable fully satisfies the original goal and is ready to send to the user.",',
+    '    "Return REVISE on the first line when more work is required, followed by concrete blocking issues and exact changes needed.",',
+    '    "Do not approve partial progress.",',
+    "    `Original goal:\\n${goal}`,",
+    "    `Candidate deliverable:\\n${resultText(ctx, attempt)}`,",
+    "    `Earlier review history:\\n${feedbackBlock(ctx, history)}`,",
+    '  ].join("\\n\\n");',
+    "}",
+    "",
+    "async function runBatch(ctx, mode, input) {",
+    '  return mode === "sequential" ? ctx.runSequential(input) : ctx.runParallel(input);',
+    "}",
+    "",
+    "/** @param {import('../../loopAPI/agent-agent-loop/loop.js').AgentAgentScriptContext} ctx */",
+    "export default async function run(ctx) {",
+    "  const metadata = ctx.profile?.metadata ?? {};",
+    "  const goal = ctx.input.message;",
+    "  const maxIterations = positiveInteger(metadata.maxIterations, 4);",
+    '  const mode = metadata.mode === "sequential" ? "sequential" : "parallel";',
+    '  const reviewMode = metadata.reviewMode === "sequential" ? "sequential" : "parallel";',
+    '  const defaultAgents = ctx.getAgentEntries("agents");',
+    "  const workers = asEntries(",
+    '    ctx.getAgentEntries("workers"),',
+    '    asEntries(ctx.getAgentEntries("draftAgents"), defaultAgents),',
+    "  );",
+    "  const reviewers = asEntries(",
+    '    ctx.getAgentEntries("reviewers"),',
+    '    asEntries(ctx.getAgentEntries("reviewAgents"), defaultAgents),',
+    "  );",
+    "  const fixers = asEntries(",
+    '    ctx.getAgentEntries("fixers"),',
+    '    asEntries(ctx.getAgentEntries("revisionAgents"), workers),',
+    "  );",
+    "  const history = [];",
+    "  let attempt;",
+    "",
+    "  if (workers.length === 0 || reviewers.length === 0) {",
+    "    ctx.finish(",
+    '      "AgentAgent quality gate requires worker and reviewer agents. Configure metadata.workers/reviewers or metadata.agents.",',
+    "    );",
+    "    return;",
+    "  }",
+    "",
+    "  for (let iteration = 1; iteration <= maxIterations; iteration += 1) {",
+    "    if (ctx.isCancelled()) break;",
+    "    const activeWorkers = iteration === 1 ? workers : fixers;",
+    "    const attemptKey = `quality-gate:${iteration}:attempt`;",
+    "    const previousAttempt = attempt;",
+    "    const savedAttempt = await ctx.loadCheckpoint(attemptKey);",
+    "    if (savedAttempt) {",
+    "      attempt = savedAttempt;",
+    "    } else {",
+    "      ctx.emit({",
+    '        type: "thinking",',
+    '        data: { status: "quality-gate-work", conversationId: ctx.input.conversationId, iteration },',
+    "      });",
+    "      attempt = await runBatch(ctx, mode, {",
+    '        agents: withConversationIds(ctx, activeWorkers, "work", iteration),',
+    "        prompt: workerPrompt(ctx, goal, iteration, previousAttempt, history),",
+    "      });",
+    "      await ctx.checkpoint(attemptKey, attempt);",
+    "    }",
+    "",
+    "    if (attempt.failures.length > 0 && attempt.results.length === 0) {",
+    "      history.push({",
+    "        iteration,",
+    "        attempt,",
+    '        review: { results: [], failures: attempt.failures, text: "" },',
+    "      });",
+    "      continue;",
+    "    }",
+    "",
+    "    const reviewKey = `quality-gate:${iteration}:review`;",
+    "    let review = await ctx.loadCheckpoint(reviewKey);",
+    "    if (!review) {",
+    "      ctx.emit({",
+    '        type: "thinking",',
+    "        data: {",
+    '          status: "quality-gate-review",',
+    "          conversationId: ctx.input.conversationId,",
+    "          iteration,",
+    "        },",
+    "      });",
+    "      review = await runBatch(ctx, reviewMode, {",
+    '        agents: withConversationIds(ctx, reviewers, "review", iteration),',
+    "        prompt: reviewPrompt(ctx, goal, attempt, history),",
+    "      });",
+    "      await ctx.checkpoint(reviewKey, review);",
+    "    }",
+    "    history.push({ iteration, attempt, review });",
+    "",
+    "    if (approved(review)) {",
+    "      ctx.finish(resultText(ctx, attempt));",
+    "      return;",
+    "    }",
+    "  }",
+    "",
+    "  ctx.finish(",
+    "    [",
+    '      "Quality gate did not approve the delegated work before the iteration limit.",',
+    '      attempt ? resultText(ctx, attempt) : "No deliverable was produced.",',
+    '      "Review trail:",',
+    "      feedbackBlock(ctx, history),",
+    "    ]",
+    "      .filter(Boolean)",
+    '      .join("\\n\\n"),',
+    "  );",
+    "}",
+    ""
+  ].join("\n")
+};
+function getBuiltinAgentAgentLoopSource(id) {
+  return builtinAgentAgentLoopSources[id];
+}
+
+// src/loopAPI/scriptLoader.ts
+var DEFAULT_POLICY = {
+  allowBuiltin: true,
+  allowFile: false,
+  allowNetwork: false,
+  allowSource: false,
+  allowSpecifier: true
+};
+var LOADED_SCRIPT_METADATA = /* @__PURE__ */ Symbol("memeloop.loadedScriptMetadata");
+function isLoadedScriptFunction(value) {
+  return typeof value === "function";
+}
+function getLoadedScriptMetadata(script) {
+  if (!isLoadedScriptFunction(script)) return void 0;
+  return script[LOADED_SCRIPT_METADATA];
+}
+function attachLoadedScriptMetadata(script, metadata) {
+  if (getLoadedScriptMetadata(script) !== void 0) return;
+  Object.defineProperty(script, LOADED_SCRIPT_METADATA, {
+    value: metadata,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+}
+var builtinScriptDigests = /* @__PURE__ */ new Set();
+function registerBuiltinScriptDigests(digests) {
+  for (const digest of digests) {
+    builtinScriptDigests.add(digest);
+  }
+}
+async function registerBuiltinScriptSources(sources) {
+  const digests = [];
+  for (const source of Object.values(sources)) {
+    digests.push(await digestNormalizedScript(normalizeScript(source)));
+  }
+  registerBuiltinScriptDigests(digests);
+  return digests;
+}
+function isRegisteredBuiltinScriptDigest(digest) {
+  return builtinScriptDigests.has(digest);
+}
+var ScriptLoadDeniedError = class extends Error {
+  constructor(digest, gateReason) {
+    super(`Agent loop script load denied (sha256:${digest}): ${gateReason}`);
+    this.digest = digest;
+    this.gateReason = gateReason;
+    this.name = "ScriptLoadDeniedError";
+  }
+  code = "SCRIPT_LOAD_DENIED";
+};
+var FAIL_CLOSED_SCRIPT_LOAD_GATE = {
+  admitScriptLoad: () => ({
+    allowed: false,
+    reason: "No script load gate configured; non-builtin script sources are denied by default (fail-closed)"
+  })
+};
+function getExportedScript(moduleExports) {
+  if (typeof moduleExports === "function") return moduleExports;
+  if (!moduleExports || typeof moduleExports !== "object") return void 0;
+  const record = moduleExports;
+  return record.default ?? record.run;
+}
+function sourceToDataSpecifier(source, name = "agent-loop-script.mjs") {
+  return `data:text/javascript;charset=utf-8,${encodeURIComponent(`${source}
+//# sourceURL=${name}`)}`;
+}
+function normalizeScriptReference(scriptReference) {
+  if (typeof scriptReference !== "string") return scriptReference;
+  if (scriptReference.startsWith("builtin:")) return { kind: "builtin", id: scriptReference };
+  return { kind: "specifier", specifier: scriptReference };
+}
+function isFileSpecifier(specifier) {
+  return specifier.startsWith("file:") || specifier.startsWith("/") || specifier.startsWith("./") || specifier.startsWith("../");
+}
+function isNetworkSpecifier(specifier) {
+  return specifier.startsWith("http:") || specifier.startsWith("https:");
+}
+function isSourceSpecifier(specifier) {
+  return specifier.startsWith("data:text/javascript") || specifier.startsWith("data:application/javascript");
+}
+function decodeDataScriptSpecifier(specifier) {
+  const commaIndex = specifier.indexOf(",");
+  if (commaIndex < 0) return void 0;
+  const metadata = specifier.slice("data:".length, commaIndex);
+  const payload = specifier.slice(commaIndex + 1);
+  try {
+    if (metadata.split(";").includes("base64")) {
+      return atob(payload);
+    }
+    return decodeURIComponent(payload);
+  } catch {
+    return void 0;
+  }
+}
+function assertSpecifierAllowed(specifier, policy) {
+  if (!policy.allowSpecifier) {
+    throw new Error("Agent loop script import specifiers are disabled by policy.");
+  }
+  if (isSourceSpecifier(specifier) && !policy.allowSource) {
+    throw new Error("Agent loop script source/data URLs are disabled by policy.");
+  }
+  if (isFileSpecifier(specifier) && !policy.allowFile) {
+    throw new Error("Agent loop script file imports are disabled by policy.");
+  }
+  if (isNetworkSpecifier(specifier) && !policy.allowNetwork) {
+    throw new Error("Agent loop script network imports are disabled by policy.");
+  }
+}
+async function loadAgentLoopScript(scriptReference, options = {}) {
+  const policy = { ...DEFAULT_POLICY, ...options };
+  const importModule = options.importModule ?? ((specifier) => import(specifier));
+  const normalized = normalizeScriptReference(scriptReference);
+  const scriptType = options.scriptType ?? "Agent loop script";
+  let scriptSpecifier;
+  let sourceForAdmission;
+  if (normalized.kind === "builtin") {
+    if (!policy.allowBuiltin) {
+      throw new Error("Built-in agent loop scripts are disabled by policy.");
+    }
+    const source = options.getBuiltinScriptSource?.(normalized.id);
+    if (!source) throw new Error(`Unknown built-in agent loop script: ${normalized.id}`);
+    sourceForAdmission = source;
+    scriptSpecifier = sourceToDataSpecifier(source, normalized.id);
+  } else if (normalized.kind === "source") {
+    if (!policy.allowSource) {
+      throw new Error("Agent loop script source strings are disabled by policy.");
+    }
+    sourceForAdmission = normalized.source;
+    scriptSpecifier = sourceToDataSpecifier(normalized.source, normalized.name);
+  } else {
+    scriptSpecifier = normalized.specifier;
+    assertSpecifierAllowed(scriptSpecifier, policy);
+    if (isSourceSpecifier(scriptSpecifier)) {
+      sourceForAdmission = decodeDataScriptSpecifier(scriptSpecifier);
+      if (sourceForAdmission === void 0) {
+        throw new ScriptLoadDeniedError("undecodable", "data: script specifier payload could not be decoded");
+      }
+    }
+  }
+  let metadata;
+  if (sourceForAdmission !== void 0) {
+    const normalizedSource = normalizeScript(sourceForAdmission);
+    const digest = await digestNormalizedScript(normalizedSource);
+    if (isRegisteredBuiltinScriptDigest(digest)) {
+      metadata = { digest, builtin: true, trustClass: "trusted" };
+    } else {
+      const gate = options.scriptLoadGate ?? FAIL_CLOSED_SCRIPT_LOAD_GATE;
+      const decision = await gate.admitScriptLoad({ normalizedSource, digest, reference: normalized, scriptType });
+      if (!decision.allowed) {
+        throw new ScriptLoadDeniedError(digest, decision.reason ?? "denied by script load gate");
+      }
+      metadata = {
+        digest,
+        builtin: false,
+        trustClass: decision.trustClass,
+        runtimeClass: decision.runtimeClass,
+        checkpointCompatible: decision.checkpointCompatible
+      };
+    }
+  }
+  const moduleExports = await importModule(scriptSpecifier);
+  const exportedScript = getExportedScript(moduleExports);
+  if (!isLoadedScriptFunction(exportedScript)) {
+    throw new TypeError(
+      `${scriptType} "${scriptSpecifier}" must export a default function or named run function.`
+    );
+  }
+  if (metadata) {
+    attachLoadedScriptMetadata(exportedScript, metadata);
+  }
+  return exportedScript;
+}
+
+// src/loopAPI/agent-agent-loop/scriptLoader.ts
+var builtinDigestsRegistered;
+function ensureBuiltinDigestsRegistered() {
+  builtinDigestsRegistered ??= registerBuiltinScriptSources(builtinAgentAgentLoopSources);
+  return builtinDigestsRegistered;
+}
+async function loadAgentAgentLoopScript(scriptReference, options = {}) {
+  await ensureBuiltinDigestsRegistered();
+  return loadAgentLoopScript(scriptReference, {
+    ...options,
+    getBuiltinScriptSource: getBuiltinAgentAgentLoopSource,
+    scriptType: "AgentAgentLoop script"
+  });
+}
+
+// src/loopAPI/agent-agent-loop/loop.ts
+var LOOP_ID = "agent-agent-loop";
+var LOOP_NAME = "AgentAgent Loop";
+var LOOP_DESC = "Orchestrates child agents to collaborate on a task. Supports sequential chaining, parallel execution, and feedback loops.";
+function isAsyncIterable(value) {
+  return Boolean(value && typeof value === "object" && Symbol.asyncIterator in value);
+}
+function messageStep(message) {
+  return { type: "message", data: message };
+}
+function stepText(step) {
+  if (step.type !== "message") return void 0;
+  if (typeof step.data === "string") return step.data;
+  if (step.data && typeof step.data === "object" && "content" in step.data) {
+    const content = step.data.content;
+    return typeof content === "string" ? content : void 0;
+  }
+  return void 0;
+}
+function profileIdFromEntry(entry) {
+  if (typeof entry === "string") return entry;
+  return entry.profileId ?? entry.profile;
+}
+function readProfileAgentEntries(profile, key = "agents") {
+  const metadata = profile?.metadata;
+  if (!metadata) return void 0;
+  const entries = metadata[key];
+  if (Array.isArray(entries)) return entries;
+  return void 0;
+}
+function normalizeAgentAgents(input, context, entries, prompt) {
+  const configuredEntries = entries ?? context.agents ?? readProfileAgentEntries(context.profile) ?? [];
+  return configuredEntries.flatMap((entry, index) => {
+    const profileId = profileIdFromEntry(entry);
+    if (!profileId) return [];
+    const record = typeof entry === "string" ? {} : entry;
+    return {
+      ...record,
+      profileId,
+      prompt: prompt ?? record.prompt,
+      conversationId: record.conversationId ?? `${input.conversationId}:child:${index}`,
+      label: record.label
+    };
+  });
+}
+function formatAgentResults(result, options = {}) {
+  const emptyMessage = options.emptyMessage ?? "No child agent output.";
+  const failureHeader = options.failureHeader ?? "Failed child agents:";
+  const includeFailureSection = options.includeFailureSection !== false;
+  const sections = [result.text || emptyMessage];
+  if (includeFailureSection && result.failures.length > 0) {
+    sections.push(`${failureHeader}
+${result.failures.map((failure) => `${failure.profileId}: ${failure.error}`).join("\n")}`);
+  }
+  return sections.filter(Boolean).join("\n\n");
+}
+function createScriptArguments(input, context, emittedSteps) {
+  const agentEntries = context.agents ?? readProfileAgentEntries(context.profile) ?? [];
+  const agents = normalizeAgentAgents(input, context, agentEntries);
+  const getAgentEntries = (key = "agents") => {
+    if (key === "agents") return agentEntries;
+    return readProfileAgentEntries(context.profile, key) ?? [];
+  };
+  const emit = (step) => {
+    emittedSteps.push(step);
+    context.runtime?.emit?.(step);
+  };
+  const log = (event, data) => {
+    context.runtime?.log?.(event, data);
+  };
+  const isCancelled = () => context.runtime?.signal?.cancelled === true;
+  let childCounter = 0;
+  const runAgent = async (childInput) => {
+    if (isCancelled()) throw new Error("AgentAgent_Loop cancelled before child agent start");
+    const profileId = childInput.profileId ?? childInput.profile;
+    if (!profileId) throw new Error("ctx.runAgent requires profileId or profile");
+    if (!context.runtime?.runChildAgent) throw new Error("ctx.runAgent requires runtime.runChildAgent");
+    const childConversationId = childInput.conversationId ?? `${input.conversationId}:child:${profileId}:${++childCounter}`;
+    const prompt = childInput.prompt ?? input.message;
+    emit({
+      type: "thinking",
+      data: { status: "child-agent-started", profileId, conversationId: childConversationId }
+    });
+    const steps = [];
+    const chunks = [];
+    try {
+      for await (const step of context.runtime.runChildAgent({
+        profileId,
+        prompt,
+        conversationId: childConversationId
+      })) {
+        if (isCancelled()) throw new Error("AgentAgent_Loop cancelled during child agent run");
+        steps.push(step);
+        const text = stepText(step);
+        if (text) chunks.push(text);
+        emit({
+          type: "thinking",
+          data: { status: "child-agent-step", profileId, conversationId: childConversationId, step }
+        });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      emit({
+        type: "thinking",
+        data: { status: "child-agent-failed", profileId, conversationId: childConversationId, error: message }
+      });
+      throw error;
+    }
+    emit({
+      type: "thinking",
+      data: { status: "child-agent-completed", profileId, conversationId: childConversationId }
+    });
+    return { profileId, conversationId: childConversationId, steps, text: chunks.join("").trim() };
+  };
+  const runBatch = async (batchInput, mode) => {
+    const batchAgents = normalizeAgentAgents(input, context, batchInput?.agents, batchInput?.prompt);
+    const continueOnError = batchInput?.continueOnError !== false;
+    const results = [];
+    const failures = [];
+    const runOne = async (agent) => {
+      if (isCancelled()) {
+        emit({
+          type: "thinking",
+          data: { status: "cancelled", conversationId: input.conversationId }
+        });
+        return;
+      }
+      try {
+        const result = await runAgent(agent);
+        results.push(result);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        failures.push({ profileId: agent.profileId, conversationId: agent.conversationId, error: message });
+        if (!continueOnError) throw error;
+      }
+    };
+    if (mode === "parallel") {
+      await Promise.all(batchAgents.map((agent) => runOne(agent)));
+    } else {
+      for (const agent of batchAgents) {
+        await runOne(agent);
+        if (isCancelled()) break;
+      }
+    }
+    return { results, failures, text: results.map((result) => result.text).filter(Boolean).join("\n\n") };
+  };
+  const agentClient = context.runtime?.orchestration ? createAgentClient(context.runtime.orchestration) : void 0;
+  const scriptClient = context.runtime?.scriptDeployment ? createScriptDeploymentClient(context.runtime.scriptDeployment) : void 0;
+  return {
+    input,
+    context,
+    profile: context.profile,
+    agents,
+    getAgentEntries,
+    runtime: context.runtime,
+    orchestration: context.runtime?.orchestration,
+    agentClient,
+    scriptClient,
+    runAgent,
+    runAgents: (inputs) => Promise.all(inputs.map(runAgent)),
+    runSequential: (batchInput) => runBatch(batchInput, "sequential"),
+    runParallel: (batchInput) => runBatch(batchInput, "parallel"),
+    formatAgentResults,
+    finishAgentResults: (result, options) => {
+      emit(messageStep(formatAgentResults(result, options)));
+    },
+    emit,
+    finish: (message) => {
+      emit(typeof message === "string" ? messageStep(message) : message);
+    },
+    isCancelled,
+    log,
+    state: context.runtime?.state ?? {
+      get: async () => void 0,
+      set: async () => void 0,
+      update: async () => void 0
+    },
+    checkpoint: context.runtime?.checkpoint ?? (async () => void 0),
+    loadCheckpoint: context.runtime?.loadCheckpoint ?? (async () => void 0)
+  };
+}
+async function* drainEmittedSteps(steps) {
+  while (steps.length > 0) {
+    const step = steps.shift();
+    if (step) yield step;
+  }
+}
+async function* runScript(script, input, context) {
+  const emittedSteps = [];
+  const scriptArguments = createScriptArguments(input, context, emittedSteps);
+  const result = await script(scriptArguments);
+  yield* drainEmittedSteps(emittedSteps);
+  if (isAsyncIterable(result)) {
+    yield* result;
+    yield* drainEmittedSteps(emittedSteps);
+  } else if (typeof result === "string") {
+    yield messageStep(result);
+  } else if (Array.isArray(result)) {
+    yield* result;
+  } else if (result) {
+    yield result;
+  }
+}
+function asAgentAgentContext(context) {
+  return context;
+}
+async function resolveScript(context) {
+  if (context.script) return context.script;
+  const scriptReference = context.profile?.scriptReference ?? context.profile?.scriptRef ?? context.profile?.script;
+  if (scriptReference) {
+    if (context.loadScript) return context.loadScript(scriptReference, context);
+    return loadAgentAgentLoopScript(scriptReference, context.scriptPolicy);
+  }
+  return void 0;
+}
+function createAgentAgentLoopDefinition() {
+  return {
+    id: LOOP_ID,
+    name: LOOP_NAME,
+    description: LOOP_DESC,
+    createRunner: (rawContext) => {
+      return async function* agentAgentLoop(input) {
+        const context = asAgentAgentContext(rawContext);
+        const script = await resolveScript(context);
+        yield {
+          type: "thinking",
+          data: { status: "agent-agent-loop-loop-started", conversationId: input.conversationId }
+        };
+        context.runtime?.log?.("agent-agent-loop-loop-started", {
+          conversationId: input.conversationId,
+          profileId: context.profile?.id
+        });
+        if (script) {
+          yield* runScript(script, input, context);
+          yield {
+            type: "thinking",
+            data: { status: "completed", conversationId: input.conversationId }
+          };
+          return;
+        }
+        yield {
+          type: "thinking",
+          data: { status: "script-missing", conversationId: input.conversationId }
+        };
+        yield {
+          type: "message",
+          data: "AgentAgentLoop requires an explicit loop script. Configure profile.scriptReference or provide context.script."
+        };
+        yield {
+          type: "thinking",
+          data: { status: "completed", conversationId: input.conversationId }
+        };
+      };
+    }
+  };
+}
+function getAgentAgentLoopId() {
+  return LOOP_ID;
+}
+
+// src/loops/agent-tool-loop/builtinLoopSources.ts
+var AgentToolLoopDefaultScriptId = "builtin:agent-tool-loop/default";
+var BUILTIN_AGENT_TOOL_LOOP_DEFAULT_SCRIPT_ID = AgentToolLoopDefaultScriptId;
+var builtinAgentToolLoopSources = {
+  [AgentToolLoopDefaultScriptId]: [
+    "// @ts-check",
+    "",
+    "/** @param {import('../../loopAPI/agent-tool-loop/loop.js').AgentToolLoopScriptContext} ctx */",
+    "export default async function* run(ctx) {",
+    "  const state = ctx.createState();",
+    "",
+    "  try {",
+    "    const start = await ctx.startTurn(state);",
+    "    if (start.step) yield start.step;",
+    "    if (start.action === 'stop') return;",
+    "",
+    "    while (true) {",
+    "      const result = yield* ctx.runIteration(state);",
+    "      if (result.action === 'stop') return;",
+    "    }",
+    "  } catch (error) {",
+    "    await ctx.stopTurn(state, 'error');",
+    "    throw error;",
+    "  } finally {",
+    "    await ctx.stopTurn(state);",
+    "  }",
+    "}"
+  ].join("\n")
+};
+function getBuiltinAgentToolLoopSource(id) {
+  return builtinAgentToolLoopSources[id];
+}
+
+// src/loopAPI/agent-tool-loop/scriptLoader.ts
+var builtinDigestsRegistered2;
+function ensureBuiltinDigestsRegistered2() {
+  builtinDigestsRegistered2 ??= registerBuiltinScriptSources(builtinAgentToolLoopSources);
+  return builtinDigestsRegistered2;
+}
+async function loadAgentToolLoopScript(scriptReference, options = {}) {
+  await ensureBuiltinDigestsRegistered2();
+  return loadAgentLoopScript(scriptReference, {
+    ...options,
+    getBuiltinScriptSource: getBuiltinAgentToolLoopSource,
+    scriptType: "AgentToolLoop script"
+  });
+}
+
+// src/loopAPI/agent-tool-loop/scriptRunner.ts
+function isAsyncIterable2(value) {
+  return Boolean(value && typeof value === "object" && Symbol.asyncIterator in value);
+}
+function messageStep2(message) {
+  return { type: "message", data: message };
+}
+async function* drainEmittedSteps2(steps) {
+  while (steps.length > 0) {
+    const step = steps.shift();
+    if (step) yield step;
+  }
+}
+function asAgentToolLoopContext(rawContext) {
+  return rawContext;
+}
+async function resolveAgentToolLoopScript(context) {
+  if (context.script) return context.script;
+  const scriptReference = context.profile?.scriptReference ?? context.profile?.scriptRef ?? context.profile?.script;
+  if (!scriptReference) return void 0;
+  if (context.loadScript) return context.loadScript(scriptReference, context);
+  return loadAgentToolLoopScript(scriptReference, context.scriptPolicy);
+}
+function createAgentToolLoopScriptContext(input, context, emittedSteps) {
+  const emit = (step) => {
+    emittedSteps.push(step);
+    context.runtime?.emit?.(step);
+  };
+  return {
+    input,
+    context,
+    profile: context.profile,
+    createState: () => createAgentToolLoopState(context),
+    startTurn: (state) => startAgentToolLoopTurn(context, input, state),
+    runIteration: (state) => runAgentToolLoopIteration(context, input, state),
+    stopTurn: (state, reason) => stopAgentToolLoopTurn(context, input, state, reason),
+    emit,
+    finish: (message) => {
+      emit(typeof message === "string" ? messageStep2(message) : message);
+    },
+    isCancelled: () => context.runtime?.signal?.cancelled === true || context.agentToolLoop?.isCancelled?.(input.conversationId) === true,
+    log: (event, data) => {
+      context.runtime?.log?.(event, data);
+      context.logger?.debug?.(event, data);
+    }
+  };
+}
+async function* runAgentToolLoopScript(script, input, context) {
+  const emittedSteps = [];
+  const result = await script(createAgentToolLoopScriptContext(input, context, emittedSteps));
+  yield* drainEmittedSteps2(emittedSteps);
+  if (isAsyncIterable2(result)) {
+    yield* result;
+    yield* drainEmittedSteps2(emittedSteps);
+  } else if (typeof result === "string") {
+    yield messageStep2(result);
+  } else if (Array.isArray(result)) {
+    yield* result;
+  } else if (result) {
+    yield result;
+  }
+}
+
+// src/loopAPI/agent-tool-loop/loop.ts
+function createAgentToolLoopDefinition(name = "AgentToolLoop") {
+  return {
+    id: "agent-tool-loop",
+    name,
+    description: "Agent/tool loop that alternates between LLM output and external tool execution.",
+    createRunner: (rawContext) => {
+      const context = asAgentToolLoopContext(rawContext);
+      return async function* agentToolLoop(input) {
+        const script = await resolveAgentToolLoopScript(context);
+        if (script) {
+          yield* runAgentToolLoopScript(script, input, context);
+          return;
+        }
+        yield* createAgentToolLoopRunner(context)(input);
+      };
+    }
+  };
+}
+
+// src/loopAPI/plugins/builtinLoopsPlugin.ts
+var AGENT_TOOL_LOOP_ID = "agent-tool-loop";
+var AGENT_AGENT_LOOP_ID = getAgentAgentLoopId();
+function registerBuiltinLoops() {
+  const registry = getLoopRegistry();
+  if (!registry.getLoop(AGENT_TOOL_LOOP_ID)) {
+    registry.registerLoop(createAgentToolLoopDefinition("AgentToolLoop"));
+  }
+  if (!registry.getLoop(AGENT_AGENT_LOOP_ID)) {
+    registry.registerLoop(createAgentAgentLoopDefinition());
+  }
+}
+
+// src/tools/builtins/askQuestion.ts
+import { z } from "zod";
+
+// src/tools/builtins/questionWaitRegistry.ts
+var pending = /* @__PURE__ */ new Map();
+function resolveQuestionAnswer(questionId, answer) {
+  const p = pending.get(questionId);
+  if (!p) return false;
+  clearTimeout(p.timer);
+  pending.delete(questionId);
+  p.resolve(answer);
+  return true;
+}
+function waitForQuestionAnswer(questionId, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pending.delete(questionId);
+      reject(new Error("askQuestion_timeout"));
+    }, timeoutMs);
+    pending.set(questionId, { resolve, reject, timer });
+  });
+}
+
+// src/tools/builtins/askQuestion.ts
+var askQuestionConfigSchema = z.object({
+  question: z.string().min(1),
+  /**
+   * Desktop / TidGi 的 LLM 工具参数里通常不会显式携带 conversationId，
+   * 由宿主侧上下文负责关联；这里允许缺省，交给宿主回调侧做路由。
+   */
+  conversationId: z.string().min(1).optional(),
+  timeoutMs: z.number().int().positive().max(36e5).optional(),
+  inputType: z.enum(["single-select", "multi-select", "text"]).optional(),
+  options: z.array(
+    z.object({
+      label: z.string(),
+      description: z.string().optional()
+    })
+  ).optional(),
+  allowFreeform: z.boolean().optional().default(true)
+});
+var ASK_QUESTION_TOOL_ID = "ask-question";
+async function askQuestionImpl(arguments_, context) {
+  const parsed = askQuestionConfigSchema.safeParse(arguments_);
+  if (!parsed.success) {
+    return { error: "invalid_askQuestion_args" };
+  }
+  const { question, conversationId, timeoutMs, inputType, options, allowFreeform } = parsed.data;
+  const questionId = crypto.randomUUID();
+  const timeout = timeoutMs ?? 3e5;
+  context.notifyAskQuestion?.({
+    questionId,
+    question,
+    conversationId,
+    inputType,
+    options,
+    allowFreeform
+  });
+  try {
+    const answer = await waitForQuestionAnswer(questionId, timeout);
+    return { result: answer };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : "askQuestion_failed" };
+  }
+}
+
+// src/tools/builtins/askUserQuestion.ts
+import { z as z2 } from "zod";
+var askUserQuestionConfigSchema = z2.object({
+  question: z2.string().min(1).describe("The question to ask the user"),
+  inputType: z2.enum(["text", "single-select", "multi-select"]).optional().default("text").describe("Type of input expected: text, single-select, or multi-select"),
+  options: z2.array(
+    z2.object({
+      label: z2.string().min(1),
+      description: z2.string().optional()
+    })
+  ).optional().describe("Options for single-select or multi-select input types"),
+  allowFreeform: z2.boolean().optional().default(true).describe("Allow free-text input even for select types"),
+  timeoutMs: z2.number().int().positive().max(36e5).optional().default(3e5).describe("Timeout in milliseconds (default 5 minutes)")
+});
+var ASK_USER_QUESTION_TOOL_ID = "askUserQuestion";
+async function askUserQuestionImpl(arguments_, context) {
+  const parsed = askUserQuestionConfigSchema.safeParse(arguments_);
+  if (!parsed.success) {
+    return { error: `invalid_askUserQuestion_args: ${parsed.error.message}` };
+  }
+  const { question, inputType, options, allowFreeform, timeoutMs } = parsed.data;
+  const questionId = crypto.randomUUID();
+  const conversationId = context.agent?.id ?? context.activeToolConversationId;
+  context.notifyAskQuestion?.({
+    questionId,
+    question,
+    conversationId,
+    inputType,
+    options,
+    allowFreeform
+  });
+  try {
+    const answer = await waitForQuestionAnswer(questionId, timeoutMs);
+    return { result: answer };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "askUserQuestion_failed";
+    return { error: message };
+  }
+}
+
+// src/tools/builtins/mcpClient.ts
+var TOOL_ID = "mcpClient";
+var mcpClientConfigSchema = {
+  type: "object",
+  properties: {
+    nodeId: { type: "string", description: "Target node ID" },
+    serverName: { type: "string", description: "MCP server name on that node" },
+    toolName: { type: "string", description: "Tool to invoke" },
+    args: { type: "object", description: "Tool arguments" }
+  },
+  required: ["nodeId", "serverName", "toolName"]
+};
+var mcpClientImpl = async (arguments_, context) => {
+  const nodeId = arguments_.nodeId;
+  const serverName = arguments_.serverName;
+  const toolName = arguments_.toolName;
+  const toolArguments = arguments_.args ?? {};
+  if (!nodeId || !serverName || !toolName) {
+    return {
+      error: "mcpClient requires nodeId, serverName, and toolName"
+    };
+  }
+  if (!context.mcpCallRemote) {
+    return {
+      error: "MCP proxy not configured (no mcpCallRemote in context). Connect to nodes that expose MCP."
+    };
+  }
+  try {
+    const result = await context.mcpCallRemote(nodeId, serverName, toolName, toolArguments);
+    return { result };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { error: `MCP call failed: ${message}` };
+  }
+};
+function getMcpClientToolId() {
+  return TOOL_ID;
+}
+
+// src/tools/builtins/mcpForward.ts
+var TOOL_ID2 = "mcpForward";
+var mcpForwardConfigSchema = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: ["list", "listTools"],
+      description: "Action: 'list' returns nodes with MCP servers, 'listTools' returns all available MCP tools across nodes"
+    }
+  }
+};
+var mcpForwardImpl = async (arguments_, context) => {
+  const action = arguments_.action ?? "list";
+  if (!context.getPeers) {
+    return { error: "Peer list not configured (no getPeers)." };
+  }
+  if (!context.sendRpcToNode) {
+    return { error: "Remote node RPC not configured (no sendRpcToNode)." };
+  }
+  const peers = await context.getPeers();
+  const online = peers.filter((p) => p.reachability.state === "online");
+  if (action === "list") {
+    const result = [];
+    for (const node of online) {
+      try {
+        const response = await context.sendRpcToNode(
+          node.peerId,
+          "memeloop.mcp.listServers",
+          {}
+        );
+        const servers = Array.isArray(response?.servers) ? response.servers : [];
+        if (servers.length > 0) {
+          result.push({
+            nodeId: node.peerId,
+            name: node.displayName,
+            mcpServers: servers
+          });
+        }
+      } catch {
+      }
+    }
+    return { nodes: result };
+  }
+  if (action === "listTools") {
+    const allTools = [];
+    for (const node of online) {
+      try {
+        const response = await context.sendRpcToNode(
+          node.peerId,
+          "memeloop.mcp.listTools",
+          {}
+        );
+        const tools = Array.isArray(response?.tools) ? response.tools : [];
+        for (const tool of tools) {
+          allTools.push({
+            nodeId: node.peerId,
+            serverName: tool.serverName,
+            name: tool.name,
+            description: tool.description
+          });
+        }
+      } catch {
+      }
+    }
+    return { tools: allTools };
+  }
+  return { error: `Unknown action: ${action}` };
+};
+function getMcpForwardToolId() {
+  return TOOL_ID2;
+}
+
+// src/tools/builtins/orchestration.ts
+var ORCHESTRATION_TOOL_ID = "orchestration";
+var orchestrationConfigSchema = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: ["capabilities", "apply", "get", "list", "wait", "delete"],
+      description: "Declarative orchestration resource operation."
+    },
+    resource: {
+      type: "object",
+      description: "Resource manifest for apply. status and actor fields are not accepted."
+    },
+    reference: {
+      type: "object",
+      description: "Resource reference for get, wait, or delete."
+    },
+    query: {
+      type: "object",
+      description: "Resource query for list."
+    },
+    condition: {
+      type: "object",
+      description: "Condition to wait for. Required when action is wait."
+    },
+    options: {
+      type: "object",
+      description: "Operation options. Only documented fields are forwarded."
+    }
+  },
+  required: ["action"]
+};
+function objectValue(value, field) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw invalidError(`${field} must be an object`);
+  }
+  return value;
+}
+function invalidError(message) {
+  return new OrchestrationError({ code: "INVALID", message, retryable: false });
+}
+function optionalString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function optionalBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function stringRecord(value) {
+  if (value === void 0) return void 0;
+  const record = objectValue(value, "record");
+  const entries = Object.entries(record);
+  if (entries.some(([, entry]) => typeof entry !== "string")) {
+    throw invalidError("record values must be strings");
+  }
+  return Object.fromEntries(entries);
+}
+function metadataValue(value) {
+  const metadata = objectValue(value, "resource.metadata");
+  return {
+    name: optionalString(metadata.name),
+    generateName: optionalString(metadata.generateName),
+    namespace: optionalString(metadata.namespace),
+    labels: stringRecord(metadata.labels),
+    annotations: stringRecord(metadata.annotations)
+  };
+}
+function resourceValue(value) {
+  const resource = objectValue(value, "resource");
+  const apiVersion = optionalString(resource.apiVersion);
+  const kind = optionalString(resource.kind);
+  if (!apiVersion || !kind) throw invalidError("resource requires apiVersion and kind");
+  return {
+    apiVersion,
+    kind,
+    metadata: metadataValue(resource.metadata),
+    spec: objectValue(resource.spec, "resource.spec")
+  };
+}
+function referenceValue(value) {
+  const reference = objectValue(value, "reference");
+  const apiVersion = optionalString(reference.apiVersion);
+  const kind = optionalString(reference.kind);
+  const name = optionalString(reference.name);
+  const uid = optionalString(reference.uid);
+  if (!apiVersion || !kind || !name && !uid) {
+    throw invalidError("reference requires apiVersion, kind, and name or uid");
+  }
+  return {
+    apiVersion,
+    kind,
+    name,
+    namespace: optionalString(reference.namespace),
+    uid
+  };
+}
+function queryValue(value) {
+  const query = objectValue(value, "query");
+  const kind = optionalString(query.kind);
+  if (!kind) throw invalidError("query requires kind");
+  return {
+    apiVersion: optionalString(query.apiVersion),
+    kind,
+    namespace: optionalString(query.namespace),
+    labels: stringRecord(query.labels)
+  };
+}
+function preconditionsValue(value) {
+  if (value === void 0) return void 0;
+  const preconditions = objectValue(value, "options.preconditions");
+  return {
+    uid: optionalString(preconditions.uid),
+    resourceVersion: optionalString(preconditions.resourceVersion),
+    generation: typeof preconditions.generation === "number" ? preconditions.generation : void 0
+  };
+}
+function applyOptions(value) {
+  if (value === void 0) return void 0;
+  const options = objectValue(value, "options");
+  return {
+    idempotencyKey: optionalString(options.idempotencyKey),
+    fieldManager: optionalString(options.fieldManager),
+    force: optionalBoolean(options.force),
+    dryRun: optionalBoolean(options.dryRun),
+    preconditions: preconditionsValue(options.preconditions)
+  };
+}
+function getOptions(value) {
+  if (value === void 0) return void 0;
+  const options = objectValue(value, "options");
+  return { resourceVersion: optionalString(options.resourceVersion) };
+}
+function listOptions(value) {
+  if (value === void 0) return void 0;
+  const options = objectValue(value, "options");
+  return {
+    resourceVersion: optionalString(options.resourceVersion),
+    resourceVersionMatch: options.resourceVersionMatch === "exact" || options.resourceVersionMatch === "not-older-than" ? options.resourceVersionMatch : void 0,
+    limit: typeof options.limit === "number" ? options.limit : void 0,
+    continueToken: optionalString(options.continueToken)
+  };
+}
+function deleteOptions(value) {
+  if (value === void 0) return void 0;
+  const options = objectValue(value, "options");
+  const propagationPolicy = options.propagationPolicy;
+  const validPropagationPolicy = propagationPolicy === "orphan" || propagationPolicy === "background" || propagationPolicy === "foreground" ? propagationPolicy : void 0;
+  return {
+    idempotencyKey: optionalString(options.idempotencyKey),
+    preconditions: preconditionsValue(options.preconditions),
+    propagationPolicy: validPropagationPolicy,
+    dryRun: optionalBoolean(options.dryRun)
+  };
+}
+function waitConditionValue(value) {
+  const condition = objectValue(value, "condition");
+  const type = optionalString(condition.type);
+  if (!type) throw invalidError("condition requires type");
+  const status = condition.status === "True" || condition.status === "False" || condition.status === "Unknown" ? condition.status : "True";
+  return { type, status };
+}
+function waitOptions(value) {
+  if (value === void 0) return {};
+  const options = objectValue(value, "options");
+  const timeout = typeof options.timeout === "number" ? options.timeout : void 0;
+  const interval = typeof options.interval === "number" ? options.interval : void 0;
+  if (timeout !== void 0 && timeout <= 0) throw invalidError("timeout must be positive");
+  if (interval !== void 0 && interval <= 0) throw invalidError("interval must be positive");
+  return { timeout, interval };
+}
+async function waitForResourceCondition(context, client, reference, condition, options) {
+  return waitForCondition(
+    () => client.get(reference, { resourceVersion: void 0 }),
+    condition,
+    {
+      ...options,
+      isCancelled: () => context.isCancelled?.() === true || context.activeToolConversationId !== void 0 && context.conversationCancellation?.has(context.activeToolConversationId) === true
+    }
+  );
+}
+var orchestrationImpl = async (arguments_, context) => {
+  const client = context.orchestration;
+  if (!client) {
+    return {
+      error: {
+        code: "UNSUPPORTED",
+        message: "Orchestration manager not configured.",
+        retryable: false
+      }
+    };
+  }
+  try {
+    switch (arguments_.action) {
+      case "capabilities":
+        return await client.getCapabilities();
+      case "apply":
+        return await client.apply(resourceValue(arguments_.resource), applyOptions(arguments_.options));
+      case "get":
+        return await client.get(referenceValue(arguments_.reference), getOptions(arguments_.options));
+      case "list":
+        return await client.list(queryValue(arguments_.query), listOptions(arguments_.options));
+      case "wait":
+        return await waitForResourceCondition(
+          context,
+          client,
+          referenceValue(arguments_.reference),
+          waitConditionValue(arguments_.condition),
+          waitOptions(arguments_.options)
+        );
+      case "delete":
+        return await client.delete(referenceValue(arguments_.reference), deleteOptions(arguments_.options));
+      default:
+        throw invalidError("orchestration requires a supported action");
+    }
+  } catch (error) {
+    return { error: toOrchestrationErrorData(error) };
+  }
+};
+
+// src/tools/builtins/remoteAgent.ts
+var TOOL_ID3 = "remoteAgent";
+var REMOTE_LOG_POLL_INTERVAL_MS = 500;
+var REMOTE_LOG_IDLE_POLLS = 2;
+function messageContentToText(content) {
+  if (typeof content === "string") return content;
+  if (content == null) return "";
+  try {
+    return JSON.stringify(content);
+  } catch {
+    return Object.prototype.toString.call(content);
+  }
+}
+function getRemoteStreamChunkContent(chunk) {
+  if (chunk != null && typeof chunk === "object" && "content" in chunk) {
+    return Reflect.get(chunk, "content");
+  }
+  return void 0;
+}
+function summarizeRemoteMessages(messages) {
+  const relevant = messages.filter((message) => message.role && message.role !== "user");
+  if (relevant.length === 0) {
+    return "(task dispatched; waiting for remote output)";
+  }
+  const joined = relevant.map((message) => {
+    const role = typeof message.role === "string" ? message.role : "message";
+    const content = messageContentToText(message.content).trim();
+    return content.length > 0 ? `[${role}] ${content}` : "";
+  }).filter((line) => line.length > 0).join("\n");
+  return joined.trim() || "(task dispatched; remote messages had no readable content)";
+}
+async function collectRemoteConversationSummary(sendRpc, nodeId, conversationId, timeoutMs) {
+  const startedAt = Date.now();
+  const knownMessageIds = /* @__PURE__ */ new Set();
+  const collectedMessages = [];
+  let idlePolls = 0;
+  while (Date.now() - startedAt < timeoutMs) {
+    const response = await sendRpc(nodeId, "memeloop.chat.pullAgentRunLog", {
+      conversationId,
+      knownMessageIds: [...knownMessageIds]
+    });
+    const newMessages = Array.isArray(response?.messages) ? response.messages : [];
+    if (newMessages.length > 0) {
+      idlePolls = 0;
+      for (const message of newMessages) {
+        if (typeof message.messageId === "string" && message.messageId.length > 0) {
+          knownMessageIds.add(message.messageId);
+        }
+        collectedMessages.push(message);
+      }
+    } else if (collectedMessages.some((message) => message.role && message.role !== "user")) {
+      idlePolls += 1;
+      if (idlePolls >= REMOTE_LOG_IDLE_POLLS) {
+        break;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, REMOTE_LOG_POLL_INTERVAL_MS));
+  }
+  return summarizeRemoteMessages(collectedMessages);
+}
+async function supportsAgentWorkload(client) {
+  try {
+    const caps = await client.getCapabilities();
+    return caps.operations.includes("apply") && caps.resourceKinds.includes("AgentWorkload");
+  } catch {
+    return false;
+  }
+}
+async function runRemoteAgentViaOrchestration(client, nodeId, definitionId, message, localNodeId) {
+  const timestamp = Date.now().toString(36);
+  const conversationId = `remote:${nodeId}:${definitionId}:${timestamp}`;
+  const agents = createAgentClient(client);
+  const workload = await agents.createWorkload({
+    name: conversationId,
+    profileId: definitionId,
+    promptReference: message,
+    completionPolicy: "complete",
+    placement: { requiredNode: nodeId }
+  });
+  const run = await agents.createRun({
+    name: `${conversationId}-run`,
+    workloadName: workload.metadata.name,
+    promptReference: message
+  });
+  const result = await agents.waitForRunCondition(
+    run.metadata.name,
+    { type: "Completed", status: "True" },
+    { timeout: 3e4, interval: 1e3 }
+  );
+  const finalRun = await agents.getRun(run.metadata.name);
+  const summary = finalRun?.status?.summary ?? "(no summary)";
+  const shortSummary = truncateToolSummary(summary);
+  const resolvedNodeId = localNodeId?.trim() || "local";
+  return {
+    summary,
+    remoteNodeId: nodeId,
+    remoteConversationId: conversationId,
+    definitionId,
+    [MEMELOOP_STRUCTURED_TOOL_KEY]: {
+      summary: shortSummary,
+      detailRef: {
+        type: "agent-run",
+        conversationId,
+        nodeId: resolvedNodeId,
+        resourceVersion: result.observedResourceVersion
+      }
+    }
+  };
+}
+var remoteAgentConfigSchema = {
+  type: "object",
+  properties: {
+    nodeId: { type: "string", description: "Target node ID to run the agent-run on" },
+    definitionId: { type: "string", description: "Agent definition ID on that node" },
+    message: { type: "string", description: "Task message for the remote agent" }
+  },
+  required: ["nodeId", "definitionId", "message"]
+};
+var remoteAgentListImpl = async (_arguments, context) => {
+  if (context.orchestration) {
+    try {
+      const caps = await context.orchestration.getCapabilities();
+      const targets = caps.resourceKinds.map((kind) => ({
+        kind,
+        interfaces: caps.interfaces,
+        operations: caps.operations
+      }));
+      return {
+        targets,
+        capabilities: caps.interfaces
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        targets: [],
+        error: `Orchestration target discovery failed: ${message}`
+      };
+    }
+  }
+  return {
+    targets: [],
+    error: "Direct peer enumeration is disabled. Configure an orchestration manager to discover execution targets."
+  };
+};
+var remoteAgentImpl = async (arguments_, context) => {
+  const nodeId = arguments_.nodeId;
+  const definitionId = arguments_.definitionId;
+  const message = arguments_.message;
+  if (!nodeId || !definitionId || typeof message !== "string") {
+    return remoteAgentListImpl(arguments_, context);
+  }
+  try {
+    if (context.orchestration && await supportsAgentWorkload(context.orchestration)) {
+      return await runRemoteAgentViaOrchestration(context.orchestration, nodeId, definitionId, message, context.localNodeId);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : messageContentToText(error);
+    return { error: `remoteAgent failed: ${errorMessage}` };
+  }
+  const sendRpc = context.sendRpcToNode ? async (nodeId2, method, parameters) => context.sendRpcToNode?.(nodeId2, method, parameters) : void 0;
+  if (!sendRpc) {
+    return {
+      error: "Remote node RPC not configured (no sendRpcToNode). Connect to peer nodes first."
+    };
+  }
+  try {
+    const createResult = await sendRpc(nodeId, "memeloop.agent.create", {
+      definitionId
+    });
+    const conversationId = createResult?.conversationId;
+    if (!conversationId) {
+      return { error: "Remote agent.create did not return conversationId", raw: createResult };
+    }
+    await sendRpc(nodeId, "memeloop.agent.send", {
+      conversationId,
+      message
+    });
+    const subscribeStream = context.subscribeRemoteStream;
+    const streamWaitMs = context.remoteAgentStreamTimeoutMs ?? 3e4;
+    const chunks = [];
+    if (subscribeStream) {
+      await new Promise((resolve) => {
+        const unsub = subscribeStream(nodeId, conversationId, (chunk) => {
+          if (typeof chunk === "string") chunks.push(chunk);
+          else {
+            const chunkContent = getRemoteStreamChunkContent(chunk);
+            if (chunkContent !== void 0) {
+              chunks.push(messageContentToText(chunkContent));
+            }
+          }
+        });
+        setTimeout(() => {
+          unsub();
+          resolve();
+        }, streamWaitMs);
+      });
+    }
+    const fullSummary = chunks.length > 0 ? chunks.join("").trim() : await collectRemoteConversationSummary(sendRpc, nodeId, conversationId, streamWaitMs);
+    const shortSummary = truncateToolSummary(fullSummary);
+    return {
+      summary: fullSummary,
+      remoteNodeId: nodeId,
+      remoteConversationId: conversationId,
+      definitionId,
+      [MEMELOOP_STRUCTURED_TOOL_KEY]: {
+        summary: shortSummary,
+        detailRef: {
+          type: "agent-run",
+          conversationId,
+          nodeId
+        }
+      }
+    };
+  } catch (error) {
+    const message2 = error instanceof Error ? error.message : messageContentToText(error);
+    return { error: `remoteAgent failed: ${message2}` };
+  }
+};
+function getRemoteAgentToolId() {
+  return TOOL_ID3;
+}
+
+// src/tools/builtins/spawnAgent.ts
+var TOOL_ID4 = "spawnAgent";
+async function supportsAgentWorkload2(client) {
+  try {
+    const caps = await client.getCapabilities();
+    return caps.operations.includes("apply") && caps.resourceKinds.includes("AgentWorkload");
+  } catch {
+    return false;
+  }
+}
+async function runSpawnAgentViaOrchestration(client, definitionId, message, conversationId, localNodeId) {
+  const agents = createAgentClient(client);
+  const workload = await agents.createWorkload({
+    name: conversationId,
+    profileId: definitionId,
+    completionPolicy: "complete"
+  });
+  const run = await agents.createRun({
+    name: `${conversationId}-run`,
+    workloadName: workload.metadata.name,
+    promptReference: message
+  });
+  const result = await agents.waitForRunCondition(
+    run.metadata.name,
+    { type: "Completed", status: "True" },
+    { timeout: 3e4, interval: 1e3 }
+  );
+  const finalRun = await agents.getRun(run.metadata.name);
+  const summary = finalRun?.status?.summary ?? "(no summary)";
+  const shortSummary = truncateToolSummary(summary);
+  const nodeId = localNodeId?.trim() || "local";
+  return {
+    summary,
+    conversationId,
+    definitionId,
+    [MEMELOOP_STRUCTURED_TOOL_KEY]: {
+      summary: shortSummary,
+      detailRef: {
+        type: "agent-run",
+        conversationId,
+        nodeId,
+        resourceVersion: result.observedResourceVersion
+      }
+    }
+  };
+}
+async function runSpawnAgentLocally(runLocalAgent, definitionId, message, conversationId, localNodeId) {
+  const chunks = [];
+  for await (const step of runLocalAgent({ conversationId, message })) {
+    if (step.type === "message" && typeof step.data === "string") {
+      chunks.push(step.data);
+    }
+    if (step.type === "message" && step.data != null && typeof step.data === "object" && "content" in step.data) {
+      const c = step.data.content;
+      if (typeof c === "string") chunks.push(c);
+    }
+  }
+  const fullSummary = chunks.join("").trim() || "(no text output)";
+  const shortSummary = truncateToolSummary(fullSummary);
+  const nodeId = localNodeId?.trim() || "local";
+  return {
+    summary: fullSummary,
+    conversationId,
+    definitionId,
+    [MEMELOOP_STRUCTURED_TOOL_KEY]: {
+      summary: shortSummary,
+      detailRef: {
+        type: "agent-run",
+        conversationId,
+        nodeId
+      }
+    }
+  };
+}
+var spawnAgentConfigSchema = {
+  type: "object",
+  properties: {
+    definitionId: { type: "string", description: "Agent definition ID to use for the agent-run" },
+    message: { type: "string", description: "User message / task for the agent-run" }
+  },
+  required: ["definitionId", "message"]
+};
+var spawnAgentImpl = async (arguments_, context) => {
+  const definitionId = arguments_.definitionId;
+  const message = arguments_.message;
+  if (!definitionId || typeof message !== "string") {
+    return { error: "spawnAgent requires definitionId and message" };
+  }
+  const conversationId = `spawn:${definitionId}:${Date.now().toString(36)}`;
+  try {
+    if (context.orchestration && await supportsAgentWorkload2(context.orchestration)) {
+      return await runSpawnAgentViaOrchestration(context.orchestration, definitionId, message, conversationId, context.localNodeId);
+    }
+    if (!context.runLocalAgent) {
+      return {
+        error: "Local agent runner not configured (no runLocalAgent in context)."
+      };
+    }
+    return await runSpawnAgentLocally(
+      (input) => context.runLocalAgent(input),
+      definitionId,
+      message,
+      conversationId,
+      context.localNodeId
+    );
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return { error: `spawnAgent failed: ${errorMessage}`, conversationId };
+  }
+};
+function getSpawnAgentToolId() {
+  return TOOL_ID4;
+}
+
+// src/agent/agentProfiles.ts
+function makeBuiltinDefinition(id, name, type, prompt, permissions, model) {
+  const systemPrompt = prompt;
+  const tools = [];
+  return {
+    id,
+    name,
+    type,
+    prompt,
+    permissions,
+    model,
+    protocolDef: {
+      id,
+      name,
+      description: prompt.slice(0, 200),
+      systemPrompt,
+      tools,
+      version: "1.0.0",
+      modelConfig: model ? {
+        provider: model.split("/")[0] ?? "memeloop",
+        model: model.split("/").slice(1).join("/") || model
+      } : void 0
+    }
+  };
+}
+var buildAgent = makeBuiltinDefinition(
+  "memeloop:build",
+  "Build Agent",
+  "build",
+  "You are a build agent capable of executing tasks, writing and editing files, running commands, and making changes. Use tools to accomplish the user's goals efficiently.",
+  { default: "allow", rules: [] }
+);
+var planAgent = makeBuiltinDefinition(
+  "memeloop:plan",
+  "Plan Agent",
+  "plan",
+  "You are a planning agent. Your role is to analyze requirements, decompose tasks, and create structured plans. You CANNOT write files or execute terminal commands. Only use read and search tools.",
+  {
+    default: "deny",
+    rules: [
+      { pattern: "file.read", action: "allow" },
+      { pattern: "file.search", action: "allow" },
+      { pattern: "file.list", action: "allow" },
+      { pattern: "grep.search", action: "allow" },
+      { pattern: "glob.*", action: "allow" }
+    ]
+  }
+);
+var exploreAgent = makeBuiltinDefinition(
+  "memeloop:explore",
+  "Explore Agent",
+  "explore",
+  "You are an exploration agent specialized in fast codebase search and discovery. You have read and search tools. Do NOT modify files or run terminal commands. Focus on finding relevant code, files, and patterns.",
+  {
+    default: "deny",
+    rules: [
+      { pattern: "file.read", action: "allow" },
+      { pattern: "file.search", action: "allow" },
+      { pattern: "file.list", action: "allow" },
+      { pattern: "grep.search", action: "allow" },
+      { pattern: "glob.*", action: "allow" },
+      { pattern: "lsp.*", action: "allow" }
+    ]
+  }
+);
+var oracleAgent = makeBuiltinDefinition(
+  "memeloop:oracle",
+  "Oracle Agent",
+  "oracle",
+  "You are an oracle agent specialized in architecture analysis, code review, and constraint verification. You have read access only. Review code, identify issues, and provide expert architectural guidance.",
+  {
+    default: "deny",
+    rules: [
+      { pattern: "file.read", action: "allow" },
+      { pattern: "file.search", action: "allow" },
+      { pattern: "file.list", action: "allow" },
+      { pattern: "grep.search", action: "allow" },
+      { pattern: "glob.*", action: "allow" },
+      { pattern: "lsp.*", action: "allow" }
+    ]
+  }
+);
+var librarianAgent = makeBuiltinDefinition(
+  "memeloop:librarian",
+  "Librarian Agent",
+  "librarian",
+  "You are a librarian agent specialized in external documentation lookup, web search, and context gathering. Use web search tools to find relevant documentation, APIs, and examples. Do NOT modify files or run terminal commands.",
+  {
+    default: "deny",
+    rules: [
+      { pattern: "file.read", action: "allow" },
+      { pattern: "file.search", action: "allow" },
+      { pattern: "file.list", action: "allow" },
+      { pattern: "web.*", action: "allow" },
+      { pattern: "grep.search", action: "allow" },
+      { pattern: "glob.*", action: "allow" }
+    ]
+  }
+);
+var BUILTIN_AGENT_PROFILES = [
+  buildAgent,
+  planAgent,
+  exploreAgent,
+  oracleAgent,
+  librarianAgent
+];
+
+// src/agent/agentProfileRegistry.ts
+var AgentProfileRegistry = class {
+  profiles = /* @__PURE__ */ new Map();
+  constructor() {
+    this.seedDefaults();
+  }
+  /** Seed the registry with built-in agent profiles. */
+  seedDefaults() {
+    for (const profile of BUILTIN_AGENT_PROFILES) {
+      this.profiles.set(profile.id, profile);
+    }
+  }
+  /**
+   * Register a new agent profile or override an existing one.
+   * Throws if the profile is invalid.
+   */
+  registerAgentProfile(profile) {
+    if (!profile.id || typeof profile.id !== "string" || profile.id.trim().length === 0) {
+      throw new Error("Agent profile must have a non-empty id");
+    }
+    if (!profile.name || typeof profile.name !== "string") {
+      throw new Error("Agent profile must have a name");
+    }
+    if (!profile.type || typeof profile.type !== "string") {
+      throw new Error("Agent profile must have a type");
+    }
+    if (!profile.prompt || typeof profile.prompt !== "string") {
+      throw new Error("Agent profile must have a prompt");
+    }
+    if (!profile.permissions || typeof profile.permissions.default !== "string") {
+      throw new Error("Agent profile must have valid permissions");
+    }
+    this.profiles.set(profile.id, profile);
+  }
+  /**
+   * Get an agent profile by ID.
+   * Returns undefined if not found.
+   */
+  getAgentProfile(id) {
+    return this.profiles.get(id);
+  }
+  /**
+   * List all registered agent profiles.
+   */
+  listAgentProfiles() {
+    return Array.from(this.profiles.values());
+  }
+  /**
+   * List agent profiles filtered by type.
+   */
+  listAgentProfilesByType(type) {
+    return this.listAgentProfiles().filter((profile) => profile.type === type);
+  }
+  /**
+   * Remove an agent profile by ID.
+   */
+  unregisterAgentProfile(id) {
+    return this.profiles.delete(id);
+  }
+  /**
+   * Reset the registry to only built-in defaults.
+   */
+  reset() {
+    this.profiles.clear();
+    this.seedDefaults();
+  }
+};
+var defaultRegistry = null;
+function getAgentProfileRegistry() {
+  if (!defaultRegistry) {
+    defaultRegistry = new AgentProfileRegistry();
+  }
+  return defaultRegistry;
+}
+function resetAgentProfileRegistry() {
+  if (defaultRegistry) {
+    defaultRegistry.reset();
+  }
+  defaultRegistry = null;
+}
+
+// src/tools/builtins/task.ts
+var TOOL_ID5 = "task";
+async function supportsAgentWorkload3(client) {
+  try {
+    const caps = await client.getCapabilities();
+    return caps.operations.includes("apply") && caps.resourceKinds.includes("AgentWorkload");
+  } catch {
+    return false;
+  }
+}
+async function runTaskViaOrchestration(client, agentId, prompt, background, localNodeId, conversationId, permissions) {
+  const agents = createAgentClient(client);
+  const workload = await agents.createWorkload({
+    name: conversationId,
+    profileId: agentId,
+    promptReference: prompt,
+    completionPolicy: background ? "detach" : "complete",
+    toolPolicy: {
+      defaultAction: permissions.default,
+      rules: permissions.rules
+    }
+  });
+  const run = await agents.createRun({
+    name: `${conversationId}-run`,
+    workloadName: workload.metadata.name,
+    promptReference: prompt
+  });
+  const nodeId = localNodeId?.trim() || "local";
+  if (background) {
+    return {
+      summary: `Background task "${agentId}" launched. Task ID: ${conversationId}`,
+      conversationId,
+      agentId,
+      taskId: conversationId,
+      background: true,
+      [MEMELOOP_STRUCTURED_TOOL_KEY]: {
+        summary: `[bg-task] ${agentId}: ${conversationId}`,
+        detailRef: {
+          type: "agent-run",
+          conversationId,
+          nodeId,
+          resourceVersion: run.metadata.resourceVersion
+        }
+      }
+    };
+  }
+  const result = await agents.waitForRunCondition(
+    run.metadata.name,
+    { type: "Completed", status: "True" },
+    { timeout: 3e4, interval: 1e3 }
+  );
+  const finalRun = await agents.getRun(run.metadata.name);
+  const text = finalRun?.status?.summary ?? "(no summary)";
+  const shortSummary = truncateToolSummary(text);
+  return {
+    result: text,
+    conversationId,
+    agentId,
+    [MEMELOOP_STRUCTURED_TOOL_KEY]: {
+      summary: shortSummary,
+      detailRef: {
+        type: "agent-run",
+        conversationId,
+        nodeId,
+        resourceVersion: result.observedResourceVersion
+      }
+    }
+  };
+}
+async function runTaskLocally(runLocalAgent, context, agentId, prompt, background, conversationId) {
+  async function collectOutput(gen2) {
+    const chunks = [];
+    for await (const step of gen2) {
+      if (step.type === "message") {
+        if (typeof step.data === "string") {
+          chunks.push(step.data);
+        } else if (step.data != null && typeof step.data === "object" && "content" in step.data) {
+          const c = step.data.content;
+          if (typeof c === "string") chunks.push(c);
+        }
+      }
+    }
+    return { text: chunks.join("").trim() || "(no text output)", conversationId };
+  }
+  if (background) {
+    const gen2 = runLocalAgent({ conversationId, message: prompt });
+    void collectOutput(gen2).catch(() => {
+    });
+    const nodeId2 = context.localNodeId?.trim() || "local";
+    return {
+      summary: `Background task "${agentId}" launched. Task ID: ${conversationId}`,
+      conversationId,
+      agentId,
+      taskId: conversationId,
+      background: true,
+      [MEMELOOP_STRUCTURED_TOOL_KEY]: {
+        summary: `[bg-task] ${agentId}: ${conversationId}`,
+        detailRef: {
+          type: "agent-run",
+          conversationId,
+          nodeId: nodeId2
+        }
+      }
+    };
+  }
+  const gen = runLocalAgent({ conversationId, message: prompt });
+  const { text, conversationId: cid } = await collectOutput(gen);
+  const shortSummary = truncateToolSummary(text);
+  const nodeId = context.localNodeId?.trim() || "local";
+  return {
+    result: text,
+    conversationId: cid,
+    agentId,
+    [MEMELOOP_STRUCTURED_TOOL_KEY]: {
+      summary: shortSummary,
+      detailRef: {
+        type: "agent-run",
+        conversationId: cid,
+        nodeId
+      }
+    }
+  };
+}
+var taskToolConfigSchema = {
+  type: "object",
+  properties: {
+    agent: {
+      type: "string",
+      description: "Agent ID to delegate to (e.g. 'memeloop:build', 'memeloop:explore')"
+    },
+    prompt: {
+      type: "string",
+      description: "Task prompt / instructions for the delegated agent"
+    },
+    background: {
+      type: "boolean",
+      description: "If true, runs asynchronously and returns a task ID immediately"
+    }
+  },
+  required: ["agent", "prompt"]
+};
+function isTooDeeplyNested(context) {
+  const cid = context.activeToolConversationId;
+  if (!cid) return false;
+  const depth = cid.split(":").length - 1;
+  return depth > 2;
+}
+function applyAgentPermissions(context, agentId, defaultAction, rules) {
+  const tp = context.agentToolLoop ?? (context.agentToolLoop = {});
+  const tperm = tp.toolPermissions ?? (tp.toolPermissions = {});
+  const perAgent = tperm.perAgent ?? (tperm.perAgent = {});
+  perAgent[agentId] = { default: defaultAction, rules };
+}
+var taskToolImpl = async (arguments_, context) => {
+  const agentId = arguments_.agent;
+  const prompt = arguments_.prompt;
+  const background = arguments_.background;
+  if (!agentId || typeof prompt !== "string" || prompt.trim().length === 0) {
+    return { error: "task requires 'agent' (string) and 'prompt' (non-empty string)" };
+  }
+  if (isTooDeeplyNested(context)) {
+    return {
+      error: "Maximum agent nesting depth exceeded. Cannot delegate further."
+    };
+  }
+  const registry = getAgentProfileRegistry();
+  const agentProfile = registry.getAgentProfile(agentId);
+  if (!agentProfile) {
+    const available = registry.listAgentProfiles().map((a) => a.id).join(", ");
+    return {
+      error: `Agent "${agentId}" not found in registry. Available: [${available}]`
+    };
+  }
+  const permissions = {
+    default: agentProfile.permissions.default,
+    rules: agentProfile.permissions.rules
+  };
+  const timestamp = Date.now().toString(36);
+  const conversationId = `${agentProfile.id}:${timestamp}`;
+  try {
+    if (context.orchestration && await supportsAgentWorkload3(context.orchestration)) {
+      return await runTaskViaOrchestration(
+        context.orchestration,
+        agentProfile.id,
+        prompt,
+        background,
+        context.localNodeId,
+        conversationId,
+        permissions
+      );
+    }
+    if (!context.runLocalAgent) {
+      return {
+        error: "Local agent runner not configured (no runLocalAgent in context)."
+      };
+    }
+    applyAgentPermissions(
+      context,
+      agentProfile.id,
+      permissions.default,
+      permissions.rules
+    );
+    return await runTaskLocally(
+      (input) => context.runLocalAgent(input),
+      context,
+      agentProfile.id,
+      prompt,
+      background,
+      conversationId
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      error: `Task execution failed: ${message}`,
+      conversationId,
+      agentId: agentProfile.id
+    };
+  }
+};
+function getTaskToolId() {
+  return TOOL_ID5;
+}
+
+// src/tools/builtins/todoWrite.ts
+import { z as z3 } from "zod";
+var todoWriteConfigSchema = z3.object({
+  action: z3.enum(["create", "update", "complete", "list", "remove"]).describe("Action: create, update, complete, list, or remove"),
+  id: z3.string().min(1).optional().describe("Todo item ID (required for update/complete/remove)"),
+  content: z3.string().min(1).optional().describe("Todo item content (required for create/update)"),
+  status: z3.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe("Status (defaults to 'pending' for create)"),
+  priority: z3.enum(["high", "medium", "low"]).optional().default("medium").describe("Priority level")
+});
+var TODO_WRITE_TOOL_ID = "todoWrite";
+var conversationTodos = /* @__PURE__ */ new Map();
+function __clearTodoStore() {
+  conversationTodos.clear();
+}
+function getConversationTodos(conversationId) {
+  let todos = conversationTodos.get(conversationId);
+  if (!todos) {
+    todos = /* @__PURE__ */ new Map();
+    conversationTodos.set(conversationId, todos);
+  }
+  return todos;
+}
+function formatTodoList(todos) {
+  if (todos.size === 0) {
+    return "(No todos)";
+  }
+  const statusOrder = {
+    in_progress: 0,
+    pending: 1,
+    completed: 2,
+    cancelled: 3
+  };
+  const sorted = [...todos.values()].sort(
+    (a, b) => (statusOrder[a.status] ?? 99) - (statusOrder[b.status] ?? 99) || b.updatedAt - a.updatedAt
+  );
+  const statusIcons = {
+    pending: "\u25CB",
+    in_progress: "\u25C9",
+    completed: "\u2713",
+    cancelled: "\u2717"
+  };
+  return sorted.map(
+    (t) => `${statusIcons[t.status] ?? "?"} [${t.priority}] ${t.content} (id: ${t.id})`
+  ).join("\n");
+}
+function getConversationId(context) {
+  return context.agent?.id ?? context.activeToolConversationId ?? "default";
+}
+async function todoWriteImpl(arguments_, context) {
+  const parsed = todoWriteConfigSchema.safeParse(arguments_);
+  if (!parsed.success) {
+    return { error: `invalid_todoWrite_args: ${parsed.error.message}` };
+  }
+  const { action, id, content, status, priority } = parsed.data;
+  const conversationId = getConversationId(context);
+  const todos = getConversationTodos(conversationId);
+  const now = Date.now();
+  switch (action) {
+    case "create": {
+      if (!content) {
+        return { error: "content is required for create action" };
+      }
+      const newId = id ?? crypto.randomUUID();
+      if (todos.has(newId)) {
+        return { error: `Todo with id '${newId}' already exists. Use update action.` };
+      }
+      const item = {
+        id: newId,
+        content,
+        status: status ?? "pending",
+        priority,
+        createdAt: now,
+        updatedAt: now
+      };
+      todos.set(newId, item);
+      return {
+        result: `Todo created: [${item.priority}] ${item.content} (id: ${item.id})
+
+${formatTodoList(todos)}`
+      };
+    }
+    case "update": {
+      if (!id) {
+        return { error: "id is required for update action" };
+      }
+      const existing = todos.get(id);
+      if (!existing) {
+        return { error: `Todo with id '${id}' not found` };
+      }
+      if (content !== void 0) existing.content = content;
+      if (status !== void 0) existing.status = status;
+      existing.priority = priority ?? existing.priority;
+      existing.updatedAt = now;
+      return {
+        result: `Todo updated: [${existing.priority}] ${existing.content} (id: ${existing.id}, status: ${existing.status})
+
+${formatTodoList(todos)}`
+      };
+    }
+    case "complete": {
+      if (!id) {
+        return { error: "id is required for complete action" };
+      }
+      const existing = todos.get(id);
+      if (!existing) {
+        return { error: `Todo with id '${id}' not found` };
+      }
+      existing.status = "completed";
+      existing.updatedAt = now;
+      return {
+        result: `Todo completed: [${existing.priority}] ${existing.content} (id: ${existing.id})
+
+${formatTodoList(todos)}`
+      };
+    }
+    case "remove": {
+      if (!id) {
+        let removed2 = 0;
+        for (const [key, item] of todos) {
+          if (item.status === "completed" || item.status === "cancelled") {
+            todos.delete(key);
+            removed2++;
+          }
+        }
+        return {
+          result: `Removed ${removed2} completed/cancelled todo(s)
+
+${formatTodoList(todos)}`
+        };
+      }
+      const removed = todos.delete(id);
+      return {
+        result: removed ? `Todo removed: ${id}
+
+${formatTodoList(todos)}` : `Todo with id '${id}' not found
+
+${formatTodoList(todos)}`
+      };
+    }
+    case "list":
+    default: {
+      return {
+        result: `Todo list (${todos.size} items):
+
+${formatTodoList(todos)}`
+      };
+    }
+  }
+}
+
+// src/loopAPI/plugins/builtinToolsPlugin.ts
+var PLUGIN_MCP_CLIENT = "builtin:mcp-client";
+var PLUGIN_MCP_FORWARD = "builtin:mcp-forward";
+var PLUGIN_ORCHESTRATION = "builtin:orchestration";
+var PLUGIN_SPAWN_AGENT = "builtin:spawn-agent";
+var PLUGIN_REMOTE_AGENT = "builtin:remote-agent";
+var PLUGIN_ASK_QUESTION = "builtin:ask-question";
+var PLUGIN_TODO_WRITE = "builtin:todo-write";
+var PLUGIN_ASK_USER_QUESTION = "builtin:ask-user-question";
+var PLUGIN_TASK = "builtin:task";
+var BUILTIN_TOOL_PLUGIN_IDS = [
+  PLUGIN_MCP_CLIENT,
+  PLUGIN_MCP_FORWARD,
+  PLUGIN_ORCHESTRATION,
+  PLUGIN_SPAWN_AGENT,
+  PLUGIN_REMOTE_AGENT,
+  PLUGIN_ASK_QUESTION,
+  PLUGIN_TODO_WRITE,
+  PLUGIN_ASK_USER_QUESTION,
+  PLUGIN_TASK
+];
+function getToolRegistry(context) {
+  return context.toolRegistry;
+}
+function createBuiltinToolPlugin(options) {
+  return {
+    id: options.id,
+    targetLoopId: "*",
+    install: (context) => {
+      const registry = getToolRegistry(context);
+      if (!registry) return;
+      const builtinContext = context;
+      const implementation = (arguments_) => options.implementation(arguments_, builtinContext);
+      if (options.effect === void 0) {
+        registry.registerTool(options.toolId, implementation, options.schema);
+      } else {
+        registry.registerTool(
+          options.toolId,
+          implementation,
+          options.schema,
+          options.effect
+        );
+      }
+      registerToolParameterSchema(options.toolId, options.schema, options.metadata);
+    }
+  };
+}
+var builtinToolPlugins = [
+  createBuiltinToolPlugin({
+    id: PLUGIN_MCP_CLIENT,
+    toolId: getMcpClientToolId(),
+    schema: mcpClientConfigSchema,
+    metadata: {
+      displayName: "MCP Client",
+      description: "Call a tool on a remote MCP server (transparent proxy). Requires nodeId, serverName, toolName, and optional args."
+    },
+    implementation: mcpClientImpl
+  }),
+  createBuiltinToolPlugin({
+    id: PLUGIN_MCP_FORWARD,
+    toolId: getMcpForwardToolId(),
+    schema: mcpForwardConfigSchema,
+    metadata: {
+      displayName: "MCP Forward",
+      description: "Discover MCP servers and tools on connected nodes. Use action='list' for nodes with servers, action='listTools' for all available tools."
+    },
+    implementation: mcpForwardImpl
+  }),
+  createBuiltinToolPlugin({
+    id: PLUGIN_ORCHESTRATION,
+    toolId: ORCHESTRATION_TOOL_ID,
+    schema: orchestrationConfigSchema,
+    metadata: {
+      displayName: "Orchestration",
+      description: "Discover and manage declarative resources through the policy-scoped orchestration manager."
+    },
+    implementation: orchestrationImpl
+  }),
+  createBuiltinToolPlugin({
+    id: PLUGIN_SPAWN_AGENT,
+    toolId: getSpawnAgentToolId(),
+    schema: spawnAgentConfigSchema,
+    metadata: {
+      displayName: "Spawn Agent",
+      description: "Run a local agent-agent-loop with the given definition and message. Returns summary."
+    },
+    implementation: spawnAgentImpl
+  }),
+  createBuiltinToolPlugin({
+    id: PLUGIN_REMOTE_AGENT,
+    toolId: getRemoteAgentToolId(),
+    schema: remoteAgentConfigSchema,
+    metadata: {
+      displayName: "Remote Agent",
+      description: "Create and run a agent-agent-loop on a remote node. Requires nodeId, definitionId, message. List nodes with no args."
+    },
+    implementation: remoteAgentImpl
+  }),
+  createBuiltinToolPlugin({
+    id: PLUGIN_ASK_QUESTION,
+    toolId: ASK_QUESTION_TOOL_ID,
+    schema: askQuestionConfigSchema,
+    metadata: {
+      displayName: "Ask Question",
+      description: "Block until the user answers (via memeloop.agent.resolveQuestion RPC). Args: question, conversationId, optional timeoutMs."
+    },
+    implementation: askQuestionImpl
+  }),
+  createBuiltinToolPlugin({
+    id: PLUGIN_TODO_WRITE,
+    toolId: TODO_WRITE_TOOL_ID,
+    effect: "update",
+    schema: todoWriteConfigSchema,
+    metadata: {
+      displayName: "Todo Write",
+      description: "Manage structured todo lists: create, update, complete, list, remove. Todos scoped per conversation."
+    },
+    implementation: todoWriteImpl
+  }),
+  createBuiltinToolPlugin({
+    id: PLUGIN_ASK_USER_QUESTION,
+    toolId: ASK_USER_QUESTION_TOOL_ID,
+    schema: askUserQuestionConfigSchema,
+    metadata: {
+      displayName: "Ask User Question",
+      description: "Pause agent and ask user a question. Supports text, single-select, and multi-select input types. Blocks until answered."
+    },
+    implementation: askUserQuestionImpl
+  }),
+  createBuiltinToolPlugin({
+    id: PLUGIN_TASK,
+    toolId: getTaskToolId(),
+    schema: taskToolConfigSchema,
+    metadata: {
+      displayName: "Task Delegation",
+      description: "Delegate a task to a specialized agent-agent-loop (build, plan, explore, oracle, librarian). Supports sync (default) and background modes."
+    },
+    implementation: taskToolImpl
+  })
+];
+function getBuiltinToolPlugins() {
+  return builtinToolPlugins;
+}
+function registerBuiltinToolPlugins() {
+  const loopRegistry = getLoopRegistry();
+  for (const plugin of builtinToolPlugins) {
+    if (loopRegistry.getPlugin(plugin.id)) continue;
+    loopRegistry.registerPlugin(plugin);
+  }
+}
+
+// src/promptUtilities/builtinPromptPlugins.ts
+var FULL_REPLACEMENT_PLUGIN_TOOL_ID = "fullReplacement";
+var DYNAMIC_POSITION_PLUGIN_TOOL_ID = "dynamicPosition";
+function registerFullReplacement(reg) {
+  if (reg.has(FULL_REPLACEMENT_PLUGIN_TOOL_ID)) return;
+  reg.set(FULL_REPLACEMENT_PLUGIN_TOOL_ID, (hooks) => {
+    hooks.processPrompts.tapAsync(
+      "fullReplacementLite",
+      (context, callback) => {
+        const msgs = context.messages;
+        if (!Array.isArray(msgs)) {
+          callback();
+          return;
+        }
+        const maxChars = context?.maxReplacementChars ?? 48e3;
+        if (!Number.isFinite(maxChars) || maxChars <= 0) {
+          callback();
+          return;
+        }
+        let total = 0;
+        const kept = [];
+        for (let index = msgs.length - 1; index >= 0; index--) {
+          const m = msgs[index];
+          const c = typeof m?.content === "string" ? m.content : m?.content != null ? JSON.stringify(m.content) : "";
+          total += c.length;
+          if (total > maxChars) break;
+          kept.push(m);
+        }
+        kept.reverse();
+        context.messages = kept;
+        callback();
+      }
+    );
+  });
+}
+function registerDynamicPosition(reg) {
+  if (reg.has(DYNAMIC_POSITION_PLUGIN_TOOL_ID)) return;
+  reg.set(DYNAMIC_POSITION_PLUGIN_TOOL_ID, (hooks) => {
+    hooks.processPrompts.tapAsync(
+      "dynamicPositionLite",
+      (context, callback) => {
+        const prompts = context.prompts;
+        const messages = context.messages;
+        if (!Array.isArray(prompts) || prompts.length < 2 || !Array.isArray(messages)) {
+          callback();
+          return;
+        }
+        const userTurns = messages.filter((m) => m?.role === "user").length;
+        if (userTurns < 2) {
+          callback();
+          return;
+        }
+        const deferred = [];
+        const rest = [];
+        for (const n of prompts) {
+          if (n?.dynamicPosition === "deferToEnd") deferred.push(n);
+          else rest.push(n);
+        }
+        if (deferred.length === 0) {
+          callback();
+          return;
+        }
+        context.prompts = [...rest, ...deferred];
+        callback();
+      }
+    );
+  });
+}
+function registerBuiltinPromptPlugins(target) {
+  const reg = target ?? getActivePluginRegistry();
+  registerFullReplacement(reg);
+  registerDynamicPosition(reg);
+}
+
+// src/runtime.ts
+async function drainAgentLoop(gen, conversationId, notify) {
+  try {
+    for await (const step of gen) {
+      notify(conversationId, { type: "agent-step", step });
+    }
+    notify(conversationId, { type: "agent-done" });
+  } catch (error) {
+    notify(conversationId, {
+      type: "agent-error",
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function inferDefinitionIdFromConversationId(conversationId) {
+  const parts = conversationId.split(":");
+  if (parts.length >= 2) return parts.slice(0, -1).join(":");
+  return conversationId;
+}
+async function resolveDefinitionId(context, conversationId) {
+  try {
+    const meta = await context.storage.getConversationMeta(conversationId);
+    if (meta?.definitionId) return meta.definitionId;
+  } catch {
+  }
+  return inferDefinitionIdFromConversationId(conversationId);
+}
+async function resolveLoopProfile(context, definitionId) {
+  const definition = (context.resolveAgentDefinition ? await context.resolveAgentDefinition(definitionId) : null) ?? await context.storage.getAgentDefinition(definitionId) ?? getBuiltinLoopProfile(definitionId) ?? null;
+  if (!definition) return null;
+  return definition;
+}
+async function createProfileRunner(context, definitionId, runtime) {
+  const profile = await resolveLoopProfile(context, definitionId);
+  if (!profile) return null;
+  return createAgentProfileRunner(context, profile, runtime);
+}
+async function createAgentProfileRunner(context, profile, runtime) {
+  registerBuiltinLoops();
+  registerBuiltinToolPlugins();
+  registerBuiltinPromptPlugins(context.tools.getPromptPlugins?.());
+  const runnerContext = {
+    ...context,
+    runtime,
+    scriptPolicy: context.loopScriptPolicy,
+    toolRegistry: context.tools
+  };
+  return getLoopRegistry().createRunnerForProfile(profile, runnerContext);
+}
+async function createAgentLoopScriptRunner(context, profile, conversationId) {
+  const cancellation = context.conversationCancellation ?? /* @__PURE__ */ new Set();
+  context.conversationCancellation ??= cancellation;
+  const scriptState = /* @__PURE__ */ new Map();
+  return createAgentProfileRunner(
+    context,
+    profile,
+    createScriptRuntime(context, cancellation, scriptState, conversationId)
+  );
+}
+function createScriptRuntime(context, cancellation, scriptState, conversationId, parentConversationId) {
+  const stateKey = (key) => `${conversationId}:${key}`;
+  return {
+    orchestration: context.orchestration,
+    scriptDeployment: context.scriptDeployment,
+    runChildAgent: async function* (input) {
+      const childRuntime = createScriptRuntime(
+        context,
+        cancellation,
+        scriptState,
+        input.conversationId,
+        conversationId
+      );
+      const run = await createProfileRunner(context, input.profileId, childRuntime);
+      if (!run) {
+        yield {
+          type: "message",
+          data: `Child agent profile not found: ${input.profileId}`
+        };
+        return;
+      }
+      yield* run({ conversationId: input.conversationId, message: input.prompt });
+    },
+    log: (event, data) => context.logger?.debug?.(event, data),
+    emit: () => void 0,
+    signal: {
+      get cancelled() {
+        return cancellation.has(conversationId) || (parentConversationId ? cancellation.has(parentConversationId) : false);
+      }
+    },
+    state: {
+      get: async (key) => {
+        const local = scriptState.get(stateKey(key));
+        if (local !== void 0) return local;
+        const persisted = await context.loopCheckpoints?.loadCheckpoint(conversationId, `state:${key}`);
+        if (persisted !== void 0) scriptState.set(stateKey(key), persisted);
+        return persisted;
+      },
+      set: async (key, value) => {
+        scriptState.set(stateKey(key), value);
+        await context.loopCheckpoints?.saveCheckpoint(conversationId, `state:${key}`, value);
+      },
+      update: async (key, updater) => {
+        const fullKey = stateKey(key);
+        const previous = scriptState.get(fullKey);
+        const next = updater(previous);
+        scriptState.set(fullKey, next);
+        await context.loopCheckpoints?.saveCheckpoint(conversationId, `state:${key}`, next);
+      }
+    },
+    checkpoint: async (key, result) => {
+      scriptState.set(stateKey(`checkpoint:${key}`), result);
+      await context.loopCheckpoints?.saveCheckpoint(conversationId, key, result);
+    },
+    loadCheckpoint: async (key) => {
+      const memoryKey = stateKey(`checkpoint:${key}`);
+      if (scriptState.has(memoryKey)) return scriptState.get(memoryKey);
+      const result = await context.loopCheckpoints?.loadCheckpoint(conversationId, key);
+      if (result !== void 0) scriptState.set(memoryKey, result);
+      return result;
+    }
+  };
+}
+async function createAgentLoopRunner(context, options) {
+  const cancellation = context.conversationCancellation ?? /* @__PURE__ */ new Set();
+  context.conversationCancellation ??= cancellation;
+  const scriptState = /* @__PURE__ */ new Map();
+  const conversationId = options.conversationId ?? options.definitionId;
+  return createProfileRunner(
+    context,
+    options.definitionId,
+    createScriptRuntime(context, cancellation, scriptState, conversationId)
+  );
+}
+function createMemeLoopRuntime(context) {
+  const listeners = /* @__PURE__ */ new Map();
+  const cancellation = context.conversationCancellation ?? /* @__PURE__ */ new Set();
+  const scriptState = /* @__PURE__ */ new Map();
+  context.conversationCancellation ??= cancellation;
+  function notify(conversationId, update) {
+    const set = listeners.get(conversationId);
+    if (!set) return;
+    for (const listener of set) {
+      listener(update);
+    }
+  }
+  async function runAgentLoop(input, definitionId) {
+    const run = context.runAgentToolLoop ?? await createProfileRunner(
+      context,
+      definitionId,
+      createScriptRuntime(context, cancellation, scriptState, input.conversationId)
+    );
+    if (!run) return false;
+    void drainAgentLoop(run(input), input.conversationId, notify);
+    return true;
+  }
+  async function* runChildAgent(input) {
+    const run = await createProfileRunner(
+      context,
+      input.profileId,
+      createScriptRuntime(context, cancellation, scriptState, input.conversationId)
+    );
+    if (!run) {
+      yield {
+        type: "message",
+        data: `Child agent profile not found: ${input.profileId}`
+      };
+      return;
+    }
+    yield* run({ conversationId: input.conversationId, message: input.prompt });
+  }
+  context.runChildAgent ??= runChildAgent;
+  return {
+    async createAgent(options) {
+      const now = Date.now();
+      const conversationId = `${options.definitionId}:${now.toString(36)}`;
+      cancellation?.delete(conversationId);
+      const meta = {
+        conversationId,
+        title: options.definitionId,
+        lastMessagePreview: context.runAgentToolLoop ? "" : options.initialMessage ?? "",
+        lastMessageTimestamp: now,
+        messageCount: context.runAgentToolLoop || !options.initialMessage ? 0 : 1,
+        originNodeId: "local",
+        definitionId: options.definitionId,
+        isUserInitiated: true
+      };
+      await context.storage.upsertConversationMetadata(meta);
+      if (options.initialMessage) {
+        const started = await runAgentLoop(
+          { conversationId, message: options.initialMessage },
+          options.definitionId
+        );
+        if (started) {
+          notify(conversationId, { type: "created", conversationId });
+          return { conversationId };
+        }
+      }
+      if (options.initialMessage) {
+        const message = {
+          messageId: `${conversationId}:m1`,
+          conversationId,
+          originNodeId: meta.originNodeId,
+          timestamp: now,
+          lamportClock: 1,
+          role: "user",
+          content: options.initialMessage
+        };
+        await context.storage.appendMessage(message);
+      }
+      notify(conversationId, { type: "created", conversationId });
+      return { conversationId };
+    },
+    async sendMessage(options) {
+      cancellation?.delete(options.conversationId);
+      const definitionId = options.definitionId ?? await resolveDefinitionId(context, options.conversationId);
+      const started = await runAgentLoop(
+        {
+          conversationId: options.conversationId,
+          message: options.message,
+          userMessage: options.userMessage,
+          resumeSession: options.resumeSession
+        },
+        definitionId
+      );
+      if (started) {
+        notify(options.conversationId, { type: "message-queued" });
+        return;
+      }
+      if (options.resumeSession && options.resumeSession.length > 0) {
+        await context.storage.insertMessagesIfAbsent(options.resumeSession);
+      }
+      const now = Date.now();
+      const lamportClock = await nextLamportClockForConversation(
+        context.storage,
+        options.conversationId
+      );
+      const hostUserMessage = options.userMessage;
+      const message = {
+        ...hostUserMessage,
+        messageId: hostUserMessage?.messageId ?? `${options.conversationId}:${now.toString(36)}`,
+        conversationId: options.conversationId,
+        originNodeId: hostUserMessage?.originNodeId ?? "local",
+        timestamp: hostUserMessage?.timestamp ?? now,
+        lamportClock: hostUserMessage?.lamportClock ?? lamportClock,
+        role: "user",
+        content: hostUserMessage?.content ?? options.message
+      };
+      await context.storage.appendMessage(message);
+      notify(options.conversationId, { type: "message-queued" });
+    },
+    async cancelAgent(conversationId) {
+      cancellation?.add(conversationId);
+      notify(conversationId, { type: "cancelled" });
+    },
+    subscribeToUpdates(conversationId, listener) {
+      const set = listeners.get(conversationId) ?? /* @__PURE__ */ new Set();
+      set.add(listener);
+      listeners.set(conversationId, set);
+      return () => {
+        const current = listeners.get(conversationId);
+        if (!current) return;
+        current.delete(listener);
+        if (current.size === 0) {
+          listeners.delete(conversationId);
+        }
+      };
+    }
+  };
+}
+
+export {
+  BUILTIN_AGENT_AGENT_LOOP_ARTIFACT_RESOURCE_LIFECYCLE_SCRIPT_ID,
+  BUILTIN_AGENT_AGENT_LOOP_DECLARATIVE_AGENT_RUN_SCRIPT_ID,
+  BUILTIN_AGENT_AGENT_LOOP_QUALITY_GATE_SCRIPT_ID,
+  builtinAgentAgentLoopSources,
+  getBuiltinAgentAgentLoopSource,
+  waitForCondition,
+  createAgentClient,
+  toolSchemaToJsonSchema,
+  registerToolParameterSchema,
+  getToolParameterSchema,
+  getToolMetadata,
+  BUILTIN_RUNTIME_CLASSES,
+  selectRuntimeClass,
+  BUILTIN_AGENT_TOOL_LOOP_DEFAULT_SCRIPT_ID,
+  builtinAgentToolLoopSources,
+  getBuiltinAgentToolLoopSource,
+  digestNormalizedScript,
+  validateScript,
+  normalizeScript,
+  loadAgentToolLoopScript,
+  createAgentToolLoopDefinition,
+  AGENT_TOOL_LOOP_ID,
+  AGENT_AGENT_LOOP_ID,
+  registerBuiltinLoops,
+  resolveQuestionAnswer,
+  askQuestionConfigSchema,
+  ASK_QUESTION_TOOL_ID,
+  askQuestionImpl,
+  askUserQuestionConfigSchema,
+  ASK_USER_QUESTION_TOOL_ID,
+  askUserQuestionImpl,
+  mcpClientConfigSchema,
+  mcpClientImpl,
+  getMcpClientToolId,
+  mcpForwardConfigSchema,
+  mcpForwardImpl,
+  getMcpForwardToolId,
+  ORCHESTRATION_TOOL_ID,
+  orchestrationConfigSchema,
+  orchestrationImpl,
+  remoteAgentConfigSchema,
+  remoteAgentListImpl,
+  remoteAgentImpl,
+  getRemoteAgentToolId,
+  spawnAgentConfigSchema,
+  spawnAgentImpl,
+  getSpawnAgentToolId,
+  buildAgent,
+  planAgent,
+  exploreAgent,
+  oracleAgent,
+  librarianAgent,
+  BUILTIN_AGENT_PROFILES,
+  AgentProfileRegistry,
+  getAgentProfileRegistry,
+  resetAgentProfileRegistry,
+  taskToolConfigSchema,
+  taskToolImpl,
+  getTaskToolId,
+  todoWriteConfigSchema,
+  TODO_WRITE_TOOL_ID,
+  __clearTodoStore,
+  todoWriteImpl,
+  PLUGIN_MCP_CLIENT,
+  PLUGIN_MCP_FORWARD,
+  PLUGIN_ORCHESTRATION,
+  PLUGIN_SPAWN_AGENT,
+  PLUGIN_REMOTE_AGENT,
+  PLUGIN_ASK_QUESTION,
+  PLUGIN_TODO_WRITE,
+  PLUGIN_ASK_USER_QUESTION,
+  PLUGIN_TASK,
+  BUILTIN_TOOL_PLUGIN_IDS,
+  getBuiltinToolPlugins,
+  registerBuiltinToolPlugins,
+  registerBuiltinPromptPlugins,
+  createAgentProfileRunner,
+  createAgentLoopScriptRunner,
+  createAgentLoopRunner,
+  createMemeLoopRuntime,
+  defaultRequestedInterfacesForTrustClass,
+  maxScriptBytesForTrustClass,
+  admitScript,
+  remoteDeploymentToWorkloadManifest,
+  deployGeneratedScript,
+  createScriptLoadGate,
+  createScriptDeploymentClient,
+  loadAgentAgentLoopScript,
+  createAgentAgentLoopDefinition,
+  getAgentAgentLoopId
+};
+//# sourceMappingURL=chunk-XHRBV6I3.js.map