@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/dist/{cli-7a93cv8c.js → cli-4mengw46.js}

@@ -12,7 +12,7 @@ import {
   generateRandomCodeVerifier,
   generateRandomState,
   oauthAppRowToProviderConfig
-} from "./cli-w1apjecb.js";
+} from "./cli-711vwbxn.js";
 import {
   CredentialBroker,
   DEFAULT_CREDENTIAL_BINDINGS,
@@ -36,6 +36,9 @@ import {
   init_oauth,
   init_quickjs_pool_config,
   init_secret_registry,
+  init_swarm_config_guard,
+  isApiOnlyConfigKey,
+  isInternalConfigKey,
   normalizeDateRequired,
   oauthSecretName,
   placeholderForConfigKey,
@@ -46,11 +49,11 @@ import {
   updateAuthorizationTokens,
   upsertAuthorization,
   upsertSwarmConfig
-} from "./cli-fmhj1ehj.js";
+} from "./cli-y3167wt1.js";
 import {
   defaultAssetKey,
   init_key
-} from "./cli-hsem16hb.js";
+} from "./cli-pe05f8yk.js";
 import {
   init_zod
 } from "./cli-sd0mxa3c.js";
@@ -73,6 +76,10 @@ import {
   init_node_env,
   isDevOrTestNodeEnv
 } from "./cli-p0sg24zp.js";
+import {
+  getMcpBaseUrl,
+  init_constants
+} from "./cli-gd4favx9.js";
 import {
   init_env_flag,
   isEnvFlagEnabled
@@ -82,12 +89,13 @@ import {
   init_api_key
 } from "./cli-a1b9b32n.js";
 import {
+  createValueScrubber,
   init_secret_scrubber,
   refreshSecretScrubberCache,
   registerVolatileSecret,
   scrubObject,
   scrubSecrets
-} from "./cli-d161g69q.js";
+} from "./cli-shk7r5cs.js";
 import {
   __commonJS,
   __require,
@@ -175188,6 +175196,7 @@ var require_dist = __commonJS(function(exports) {
 
 // src/scripts-runtime/loader.ts
 init_api_key();
+init_constants();
 init_secret_scrubber();
 
 // src/scripts-runtime/egress-secrets.ts
@@ -175784,7 +175793,7 @@ async function buildConfigPayload(input) {
       apiKey: { value: apiKey, isSecret: true },
       agentId: { value: input.agentId, isSecret: false },
       mcpBaseUrl: {
-        value: input.mcpBaseUrl ?? process.env.MCP_BASE_URL ?? "http://localhost:3013",
+        value: input.mcpBaseUrl ?? getMcpBaseUrl(),
         isSecret: false
       },
       ...input.runtimeInstanceId ? { runtimeInstanceId: { value: input.runtimeInstanceId, isSecret: false } } : {}
@@ -175808,12 +175817,13 @@ async function runScript(input) {
       error: "executor_error"
     };
   }
+  const runSecrets = createValueScrubber(Object.entries(input.userConfig ?? {}).filter(([, entry]) => entry.isSecret).map(([key, entry]) => ({ value: entry.value, name: `config:${key}` })));
   const imports = validateScriptImports(input.source);
   if (!imports.ok) {
     return {
       result: undefined,
       stdout: "",
-      stderr: imports.diagnostic,
+      stderr: scrubSecrets(runSecrets.text(imports.diagnostic)),
       truncated: { stdout: false, stderr: false },
       durationMs: 0,
       exitCode: 1,
@@ -175844,10 +175854,10 @@ async function runScript(input) {
   }
   return {
     ...output,
-    result: scrubObject(output.result),
-    stdout: scrubSecrets(output.stdout),
-    stderr: scrubSecrets(output.stderr),
-    ...output.runtimeError ? { runtimeError: scrubObject(output.runtimeError) } : {}
+    result: scrubObject(runSecrets.object(output.result)),
+    stdout: scrubSecrets(runSecrets.text(output.stdout)),
+    stderr: scrubSecrets(runSecrets.text(output.stderr)),
+    ...output.runtimeError ? { runtimeError: scrubObject(runSecrets.object(output.runtimeError)) } : {}
   };
 }
 
@@ -178361,13 +178371,25 @@ async function resolveOAuthBindingToken(oauthAuthorizationId) {
 }
 
 // src/be/script-credential-broker.ts
+init_swarm_config_guard();
+
 class RelationalCredentialBindingStore {
   listActiveBindings(context) {
     return listRelationalCredentialBindings(context);
   }
 }
+function toScriptUserConfig(configs) {
+  const exposed = configs.filter((config) => !isApiOnlyConfigKey(config.key) && !isInternalConfigKey(config.key));
+  for (const config of exposed) {
+    if (config.isSecret && config.value) {
+      registerVolatileSecret(config.value, `config:${config.key}`);
+    }
+  }
+  return Object.fromEntries(exposed.map((config) => [config.key, { value: config.value, isSecret: config.isSecret }]));
+}
 async function buildScriptCredentialBindingsWithFailures(input) {
   const resolvedConfigs = await getResolvedConfig(input.agentId, input.repoId);
+  const userConfig = toScriptUserConfig(resolvedConfigs);
   const configMap = new Map(resolvedConfigs.map((config) => [config.key, config.value]));
   const broker = new CredentialBroker(new RelationalCredentialBindingStore, (configKey) => configMap.get(configKey) ?? process.env[configKey], DEFAULT_CREDENTIAL_BINDINGS, (oauthAuthorizationId) => resolveOAuthBindingToken(oauthAuthorizationId));
   const { resolved, failed } = await broker.resolveBindingsWithFailures({
@@ -178377,10 +178399,11 @@ async function buildScriptCredentialBindingsWithFailures(input) {
   for (const binding of resolved) {
     registerVolatileSecret(binding.value, binding.configKey);
   }
-  return { egressSecrets: resolved, failedBindings: failed };
-}
-async function buildScriptCredentialBindings(input) {
-  return (await buildScriptCredentialBindingsWithFailures(input)).egressSecrets;
+  return {
+    egressSecrets: resolved,
+    failedBindings: failed,
+    userConfig
+  };
 }
 
 // src/be/scripts/run-saved.ts
@@ -178407,6 +178430,7 @@ async function runSavedScriptAsAgent(args, deps = {}) {
     agentId: args.agentId,
     egressSecrets: credentials.egressSecrets,
     failedBindings: credentials.failedBindings,
+    userConfig: credentials.userConfig,
     apiConnections: getScriptApiConnectionDescriptors({ agentId: args.agentId }),
     mcpConnections: getScriptMcpConnectionDescriptors({ agentId: args.agentId }),
     ...args.timeoutMs ? { timeoutMs: args.timeoutMs } : {},
@@ -178525,12 +178549,312 @@ async function extractArgsJsonSchema(source) {
 }
 
 // src/be/scripts/typecheck.ts
-var import_typescript3 = __toESM(require_typescript(), 1);
+var import_typescript4 = __toESM(require_typescript(), 1);
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/apps/definition.ts
 init_zod();
 init_db();
+
+// src/scripts-runtime/quickjs-compat.ts
+var import_typescript3 = __toESM(require_typescript(), 1);
+var UNSUPPORTED_GLOBALS = new Set([
+  "AbortController",
+  "AbortSignal",
+  "Blob",
+  "Buffer",
+  "Event",
+  "EventTarget",
+  "File",
+  "FormData",
+  "Intl",
+  "ReadableStream",
+  "Request",
+  "TransformStream",
+  "WebSocket",
+  "WritableStream",
+  "clearImmediate",
+  "navigator",
+  "performance",
+  "queueMicrotask",
+  "setImmediate",
+  "structuredClone"
+]);
+var RESPONSE_BODY_METHODS = new Set(["arrayBuffer", "blob", "formData", "bytes"]);
+var LOCALE_METHODS = new Set(["toLocaleString", "toLocaleDateString", "toLocaleTimeString"]);
+var FS_STDLIB = new Set(["glob", "grep"]);
+var HOST_ONLY_CONFIG = new Set(["apiKey", "runtimeInstanceId"]);
+var MAX_FINDINGS = 20;
+var SCRIPT_FILE = "user-script.ts";
+var MAX_CONST_DEPTH = 4;
+function isAmbient(node) {
+  for (let current = node;current; current = current.parent) {
+    if (import_typescript3.default.canHaveModifiers(current) && import_typescript3.default.getModifiers(current)?.some((modifier) => modifier.kind === import_typescript3.default.SyntaxKind.DeclareKeyword)) {
+      return true;
+    }
+  }
+  return false;
+}
+function createScope(source) {
+  const sourceFile = import_typescript3.default.createSourceFile(SCRIPT_FILE, source, import_typescript3.default.ScriptTarget.Latest, true);
+  const host = {
+    getSourceFile: (name) => name === SCRIPT_FILE ? sourceFile : undefined,
+    getDefaultLibFileName: () => "lib.d.ts",
+    writeFile: () => {},
+    getCurrentDirectory: () => "/",
+    getCanonicalFileName: (name) => name,
+    useCaseSensitiveFileNames: () => true,
+    getNewLine: () => `
+`,
+    fileExists: (name) => name === SCRIPT_FILE,
+    readFile: () => {
+      return;
+    }
+  };
+  const program = import_typescript3.default.createProgram({
+    rootNames: [SCRIPT_FILE],
+    options: { noLib: true, noResolve: true, types: [], target: import_typescript3.default.ScriptTarget.Latest },
+    host
+  });
+  const checker = program.getTypeChecker();
+  const isLocal = (node) => {
+    const symbol = import_typescript3.default.isShorthandPropertyAssignment(node.parent) && node.parent.name === node ? checker.getShorthandAssignmentValueSymbol(node.parent) : checker.getSymbolAtLocation(node);
+    return Boolean(symbol?.declarations?.some((declaration) => declaration.getSourceFile() === sourceFile && !isAmbient(declaration)));
+  };
+  const constInitializer = (node) => {
+    const declaration = checker.getSymbolAtLocation(node)?.valueDeclaration;
+    if (!declaration || !import_typescript3.default.isVariableDeclaration(declaration) || !declaration.initializer) {
+      return null;
+    }
+    return import_typescript3.default.getCombinedNodeFlags(declaration) & import_typescript3.default.NodeFlags.Const ? declaration.initializer : null;
+  };
+  return { sourceFile, isLocal, constInitializer };
+}
+function isValueReference(node) {
+  const parent = node.parent;
+  if (import_typescript3.default.isPropertyAccessExpression(parent) && parent.name === node)
+    return false;
+  if (import_typescript3.default.isShorthandPropertyAssignment(parent))
+    return true;
+  if ("name" in parent && parent.name === node)
+    return false;
+  if (import_typescript3.default.isTypeOfExpression(parent))
+    return false;
+  return true;
+}
+function isTypeOnly(node) {
+  return import_typescript3.default.isTypeNode(node) || import_typescript3.default.isInterfaceDeclaration(node) || import_typescript3.default.isTypeAliasDeclaration(node) || import_typescript3.default.isImportDeclaration(node) && Boolean(node.importClause?.isTypeOnly);
+}
+function stdlibImportNames(node) {
+  if (!import_typescript3.default.isStringLiteral(node.moduleSpecifier) || node.moduleSpecifier.text !== "stdlib")
+    return [];
+  const bindings = node.importClause?.namedBindings;
+  if (!bindings || !import_typescript3.default.isNamedImports(bindings))
+    return [];
+  return bindings.elements.map((element) => (element.propertyName ?? element.name).text).filter((name) => FS_STDLIB.has(name));
+}
+function unwrap(node) {
+  let current = node;
+  while (import_typescript3.default.isParenthesizedExpression(current) || import_typescript3.default.isAsExpression(current) || import_typescript3.default.isNonNullExpression(current) || import_typescript3.default.isTypeAssertionExpression(current) || import_typescript3.default.isSatisfiesExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+}
+function isGlobalThis(node) {
+  const inner = unwrap(node);
+  return import_typescript3.default.isIdentifier(inner) && inner.text === "globalThis";
+}
+function globalName(node, isLocal) {
+  const inner = unwrap(node);
+  if (import_typescript3.default.isIdentifier(inner))
+    return isLocal(inner) ? null : inner.text;
+  if (import_typescript3.default.isPropertyAccessExpression(inner) && isGlobalThis(inner.expression)) {
+    return inner.name.text;
+  }
+  return null;
+}
+function isPrivateIPv42([a = 0, b = 0, c = 0]) {
+  return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 192 && b === 0 && c === 0 || a === 198 && (b === 18 || b === 19) || a >= 224;
+}
+function isPrivateIPv62(text) {
+  const [head = "", tail = ""] = text.split("::");
+  const left = head ? head.split(":") : [];
+  const right = text.includes("::") && tail ? tail.split(":") : [];
+  const fill = text.includes("::") ? 8 - left.length - right.length : 0;
+  const g = [...left, ...Array(fill).fill("0"), ...right].map((part) => parseInt(part, 16));
+  const g0 = g[0] ?? 0;
+  if (g.slice(0, 6).every((part) => part === 0))
+    return true;
+  if (g.slice(0, 5).every((part) => part === 0) && g[5] === 65535) {
+    const [g6 = 0, g7 = 0] = g.slice(6);
+    return isPrivateIPv42([g6 >> 8, g6 & 255, g7 >> 8]);
+  }
+  return (g0 & 65024) === 64512 || (g0 & 65472) === 65152 || (g0 & 65472) === 65216 || (g0 & 65280) === 65280;
+}
+function staticHostClass(hostname) {
+  const host = hostname.toLowerCase().replace(/\.$/, "");
+  if (host === "localhost" || host.endsWith(".localhost"))
+    return "private";
+  if (host.startsWith("["))
+    return isPrivateIPv62(host.slice(1, -1)) ? "private" : null;
+  const v4 = /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/.exec(host);
+  if (v4)
+    return isPrivateIPv42(v4.slice(1).map(Number)) ? "private" : null;
+  return host !== "" && !host.includes(".") ? "single-label" : null;
+}
+function fetchCallName(callee) {
+  const inner = unwrap(callee);
+  if (import_typescript3.default.isIdentifier(inner)) {
+    return inner.text === "fetch" || inner.text === "fetchJson" ? inner.text : null;
+  }
+  if (!import_typescript3.default.isPropertyAccessExpression(inner))
+    return null;
+  const method = inner.name.text;
+  if (method !== "fetch" && method !== "fetchJson")
+    return null;
+  const owner = unwrap(inner.expression);
+  if (method === "fetch" && isGlobalThis(owner))
+    return "fetch";
+  const ownerName = import_typescript3.default.isIdentifier(owner) ? owner.text : import_typescript3.default.isPropertyAccessExpression(owner) ? owner.name.text : null;
+  return ownerName === "stdlib" ? `ctx.stdlib.${method}` : null;
+}
+function staticPrefix(node, resolve, depth = 0) {
+  const inner = unwrap(node);
+  if (import_typescript3.default.isStringLiteral(inner) || import_typescript3.default.isNoSubstitutionTemplateLiteral(inner)) {
+    return { text: inner.text, cut: false };
+  }
+  if (import_typescript3.default.isIdentifier(inner)) {
+    const initializer = depth < MAX_CONST_DEPTH ? resolve(inner) : null;
+    return initializer ? staticPrefix(initializer, resolve, depth + 1) : null;
+  }
+  if (import_typescript3.default.isTemplateExpression(inner)) {
+    let text = inner.head.text;
+    let boundary = false;
+    for (const span of inner.templateSpans) {
+      const part = staticPrefix(span.expression, resolve, depth);
+      if (part === null)
+        return { text, cut: !boundary || text === "" };
+      if (part.cut)
+        return { text: text + part.text, cut: true };
+      text += part.text + span.literal.text;
+      boundary = span.literal.text === "";
+    }
+    return { text, cut: false };
+  }
+  if (import_typescript3.default.isBinaryExpression(inner) && inner.operatorToken.kind === import_typescript3.default.SyntaxKind.PlusToken) {
+    const left = staticPrefix(inner.left, resolve, depth);
+    if (left === null || left.cut)
+      return left;
+    const right = staticPrefix(inner.right, resolve, depth);
+    if (right === null)
+      return { text: left.text, cut: !import_typescript3.default.isIdentifier(unwrap(inner.left)) };
+    return { text: left.text + right.text, cut: right.cut };
+  }
+  return null;
+}
+function literalUrl(arg, resolve) {
+  if (!arg)
+    return null;
+  const prefix = staticPrefix(arg, resolve);
+  if (!prefix)
+    return null;
+  if (prefix.cut && !/^[a-z][a-z0-9+.-]*:\/\/[^/?#]*[/?#]/i.test(prefix.text))
+    return null;
+  try {
+    return new URL(prefix.text);
+  } catch {
+    return null;
+  }
+}
+function checkQuickJSCompat(source, options = {}) {
+  const findings = [];
+  const seen = new Set;
+  const { sourceFile, isLocal, constInitializer } = createScope(source);
+  const add = (rule, message, node) => {
+    if (seen.has(`${rule}:${message}`))
+      return;
+    seen.add(`${rule}:${message}`);
+    const line = node ? sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1 : undefined;
+    findings.push(line === undefined ? { rule, message } : { rule, message, line });
+  };
+  if (options.fsMode === "workspace-rw") {
+    add("workspaceRw", "fsMode workspace-rw is not available under quickjs");
+  }
+  const reportGlobal = (name, node) => {
+    if (name === "Bun")
+      add("bunGlobal", "Bun.* is not available under quickjs", node);
+    else if (name === "process")
+      add("process", "process is not available under quickjs", node);
+    else if (UNSUPPORTED_GLOBALS.has(name)) {
+      add("unsupportedGlobal", `${name} is not available under quickjs`, node);
+    }
+  };
+  const visit = (node) => {
+    if (isTypeOnly(node))
+      return;
+    if (import_typescript3.default.isIdentifier(node) && (node.text === "Bun" || node.text === "process" || UNSUPPORTED_GLOBALS.has(node.text)) && isValueReference(node) && !isLocal(node)) {
+      reportGlobal(node.text, node);
+    }
+    if (import_typescript3.default.isPropertyAccessExpression(node)) {
+      const member = node.name.text;
+      const owner = globalName(node.expression, isLocal);
+      if (isGlobalThis(node.expression) && !import_typescript3.default.isTypeOfExpression(node.parent)) {
+        reportGlobal(member, node);
+      }
+      const parent = unwrap(node.expression);
+      if (HOST_ONLY_CONFIG.has(member) && import_typescript3.default.isPropertyAccessExpression(parent) && parent.name.text === "config") {
+        add("hostCredential", `ctx.swarm.config.${member} is host-only under quickjs; ctx.swarm calls use it for you`, node);
+      }
+      if (member === "subtle" && owner === "crypto") {
+        add("cryptoSubtle", "crypto.subtle is not available under quickjs", node);
+      }
+      if (FS_STDLIB.has(member) && import_typescript3.default.isPropertyAccessExpression(unwrap(node.expression)) && unwrap(node.expression).name.text === "stdlib") {
+        add("fsStdlib", `ctx.stdlib.${member} needs filesystem access, which quickjs lacks`, node);
+      }
+    }
+    if (import_typescript3.default.isImportDeclaration(node)) {
+      for (const name of stdlibImportNames(node)) {
+        add("fsStdlib", `stdlib ${name} needs filesystem access, which quickjs lacks`, node);
+      }
+    }
+    if (import_typescript3.default.isVariableDeclaration(node) && import_typescript3.default.isObjectBindingPattern(node.name) && node.initializer && import_typescript3.default.isPropertyAccessExpression(node.initializer) && node.initializer.name.text === "stdlib") {
+      for (const element of node.name.elements) {
+        const name = (element.propertyName ?? element.name).getText(sourceFile);
+        if (FS_STDLIB.has(name)) {
+          add("fsStdlib", `ctx.stdlib.${name} needs filesystem access, which quickjs lacks`, node);
+        }
+      }
+    }
+    if (import_typescript3.default.isCallExpression(node)) {
+      const callee = node.expression;
+      const fetchName = fetchCallName(callee);
+      const url = fetchName ? literalUrl(node.arguments[0], constInitializer) : null;
+      const hostClass = url && (url.protocol === "http:" || url.protocol === "https:") ? staticHostClass(url.hostname) : null;
+      if (url && hostClass) {
+        add("privateHost", `${fetchName} to ${url.host} (${hostClass} host) depends on the egress policy: quickjs refuses private hosts unless the operator allows them`, node);
+      }
+      if (import_typescript3.default.isIdentifier(callee) && callee.text === "require" && !isLocal(callee)) {
+        add("require", "require() is not supported; use an import", node);
+      }
+      if (import_typescript3.default.isPropertyAccessExpression(callee)) {
+        const method = callee.name.text;
+        if (RESPONSE_BODY_METHODS.has(method) && node.arguments.length === 0) {
+          add("responseBody", `.${method}() on a fetch Response is not available under quickjs (text() and json() are)`, node);
+        }
+        if (LOCALE_METHODS.has(method) && node.arguments.length > 0) {
+          add("localeFormat", `${method}(locale, options) ignores its arguments under quickjs (no Intl)`, node);
+        }
+      }
+    }
+    import_typescript3.default.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return { compatible: findings.length === 0, findings: findings.slice(0, MAX_FINDINGS) };
+}
+function quickJSCompatWarnings(report, label) {
+  const prefix = label ? `${label}: ` : "";
+  return report.findings.map((finding) => `${prefix}quickjs compat (${finding.rule}${finding.line ? `, line ${finding.line}` : ""}): ${finding.message}`);
+}
 // src/apps/catalog.generated.json
 var catalog_generated_default = {
   $comment: "GENERATED by apps/ui/scripts/generate-catalog-schema.ts — do not hand-edit. Regenerate with `cd apps/ui && bun run generate:catalog-schema`.",
@@ -182583,6 +182907,17 @@ function collectScriptReferences(definition) {
   }
   return references;
 }
+async function scriptCompatWarnings(definition) {
+  const warnings = [];
+  for (const [scriptId, paths] of collectScriptReferences(definition)) {
+    const script = await getScriptById(scriptId);
+    if (!script)
+      continue;
+    const report = checkQuickJSCompat(script.source, { fsMode: script.fsMode });
+    warnings.push(...quickJSCompatWarnings(report, paths.join(", ")));
+  }
+  return warnings;
+}
 function foreignScriptForWriter(context, script) {
   if (script.scope !== "agent")
     return false;
@@ -183514,13 +183849,15 @@ export interface SwarmSdk {
   // --- config ---
   config_get(args?: { agentId?: string; repoId?: string; key?: string; includeSecrets?: boolean }): Promise<unknown>;
   config_list(args?: { scope?: "global" | "agent" | "repo"; scopeId?: string; key?: string; includeSecrets?: boolean }): Promise<unknown>;
+  // --- model profiles ---
+  modelProfile_list(args?: { harness?: string }): Promise<unknown>;
   // --- slack ---
   slack_read(args?: { inboxMessageId?: string; taskId?: string; channelId?: string; threadTs?: string; limit?: number; includeFiles?: boolean }): Promise<unknown>;
   slack_listChannels(args?: { types?: Array<"public" | "private" | "dm" | "mpim">; limit?: number }): Promise<unknown>;
+  // --- chat sdk ---
+  chat_readThread(args: { threadId: string; limit?: number }): Promise<unknown>;
   // --- messaging ---
   message_read(args?: { channel?: string; limit?: number; since?: string; unreadOnly?: boolean; mentionsOnly?: boolean; markAsRead?: boolean }): Promise<unknown>;
-  // --- services ---
-  service_list(args?: { agentId?: string; name?: string; status?: "starting" | "healthy" | "unhealthy" | "stopped"; includeOwn?: boolean }): Promise<unknown>;
   // --- context / profiles ---
   context_history(args?: { agentId?: string; field?: "soulMd" | "identityMd" | "toolsMd" | "claudeMd" | "setupScript"; limit?: number }): Promise<unknown>;
   context_diff(args: { versionId: string; compareToVersionId?: string }): Promise<unknown>;
@@ -183563,7 +183900,7 @@ export interface SwarmSdk {
   task_action(args: Record<string, unknown>): Promise<unknown>;
 
   // --- write: config ---
-  config_set(args: { key: string; value: unknown; scope?: "global" | "agent" | "repo"; scopeId?: string; isSecret?: boolean }): Promise<unknown>;
+  config_set(args: { key: string; value: unknown; scope?: "global" | "agent" | "repo"; scopeId?: string; isSecret?: boolean; exportToEnv?: boolean }): Promise<unknown>;
   config_delete(args: { id: string }): Promise<unknown>;
 
   // --- write: model catalog ---
@@ -183593,17 +183930,19 @@ export interface SwarmSdk {
   slack_delete(args: { channelId: string; messageTs: string }): Promise<unknown>;
   slack_update(args: { channelId: string; messageTs: string; message: string }): Promise<unknown>;
 
+  // --- write: chat sdk ---
+  chat_reply(args: { text: string }): Promise<unknown>;
+  chat_post(args: { adapter: "telegram" | "slack" | "discord" | "teams"; threadId?: string; channelId?: string; text: string }): Promise<unknown>;
+  chat_openDm(args: { adapter: "telegram" | "slack" | "discord" | "teams"; userId: string }): Promise<unknown>;
+  chat_registerChannel(args: { adapter: "telegram" | "slack" | "discord" | "teams"; channelId: string; agentId?: string; workflowId?: string; name?: string }): Promise<unknown>;
+  chat_unregisterChannel(args: { adapter: "telegram" | "slack" | "discord" | "teams"; channelId: string }): Promise<unknown>;
+
   // --- write: messaging (internal) ---
   message_post(args: { channel?: string; content: string; to?: string }): Promise<unknown>;
 
   // --- write: profiles ---
   profile_update(args: Record<string, unknown>): Promise<unknown>;
 
-  // --- write: services ---
-  service_register(args: Record<string, unknown>): Promise<unknown>;
-  service_unregister(args: { name: string }): Promise<unknown>;
-  service_updateStatus(args: { name: string; status: "starting" | "healthy" | "unhealthy" | "stopped" }): Promise<unknown>;
-
   // --- write: schedules ---
   schedule_create(args: Record<string, unknown>): Promise<unknown>;
   schedule_update(args: Record<string, unknown>): Promise<unknown>;
@@ -183719,6 +184058,16 @@ export interface SwarmSdk {
   // --- human input ---
   request_humanInput(args: Record<string, unknown>): Promise<unknown>;
   approval_cancel(args: { requestId: string; reason?: string }): Promise<unknown>;
+
+  // --- decisions ---
+  systemOne_decide(args: {
+    provider?: "typesafe" | "openrouter" | "laya" | "openai" | "cloudflare";
+    model?: string;
+    state: string | string[] | Record<string, unknown>;
+    questions: Record<string, Record<string, unknown>>;
+    timeoutMs?: number;
+    maxRetries?: number;
+  }): Promise<unknown>;
 }
 
 export interface ScriptStdlib {
@@ -184168,20 +184517,20 @@ function sourceFileCacheKey(fileName, languageVersion) {
   return `${fileName}\x00${languageVersion.languageVersion}\x00${languageVersion.impliedNodeFormat}\x00${languageVersion.jsDocParsingMode}`;
 }
 function createCompilerHost(files, options, virtualModules = new Map) {
-  const host = import_typescript3.default.createCompilerHost(options, true);
+  const host = import_typescript4.default.createCompilerHost(options, true);
   const originalGetSourceFile = host.getSourceFile.bind(host);
   host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
     const normalized = fileName.replace(/\\/g, "/");
     const source = files.get(normalized);
     if (normalized === USER_FILE || normalized === CHECK_FILE) {
       if (source !== undefined) {
-        return import_typescript3.default.createSourceFile(normalized, source, languageVersion, true, import_typescript3.default.ScriptKind.TS);
+        return import_typescript4.default.createSourceFile(normalized, source, languageVersion, true, import_typescript4.default.ScriptKind.TS);
       }
     }
-    const text = source ?? import_typescript3.default.sys.readFile(fileName);
+    const text = source ?? import_typescript4.default.sys.readFile(fileName);
     if (text === undefined || shouldCreateNewSourceFile) {
       if (source !== undefined) {
-        return import_typescript3.default.createSourceFile(normalized, source, languageVersion, true, import_typescript3.default.ScriptKind.TS);
+        return import_typescript4.default.createSourceFile(normalized, source, languageVersion, true, import_typescript4.default.ScriptKind.TS);
       }
       return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
     }
@@ -184189,30 +184538,30 @@ function createCompilerHost(files, options, virtualModules = new Map) {
     const cached = sharedSourceFiles.get(key);
     if (cached && cached.text === text)
       return cached.sourceFile;
-    const sourceFile = source !== undefined ? import_typescript3.default.createSourceFile(normalized, source, languageVersion, true, import_typescript3.default.ScriptKind.TS) : originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+    const sourceFile = source !== undefined ? import_typescript4.default.createSourceFile(normalized, source, languageVersion, true, import_typescript4.default.ScriptKind.TS) : originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
     if (sourceFile)
       sharedSourceFiles.set(key, { text, sourceFile });
     return sourceFile;
   };
   host.fileExists = (fileName) => {
     const normalized = fileName.replace(/\\/g, "/");
-    return files.has(normalized) || import_typescript3.default.sys.fileExists(fileName);
+    return files.has(normalized) || import_typescript4.default.sys.fileExists(fileName);
   };
   host.readFile = (fileName) => {
     const normalized = fileName.replace(/\\/g, "/");
-    return files.get(normalized) ?? import_typescript3.default.sys.readFile(fileName);
+    return files.get(normalized) ?? import_typescript4.default.sys.readFile(fileName);
   };
   const projectBase = scriptTypesBase();
   host.resolveModuleNames = (moduleNames, containingFile) => moduleNames.map((moduleName) => {
     if (moduleName === "./user-script") {
-      return { resolvedFileName: USER_FILE, extension: import_typescript3.default.Extension.Ts };
+      return { resolvedFileName: USER_FILE, extension: import_typescript4.default.Extension.Ts };
     }
     const virtualModule = virtualModules.get(moduleName);
     if (virtualModule) {
-      return { resolvedFileName: virtualModule, extension: import_typescript3.default.Extension.Dts };
+      return { resolvedFileName: virtualModule, extension: import_typescript4.default.Extension.Dts };
     }
     const base = containingFile.startsWith("/virtual/") ? projectBase : containingFile;
-    return import_typescript3.default.resolveModuleName(moduleName, base, options, host).resolvedModule;
+    return import_typescript4.default.resolveModuleName(moduleName, base, options, host).resolvedModule;
   });
   const tsLibDir = process.env.TS_LIB_DIR;
   if (tsLibDir) {
@@ -184221,16 +184570,16 @@ function createCompilerHost(files, options, virtualModules = new Map) {
   return host;
 }
 function flattenMessage(messageText) {
-  return import_typescript3.default.flattenDiagnosticMessageText(messageText, `
+  return import_typescript4.default.flattenDiagnosticMessageText(messageText, `
 `);
 }
 function diagnosticSeverity(diag) {
   switch (diag.category) {
-    case import_typescript3.default.DiagnosticCategory.Error:
+    case import_typescript4.default.DiagnosticCategory.Error:
       return "error";
-    case import_typescript3.default.DiagnosticCategory.Warning:
+    case import_typescript4.default.DiagnosticCategory.Warning:
       return "warning";
-    case import_typescript3.default.DiagnosticCategory.Suggestion:
+    case import_typescript4.default.DiagnosticCategory.Suggestion:
       return "suggestion";
     default:
       return "message";
@@ -184286,12 +184635,12 @@ async function typecheckWithAmbient(args) {
   const options = {
     allowImportingTsExtensions: true,
     lib: ["lib.es2022.d.ts"],
-    module: import_typescript3.default.ModuleKind.ESNext,
-    moduleResolution: import_typescript3.default.ModuleResolutionKind.Bundler,
+    module: import_typescript4.default.ModuleKind.ESNext,
+    moduleResolution: import_typescript4.default.ModuleResolutionKind.Bundler,
     noEmit: true,
     skipLibCheck: true,
     strict: true,
-    target: import_typescript3.default.ScriptTarget.ES2022,
+    target: import_typescript4.default.ScriptTarget.ES2022,
     types: []
   };
   const files = new Map([
@@ -184309,7 +184658,7 @@ async function typecheckWithAmbient(args) {
     files.set(`/virtual/ambient-${name.replace(/[^A-Za-z0-9_.-]/g, "_")}.d.ts`, source);
   }
   const host = createCompilerHost(files, options, virtualModules);
-  const program = import_typescript3.default.createProgram([...files.keys()], options, host);
+  const program = import_typescript4.default.createProgram([...files.keys()], options, host);
   const diagnostics = [
     ...program.getSyntacticDiagnostics(),
     ...program.getSemanticDiagnostics()
@@ -184327,7 +184676,7 @@ async function typecheckWithAmbient(args) {
   };
   return {
     ok: false,
-    diagnostics: diagnostics.map((diagnostic) => import_typescript3.default.formatDiagnosticsWithColorAndContext([diagnostic], formatHost).trimEnd()),
+    diagnostics: diagnostics.map((diagnostic) => import_typescript4.default.formatDiagnosticsWithColorAndContext([diagnostic], formatHost).trimEnd()),
     structured: diagnostics.map(toStructured)
   };
 }
@@ -184349,4 +184698,53 @@ void _scriptMain;
   });
 }
 
-export { require_dist, isInvalidClientError, assertUrlSafe, publicEndpointSsrfOptions, mcpOAuthSsrfOptions, discoverProtectedResourceMetadata, discoverAuthorizationServerMetadata, normalizeTokenEndpointAuthMethod, resolveAdvertisedTokenEndpointAuthMethod, authMethodForStoredClient, selectDcrTokenEndpointAuthMethod, registerClient, buildAuthorizeUrl, exchangeCodeForTokens, refreshMcpToken, revokeMcpToken, computeExpiresAt, getMcpOAuthToken, findReusableMcpOAuthClient, invalidateMcpOAuthClient, upsertMcpOAuthToken, applyMcpOAuthRefresh, markMcpOAuthTokenStatus, deleteMcpOAuthToken, insertMcpOAuthPending, consumeMcpOAuthPending, gcMcpOAuthPending, setMcpServerAuthMethod, ensureMcpToken, callMcpServerTool, resolveSqlDsn, runReadOnlyQuery, listVendoredOpenapiEntries, ConnectionAuthInputSchema, SqlDsnInputSchema, connectionAuthSummary, listRelationalCredentialBindings, getCredentialBindingById, findCredentialBindingByIdentity, upsertCredentialBinding, disableCredentialBinding, listScriptConnections, listScriptConnectionsAsync, getScriptConnectionById, ScriptConnectionConflictError, connectionAuthInputFromFlat, upsertScriptConnection, refreshScriptConnection, setScriptConnectionEnabled, deleteScriptConnection, getScriptApiConnectionDescriptors, getScriptMcpConnectionDescriptors, getScriptApiTypes, getScriptMcpTypes, oauthAppToProviderConfig, getOAuthProviderConfig, getOAuthBindingTokenStatus, buildScriptCredentialBindingsWithFailures, buildScriptCredentialBindings, buildSandboxedCommand, sandboxSpawnEnv, createCappedStreamState, snapshotCapped, readStreamCapped, writeBareImportShim, MIN_SCRIPT_WALL_CLOCK_MS, SCRIPT_LONG_TIMEOUT_HINT_MS, MAX_SCRIPT_WALL_CLOCK_MS, DEFAULT_SCRIPT_RESOURCES, require_typescript, checkImportAllowlist, validateScriptImports, runScript, extractScriptSignature, extractArgsJsonSchema, getSavedScriptOwnerAgentId, runSavedScriptAsAgent, resolveSyncRunAs, AppNameSchema, ColumnKindSchema, isIso8601Date, SYSTEM_COLUMN_KINDS, SORTABLE_SYSTEM_DATE_COLUMNS, AppElementsSchema, AppDefinitionSchema, collectScriptReferences, parseAppDefinition, applyAppDefinitionPatch, upgradeAppDefinition, decodeAppDefinition, appDefinitionNeedsRepair, createApp, getApp, listApps, listAppRecords, updateApp, deleteApp, getScriptAppTypes, SCRIPT_SDK_TYPES, scriptSdkTypesWithGeneratedApis, SCRIPT_STDLIB_MODULE_TYPES, scriptStdlibTypesWithGeneratedApis, typecheckWithAmbient, typecheckScript };
+// src/be/skill-parser.ts
+function parseSkillContent(content) {
+  const trimmed = content.trim();
+  if (!trimmed.startsWith("---")) {
+    throw new Error("Skill content must start with YAML frontmatter (---). No frontmatter found.");
+  }
+  const secondDelimiter = trimmed.indexOf("---", 3);
+  if (secondDelimiter === -1) {
+    throw new Error("Skill content has unterminated frontmatter. Missing closing ---.");
+  }
+  const frontmatterRaw = trimmed.slice(3, secondDelimiter).trim();
+  const body = trimmed.slice(secondDelimiter + 3).trim();
+  const metadata = {};
+  for (const line of frontmatterRaw.split(`
+`)) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1)
+      continue;
+    const key = line.slice(0, colonIdx).trim();
+    let value = line.slice(colonIdx + 1).trim();
+    if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+      try {
+        value = JSON.parse(value);
+      } catch {}
+    }
+    if (key && value) {
+      metadata[key] = value;
+    }
+  }
+  if (!metadata.name) {
+    throw new Error('Skill frontmatter is missing required field: "name"');
+  }
+  if (!metadata.description) {
+    throw new Error('Skill frontmatter is missing required field: "description"');
+  }
+  return {
+    name: metadata.name,
+    description: metadata.description,
+    allowedTools: metadata["allowed-tools"] || undefined,
+    model: metadata.model || undefined,
+    effort: metadata.effort || undefined,
+    context: metadata.context || undefined,
+    agent: metadata.agent || undefined,
+    disableModelInvocation: metadata["disable-model-invocation"] === "true" ? true : undefined,
+    userInvocable: metadata["user-invocable"] !== undefined ? metadata["user-invocable"] !== "false" : undefined,
+    body
+  };
+}
+
+export { require_dist, isInvalidClientError, assertUrlSafe, publicEndpointSsrfOptions, mcpOAuthSsrfOptions, discoverProtectedResourceMetadata, discoverAuthorizationServerMetadata, normalizeTokenEndpointAuthMethod, resolveAdvertisedTokenEndpointAuthMethod, authMethodForStoredClient, selectDcrTokenEndpointAuthMethod, registerClient, buildAuthorizeUrl, exchangeCodeForTokens, refreshMcpToken, revokeMcpToken, computeExpiresAt, getMcpOAuthToken, findReusableMcpOAuthClient, invalidateMcpOAuthClient, upsertMcpOAuthToken, applyMcpOAuthRefresh, markMcpOAuthTokenStatus, deleteMcpOAuthToken, insertMcpOAuthPending, consumeMcpOAuthPending, gcMcpOAuthPending, setMcpServerAuthMethod, ensureMcpToken, callMcpServerTool, resolveSqlDsn, runReadOnlyQuery, listVendoredOpenapiEntries, ConnectionAuthInputSchema, SqlDsnInputSchema, connectionAuthSummary, listRelationalCredentialBindings, getCredentialBindingById, findCredentialBindingByIdentity, upsertCredentialBinding, disableCredentialBinding, listScriptConnections, listScriptConnectionsAsync, getScriptConnectionById, ScriptConnectionConflictError, connectionAuthInputFromFlat, upsertScriptConnection, refreshScriptConnection, setScriptConnectionEnabled, deleteScriptConnection, getScriptApiConnectionDescriptors, getScriptMcpConnectionDescriptors, getScriptApiTypes, getScriptMcpTypes, oauthAppToProviderConfig, getOAuthProviderConfig, getOAuthBindingTokenStatus, buildScriptCredentialBindingsWithFailures, buildSandboxedCommand, sandboxSpawnEnv, createCappedStreamState, snapshotCapped, readStreamCapped, writeBareImportShim, MIN_SCRIPT_WALL_CLOCK_MS, SCRIPT_LONG_TIMEOUT_HINT_MS, MAX_SCRIPT_WALL_CLOCK_MS, DEFAULT_SCRIPT_RESOURCES, require_typescript, checkImportAllowlist, validateScriptImports, runScript, extractScriptSignature, extractArgsJsonSchema, getSavedScriptOwnerAgentId, runSavedScriptAsAgent, checkQuickJSCompat, quickJSCompatWarnings, resolveSyncRunAs, AppNameSchema, ColumnKindSchema, isIso8601Date, SYSTEM_COLUMN_KINDS, SORTABLE_SYSTEM_DATE_COLUMNS, AppElementsSchema, AppDefinitionSchema, collectScriptReferences, scriptCompatWarnings, parseAppDefinition, applyAppDefinitionPatch, upgradeAppDefinition, decodeAppDefinition, appDefinitionNeedsRepair, createApp, getApp, listApps, listAppRecords, updateApp, deleteApp, getScriptAppTypes, SCRIPT_SDK_TYPES, scriptSdkTypesWithGeneratedApis, SCRIPT_STDLIB_MODULE_TYPES, scriptStdlibTypesWithGeneratedApis, typecheckWithAmbient, typecheckScript, parseSkillContent };