glove-foundry 0.0.0

package/dist/chunk-CRWY7M66.js

@@ -0,0 +1,3275 @@
+// src/application.ts
+var FOUNDRY_APPLICATION_BRAND = /* @__PURE__ */ Symbol.for(
+  "glove-foundry-application"
+);
+function isFoundryApplication(value) {
+  return Boolean(
+    value && typeof value === "object" && value[FOUNDRY_APPLICATION_BRAND] === true
+  );
+}
+function assertUnique(label, values) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (seen.has(value.id)) {
+      throw new Error(`Duplicate Foundry ${label} id "${value.id}".`);
+    }
+    seen.add(value.id);
+  }
+}
+function defineApplication(options) {
+  if (!options.name.trim()) throw new Error("Foundry application name is required.");
+  const accounts = Object.freeze([...options.accounts ?? []]);
+  const routes = Object.freeze([...options.routes ?? []]);
+  const bindings = Object.freeze([...options.bindings ?? []]);
+  assertUnique("account", accounts);
+  assertUnique("route", routes);
+  assertUnique("binding", bindings);
+  return Object.freeze({
+    ...options,
+    accounts,
+    routes,
+    bindings,
+    [FOUNDRY_APPLICATION_BRAND]: true
+  });
+}
+var EMPTY_FOUNDRY_APPLICATION = defineApplication({
+  name: "Glove Foundry"
+});
+
+// src/definition.ts
+import { Displaymanager, Glove } from "glove-core";
+import { Effect } from "effect";
+
+// src/identity.ts
+var identities = /* @__PURE__ */ new WeakMap();
+function fileIdentified(value, kind, explicitId) {
+  const cell = {
+    kind,
+    ...explicitId ? { id: explicitId } : {},
+    explicit: explicitId !== void 0
+  };
+  const identified = { ...value };
+  Object.defineProperty(identified, "id", {
+    enumerable: true,
+    configurable: false,
+    get() {
+      if (cell.id) return cell.id;
+      throw new Error(
+        `Foundry ${kind} identity has not been bound yet. Default-export it from its convention file and let Foundry discovery derive the id.`
+      );
+    }
+  });
+  identities.set(identified, cell);
+  return identified;
+}
+function bindFileIdentity(value, id2, expectedKind) {
+  const cell = identities.get(value);
+  if (!cell) {
+    const current = value.id;
+    if (typeof current === "string" && current !== id2) {
+      throw new Error(`Foundry file route resolves to "${id2}" but the definition declares "${current}".`);
+    }
+    return;
+  }
+  if (expectedKind && cell.kind !== expectedKind) {
+    throw new Error(
+      `Foundry ${expectedKind} route "${id2}" received a ${cell.kind} definition.`
+    );
+  }
+  if (cell.id && cell.id !== id2) {
+    throw new Error(
+      `Foundry ${cell.kind} route resolves to "${id2}" but the definition declares "${cell.id}". Remove the explicit id and let the file own identity.`
+    );
+  }
+  cell.id = id2;
+}
+function fileDefinitionKey(value) {
+  const cell = identities.get(value);
+  return cell ?? value;
+}
+function fileDefinitionLabel(value) {
+  const cell = identities.get(value);
+  return cell?.id ?? `<${cell?.kind ?? "definition"} file route>`;
+}
+
+// src/definition.ts
+var FOUNDRY_AGENT_DEFINITION_BRAND = /* @__PURE__ */ Symbol.for(
+  "glove-foundry-agent-definition"
+);
+var FOUNDRY_AGENT_BRAND = FOUNDRY_AGENT_DEFINITION_BRAND;
+var FOUNDRY_EVENT_PREFIX = "__GLOVE_FOUNDRY_EVENT__";
+var FOUNDRY_APPLICATION_ENV = "GLOVE_FOUNDRY_APPLICATION_FILE";
+var FOUNDRY_AGENT_ROUTE_ENV = "GLOVE_FOUNDRY_AGENT_ROUTE";
+var FOUNDRY_AGENT_FILE_ENV = "GLOVE_FOUNDRY_AGENT_FILE";
+var FOUNDRY_EXECUTION_MARKER = "__glove_foundry_execution_v1";
+function defineCall(options) {
+  if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(options.name)) {
+    throw new Error(`Invalid Foundry call name "${options.name}".`);
+  }
+  return Object.freeze({ ...options });
+}
+var ROUTE_PATTERN = /^[a-z][a-z0-9-]*(?:\/[a-z][a-z0-9-]*)*$/;
+function assertAgentRoute(route) {
+  if (!ROUTE_PATTERN.test(route)) {
+    throw new Error(
+      `Invalid Foundry agent id "${route}". Use lowercase path segments containing letters, digits, and hyphens.`
+    );
+  }
+  if (route.includes("__")) {
+    throw new Error(`Invalid Foundry agent id "${route}": "__" is reserved.`);
+  }
+}
+function internalAgentName(route) {
+  assertAgentRoute(route);
+  return `foundry_${route.replaceAll("/", "__").replaceAll("-", "_")}`;
+}
+function routeFromInternalAgentName(name) {
+  if (!name.startsWith("foundry_")) return name;
+  return name.slice("foundry_".length).replaceAll("__", "/").replaceAll("_", "-");
+}
+function isFoundryAgentDefinition(value) {
+  return Boolean(
+    value && typeof value === "object" && value[FOUNDRY_AGENT_DEFINITION_BRAND] === true
+  );
+}
+var isFoundryAgent = isFoundryAgentDefinition;
+function validateDefinition(options, route) {
+  const id2 = route ?? options.id;
+  if (id2) assertAgentRoute(id2);
+  if (!options.model && !options.run && !options.handler && !options.spawn) {
+    throw new Error(`Foundry agent "${id2 ?? "<file route>"}" must define model, run, handler, or spawn.`);
+  }
+  if (options.model && options.systemPrompt === void 0) {
+    throw new Error(`Foundry agent "${id2 ?? "<file route>"}" must define systemPrompt when it defines a model.`);
+  }
+  if (options.inboxes !== void 0 && typeof options.inboxes !== "function") {
+    throw new Error(
+      `Foundry agent "${id2 ?? "<file route>"}" inboxes must be a lazy resolver function.`
+    );
+  }
+  const forbidden = ["input", "output"];
+  for (const key of forbidden) {
+    if (key in options) {
+      throw new Error(`Foundry agent "${id2 ?? "<file route>"}" cannot define ${key}; invocation contracts are framework-owned.`);
+    }
+  }
+}
+function defineAgent(options) {
+  validateDefinition(options);
+  const { id: id2, ...definition } = options;
+  return Object.freeze(fileIdentified({
+    ...definition,
+    tags: Object.freeze([...options.tags ?? []]),
+    [FOUNDRY_AGENT_DEFINITION_BRAND]: true
+  }, "agent", id2));
+}
+var CONVENTION_EXPORTS = [
+  "id",
+  "description",
+  "tags",
+  "components",
+  "mcpAdapter",
+  "accountSessions",
+  "store",
+  "model",
+  "systemPrompt",
+  "displayManager",
+  "serverMode",
+  "maxRetries",
+  "maxConsecutiveErrors",
+  "compactionLimit",
+  "compactionInstructions",
+  "maxTurns",
+  "enableToolResultSummary",
+  "tools",
+  "hooks",
+  "skills",
+  "subagents",
+  "memory",
+  "inboxes",
+  "subscribers",
+  "layers",
+  "calls",
+  "schedules",
+  "playbooks",
+  "mesh",
+  "workingEnvironment",
+  "repl",
+  "configure",
+  "build",
+  "spawn",
+  "run",
+  "handler"
+];
+function defineAgentFromModule(route, module) {
+  assertAgentRoute(route);
+  if (isFoundryAgentDefinition(module.default)) {
+    const definition2 = module.default;
+    bindFileIdentity(definition2, route, "agent");
+    validateDefinition(definition2, route);
+    return definition2;
+  }
+  if (!module.description) {
+    throw new Error(`Foundry route "${route}" must default-export defineAgent(...) or export description.`);
+  }
+  const options = {};
+  for (const key of CONVENTION_EXPORTS) {
+    if (module[key] !== void 0) options[key] = module[key];
+  }
+  const definition = defineAgent(options);
+  bindFileIdentity(definition, route, "agent");
+  return definition;
+}
+function defineSubagent(options) {
+  if (!/^[A-Za-z][\w-]*$/.test(options.name)) throw new Error(`Invalid Foundry subagent name "${options.name}".`);
+  return Object.freeze({
+    name: options.name,
+    description: options.description,
+    factory: async ({ parentStore, parentControls, prompt }) => {
+      const store = await parentStore.createSubAgentStore?.(options.name, options.durable ?? false) ?? void 0;
+      const glove = new Glove({
+        ...store ? { store } : {},
+        model: options.model ?? parentControls.glove.model,
+        displayManager: parentControls.displayManager ?? new Displaymanager(),
+        systemPrompt: options.systemPrompt,
+        serverMode: options.serverMode ?? parentControls.glove.serverMode,
+        ...options.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {},
+        ...options.maxConsecutiveErrors !== void 0 ? { maxConsecutiveErrors: options.maxConsecutiveErrors } : {},
+        compaction_config: {
+          compaction_instructions: options.compactionInstructions ?? `Preserve the ${options.name} subagent's findings and unresolved work.`,
+          ...options.maxTurns !== void 0 ? { max_turns: options.maxTurns } : {},
+          ...options.compactionLimit !== void 0 ? { compaction_context_limit: options.compactionLimit } : {}
+        },
+        ...options.enableToolResultSummary !== void 0 ? { enableToolResultSummary: options.enableToolResultSummary } : {}
+      }).build();
+      for (const tool of options.tools ?? []) glove.fold(tool);
+      for (const hook of options.hooks ?? []) glove.defineHook(hook.name, hook.handler);
+      for (const skill of options.skills ?? []) glove.defineSkill(skill);
+      for (const subagent of options.subagents ?? []) glove.defineSubAgent(subagent);
+      if (options.configure) {
+        const message = { sender: "user", text: prompt };
+        const request = {
+          agentId: options.name,
+          conversationId: `subagent:${options.name}`,
+          workspaceId: "subagent",
+          message: prompt,
+          source: { kind: "spawn" }
+        };
+        await resolveResolvable(options.configure({
+          definitionId: options.name,
+          agentId: options.name,
+          conversationId: request.conversationId,
+          workspaceId: request.workspaceId,
+          runId: `subagent:${options.name}`,
+          input: prompt,
+          request,
+          message,
+          messageInput: prompt,
+          messageText: prompt,
+          history: [],
+          messages: [message],
+          glove,
+          signal: new AbortController().signal,
+          emit: () => void 0
+        }));
+      }
+      return glove;
+    }
+  });
+}
+async function resolveResolvable(value) {
+  if (Effect.isEffect(value)) return Effect.runPromise(value);
+  return Promise.resolve(value);
+}
+function defineRoutes(routes) {
+  return Object.freeze({ ...routes });
+}
+
+// src/capabilities.ts
+import { Effect as Effect2 } from "effect";
+import { mountMcp } from "glove-mcp";
+import {
+  useContext,
+  useEpisodicCurator,
+  useEpisodicReader,
+  useMemoryCurator,
+  useMemoryReader,
+  useResourcesCurator,
+  useResourcesReader
+} from "glove-memory/tools";
+var FOUNDRY_SHARED_TOOL_BRAND = /* @__PURE__ */ Symbol.for(
+  "glove-foundry-shared-tool"
+);
+var FOUNDRY_AGENT_APPLICATION_BRAND = /* @__PURE__ */ Symbol.for(
+  "glove-foundry-agent-application"
+);
+var FOUNDRY_MCP_BRAND = /* @__PURE__ */ Symbol.for("glove-foundry-mcp");
+var FOUNDRY_MEMORY_BRAND = /* @__PURE__ */ Symbol.for("glove-foundry-memory");
+function install(capability, ...configuration) {
+  const config = configuration[0];
+  const selection = configuration[1];
+  const kind = FOUNDRY_SHARED_TOOL_BRAND in capability ? "tool" : FOUNDRY_AGENT_APPLICATION_BRAND in capability ? "application" : "mcp";
+  const installation = {
+    kind,
+    ...config !== void 0 ? { config } : {}
+  };
+  Object.defineProperty(installation, "id", {
+    enumerable: true,
+    get: () => capability.id
+  });
+  if (selection?.account) {
+    Object.defineProperty(installation, "accountId", {
+      enumerable: true,
+      get: () => selection.account.id
+    });
+  }
+  return Object.freeze(installation);
+}
+function installationKey(installation) {
+  return `${installation.kind}:${installation.id}`;
+}
+function assertCapabilityId(id2, label) {
+  if (!/^[a-z][a-z0-9-]*(?:\/[a-z][a-z0-9-]*)*$/.test(id2)) {
+    throw new Error(
+      `Invalid Foundry ${label} id "${id2}". Use lowercase path segments containing letters, digits, and hyphens.`
+    );
+  }
+}
+function decodeCapabilityConfig(definition, installation) {
+  if (!definition.config) return installation.config;
+  const parsed = definition.config.safeParse(installation.config ?? {});
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid config for ${installation.kind} "${definition.id}": ${parsed.error.message}`
+    );
+  }
+  return parsed.data;
+}
+function defineSharedTool(options) {
+  if (options.id) assertCapabilityId(options.id, "shared tool");
+  const { id: id2, ...definition } = options;
+  return Object.freeze(fileIdentified({
+    ...definition,
+    [FOUNDRY_SHARED_TOOL_BRAND]: true
+  }, "tool", id2));
+}
+function defineAgentApplication(options) {
+  if (options.id) assertCapabilityId(options.id, "agent application");
+  const label = options.id ?? "<application file route>";
+  const inbound = Object.freeze([...options.inbound ?? []]);
+  const outbound = Object.freeze([...options.outbound ?? []]);
+  for (const transmission of inbound) {
+    if (!transmission.inbound) {
+      throw new Error(
+        `Application "${label}" declares an outbound-only transmission as inbound.`
+      );
+    }
+  }
+  for (const transmission of outbound) {
+    if (!transmission.outbound) {
+      throw new Error(
+        `Application "${label}" declares an inbound-only transmission as outbound.`
+      );
+    }
+  }
+  const transmissionDefinitions = /* @__PURE__ */ new Map();
+  for (const transmission of [
+    ...options.transmissions ?? [],
+    ...inbound,
+    ...outbound
+  ]) {
+    const key = fileDefinitionKey(transmission);
+    const existing = transmissionDefinitions.get(key);
+    if (!existing) transmissionDefinitions.set(key, transmission);
+  }
+  const transmissions = Object.freeze([...transmissionDefinitions.values()]);
+  const connections = Object.freeze([...options.connections ?? []]);
+  const connectionIds = /* @__PURE__ */ new Set();
+  for (const connection of connections) {
+    const connectionKey = fileDefinitionKey(connection);
+    if (connectionIds.has(connectionKey)) {
+      throw new Error(`Application "${label}" contains the same connection more than once.`);
+    }
+    connectionIds.add(connectionKey);
+    for (const transmission of connection.transmissions) {
+      if (!transmissionDefinitions.has(fileDefinitionKey(transmission))) {
+        throw new Error(
+          `Application "${label}" contains a connection for a transmission it does not own.`
+        );
+      }
+    }
+  }
+  const { id: id2, ...definition } = options;
+  return Object.freeze(fileIdentified({
+    ...definition,
+    inbound,
+    outbound,
+    transmissions,
+    connections,
+    [FOUNDRY_AGENT_APPLICATION_BRAND]: true
+  }, "application", id2));
+}
+var defineApp = defineAgentApplication;
+function defineMcp(options) {
+  if (options.id) assertCapabilityId(options.id, "MCP");
+  const { id: id2, ...definition } = options;
+  return Object.freeze(fileIdentified({
+    ...definition,
+    [FOUNDRY_MCP_BRAND]: true
+  }, "mcp", id2));
+}
+function defineMemory(options) {
+  if (options.id) assertCapabilityId(options.id, "memory profile");
+  if (!options.entity && !options.episodic && !options.resources && !options.context && !options.mount) {
+    throw new Error(`Foundry memory profile "${options.id ?? "<file route>"}" is empty.`);
+  }
+  const { id: id2, ...definition } = options;
+  return Object.freeze(fileIdentified({
+    ...definition,
+    [FOUNDRY_MEMORY_BRAND]: true
+  }, "memory", id2));
+}
+var EMPTY_CAPABILITY_REGISTRY = Object.freeze({
+  tools: Object.freeze([]),
+  applications: Object.freeze([]),
+  mcp: Object.freeze([]),
+  memory: Object.freeze([])
+});
+function inboxMethods(store) {
+  return typeof store.getInboxItems === "function" && typeof store.addInboxItem === "function" && typeof store.updateInboxItem === "function" && typeof store.getResolvedInboxItems === "function";
+}
+function isInboxCapableStore(store) {
+  return inboxMethods(store);
+}
+function indexRegistry(values, kind) {
+  const result = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    if (result.has(value.id)) {
+      throw new Error(`Duplicate Foundry ${kind} id "${value.id}".`);
+    }
+    result.set(value.id, value);
+  }
+  return result;
+}
+function mountMemory(profile, context) {
+  return Effect2.gen(function* () {
+    if (profile.entity) {
+      const adapter = yield* profile.entity.adapter(context);
+      const options = profile.entity.tools ? { tools: profile.entity.tools } : void 0;
+      if ((profile.entity.access ?? "reader") === "curator") {
+        useMemoryCurator(context.glove, adapter, options);
+      } else {
+        useMemoryReader(context.glove, adapter, options);
+      }
+    }
+    if (profile.episodic) {
+      const adapter = yield* profile.episodic.adapter(context);
+      const options = profile.episodic.tools ? { tools: profile.episodic.tools } : void 0;
+      if ((profile.episodic.access ?? "reader") === "curator") {
+        useEpisodicCurator(context.glove, adapter, options);
+      } else {
+        useEpisodicReader(context.glove, adapter, options);
+      }
+    }
+    if (profile.resources) {
+      const adapter = yield* profile.resources.adapter(context);
+      const options = profile.resources.tools ? { tools: profile.resources.tools } : void 0;
+      if ((profile.resources.access ?? "reader") === "curator") {
+        useResourcesCurator(context.glove, adapter, options);
+      } else {
+        useResourcesReader(context.glove, adapter, options);
+      }
+    }
+    if (profile.context) {
+      const adapter = yield* profile.context.adapter(context);
+      useContext(
+        context.glove,
+        adapter,
+        profile.context.tools ? { tools: profile.context.tools } : void 0
+      );
+    }
+    if (profile.mount) yield* profile.mount(context);
+  });
+}
+function configureMemory(profile, config) {
+  return Object.freeze({ profile, config });
+}
+function mountAgentDefinitionMemory(options) {
+  return Effect2.gen(function* () {
+    const memory = indexRegistry(options.registry.memory, "memory profile");
+    const seen = /* @__PURE__ */ new Set();
+    for (const selection of options.memory) {
+      const reference = "profile" in selection ? selection.profile : selection;
+      const profile = memory.get(reference.id);
+      if (!profile) {
+        throw new Error(`Unknown agent memory profile "${reference.id}".`);
+      }
+      if (seen.has(`memory:${profile.id}`)) {
+        throw new Error(`Duplicate agent memory profile "${profile.id}".`);
+      }
+      seen.add(`memory:${profile.id}`);
+      const config = typeof selection === "object" && "profile" in selection ? selection.config : void 0;
+      const capability = {
+        kind: "memory",
+        id: profile.id,
+        ...config !== void 0 ? { config } : {}
+      };
+      const context = {
+        ...options.context,
+        surface: { kind: "memory", id: profile.id },
+        config: decodeCapabilityConfig(profile, capability)
+      };
+      yield* mountMemory(profile, context);
+      options.context.emit({
+        type: "foundry.definition.memory.mounted",
+        data: { id: profile.id }
+      });
+    }
+  });
+}
+function installRegistry(options) {
+  return Effect2.gen(function* () {
+    const tools = indexRegistry(options.registry.tools, "shared tool");
+    const applications = indexRegistry(
+      options.registry.applications,
+      "agent application"
+    );
+    const mcp = indexRegistry(options.registry.mcp, "MCP");
+    const seen = /* @__PURE__ */ new Set();
+    const installedMcp = [];
+    const installed = [];
+    for (const installation of options.installations) {
+      assertCapabilityId(installation.id, installation.kind);
+      if (installation.config && typeof installation.config === "object" && Object.prototype.hasOwnProperty.call(installation.config, "accountId")) {
+        throw new Error(
+          `Installation config for ${installation.kind} "${installation.id}" cannot contain accountId. Select a persisted account on the installation, or pass { account } as install()'s third argument in code.`
+        );
+      }
+      const key = installationKey(installation);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const definition = installation.kind === "tool" ? tools.get(installation.id) : installation.kind === "application" ? applications.get(installation.id) : mcp.get(installation.id);
+      if (!definition) {
+        throw new Error(
+          `Agent "${options.context.agentId}" requests unknown ${installation.kind} "${installation.id}".`
+        );
+      }
+      const config = decodeCapabilityConfig(
+        definition,
+        installation
+      );
+      const context = {
+        ...options.context,
+        installation,
+        config,
+        ...installation.accountId ? {
+          accountId: installation.accountId,
+          ...options.accountSessions ? {
+            withAccountSession: (operation, use) => options.accountSessions.withSession({
+              accountId: installation.accountId,
+              operation,
+              agentId: options.context.agentId,
+              conversationId: options.context.conversationId,
+              workspaceId: options.context.workspaceId
+            }, use)
+          } : {}
+        } : {}
+      };
+      if (installation.kind === "tool") {
+        const shared = definition;
+        const tool = shared.tool ?? (yield* shared.create(context));
+        options.context.glove.fold(tool);
+      } else if (installation.kind === "application") {
+        const { glove: _glove, store: _store, ...headlessContext } = context;
+        const application = definition;
+        const contribution = application.install ? yield* application.install(headlessContext) : void 0;
+        for (const tool of contribution?.tools ?? []) options.context.glove.fold(tool);
+      } else {
+        installedMcp.push(definition);
+      }
+      installed.push(installation);
+      options.context.emit({
+        type: "foundry.installation.completed",
+        data: { kind: installation.kind, id: installation.id }
+      });
+    }
+    if (installedMcp.length > 0) {
+      if (!options.mcpAdapter) {
+        throw new Error(
+          `Agent "${options.context.agentId}" installs MCP capabilities but the application does not define mcpAdapter.`
+        );
+      }
+      const adapter = yield* options.mcpAdapter({
+        ...options.context,
+        installed: installedMcp
+      });
+      const selectedIds = new Set(installedMcp.map((entry) => entry.id));
+      const scopedAdapter = {
+        identifier: adapter.identifier,
+        getActive: async () => [...selectedIds],
+        activate: (id2) => adapter.activate(id2),
+        deactivate: (id2) => adapter.deactivate(id2),
+        ...adapter.getAccessToken ? { getAccessToken: (id2) => adapter.getAccessToken(id2) } : {},
+        ...adapter.getAuthHeaders ? { getAuthHeaders: (id2) => adapter.getAuthHeaders(id2) } : {}
+      };
+      yield* Effect2.tryPromise({
+        try: () => mountMcp(options.context.glove, {
+          adapter: scopedAdapter,
+          entries: installedMcp.map((definition) => ({
+            ...definition.entry,
+            id: definition.id
+          })),
+          ambiguityPolicy: { type: "auto-pick-best" }
+        }),
+        catch: (cause) => cause
+      });
+    }
+    return Object.freeze(installed);
+  });
+}
+function isFoundryCapability(value) {
+  if (!value || typeof value !== "object") return false;
+  const object = value;
+  return object[FOUNDRY_SHARED_TOOL_BRAND] === true || object[FOUNDRY_AGENT_APPLICATION_BRAND] === true || object[FOUNDRY_MCP_BRAND] === true || object[FOUNDRY_MEMORY_BRAND] === true;
+}
+
+// src/surfaces.ts
+import { Effect as Effect3 } from "effect";
+var FOUNDRY_LAYER_BRAND = /* @__PURE__ */ Symbol.for("glove-foundry-layer");
+var FOUNDRY_SUBSCRIBER_BRAND = /* @__PURE__ */ Symbol.for(
+  "glove-foundry-subscriber"
+);
+var SURFACE_ID = /^[a-z][a-z0-9-]*(?:\/[a-z][a-z0-9-]*)*$/;
+function assertSurfaceId(id2, label) {
+  if (!SURFACE_ID.test(id2)) {
+    throw new Error(
+      `Invalid Foundry ${label} id "${id2}". Use lowercase path segments containing letters, digits, and hyphens.`
+    );
+  }
+}
+function defineLayer(options) {
+  if (options.id) assertSurfaceId(options.id, "layer");
+  const { id: id2, ...definition } = options;
+  return Object.freeze(fileIdentified({
+    ...definition,
+    [FOUNDRY_LAYER_BRAND]: true
+  }, "layer", id2));
+}
+function configureLayer(layer, config) {
+  return Object.freeze({ layer, config });
+}
+function defineSubscriber(options) {
+  if (options.id) assertSurfaceId(options.id, "subscriber");
+  const { id: id2, ...definition } = options;
+  return Object.freeze(fileIdentified({
+    ...definition,
+    [FOUNDRY_SUBSCRIBER_BRAND]: true
+  }, "subscriber", id2));
+}
+var EMPTY_NATIVE_REGISTRY = Object.freeze({
+  layers: Object.freeze([]),
+  subscribers: Object.freeze([])
+});
+function indexById(values, label) {
+  const indexed = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    if (indexed.has(value.id)) {
+      throw new Error(`Duplicate Foundry ${label} id "${value.id}".`);
+    }
+    indexed.set(value.id, value);
+  }
+  return indexed;
+}
+async function mountFoundrySurfaces(options) {
+  const layers = indexById(options.registry.layers, "layer");
+  const subscribers = indexById(options.registry.subscribers, "subscriber");
+  const cleanup = [];
+  const disposeAll = async () => {
+    const failures = [];
+    for (const dispose of cleanup.reverse()) {
+      try {
+        const result = dispose();
+        if (Effect3.isEffect(result)) await Effect3.runPromise(result);
+        else await Promise.resolve(result);
+      } catch (cause) {
+        failures.push(cause);
+      }
+    }
+    if (failures.length > 0) {
+      throw new AggregateError(failures, "Foundry surface cleanup failed.");
+    }
+  };
+  try {
+    for (const selected of options.subscribers ?? []) {
+      let definition = selected;
+      if (typeof definition === "object" && definition !== null && FOUNDRY_SUBSCRIBER_BRAND in definition) {
+        const registered = subscribers.get(definition.id);
+        if (!registered) {
+          throw new Error(
+            `Agent "${options.context.agentId}" references unknown subscriber "${definition.id}".`
+          );
+        }
+        definition = registered;
+      }
+      let subscriber;
+      let subscriberId = "inline";
+      if (typeof definition === "object" && definition !== null && definition[FOUNDRY_SUBSCRIBER_BRAND] === true) {
+        const foundrySubscriber = definition;
+        const created = typeof foundrySubscriber.create === "function" ? foundrySubscriber.create(options.context) : foundrySubscriber.create;
+        subscriber = Effect3.isEffect(created) ? await Effect3.runPromise(created) : await Promise.resolve(created);
+        subscriberId = foundrySubscriber.id;
+      } else {
+        subscriber = definition;
+      }
+      options.context.glove.addSubscriber(subscriber);
+      cleanup.push(() => options.context.glove.removeSubscriber(subscriber));
+      options.context.emit({
+        type: "foundry.subscriber.mounted",
+        data: { id: subscriberId }
+      });
+    }
+    for (const selected of options.layers ?? []) {
+      const reference = FOUNDRY_LAYER_BRAND in selected ? { layer: selected } : selected;
+      const definition = layers.get(reference.layer.id);
+      if (!definition) {
+        throw new Error(
+          `Agent "${options.context.agentId}" references unknown layer "${reference.layer.id}".`
+        );
+      }
+      const referenceConfig = "config" in reference ? reference.config : void 0;
+      const parsed = definition.config ? definition.config.safeParse(referenceConfig ?? {}) : { success: true, data: referenceConfig };
+      if (!parsed.success) {
+        throw new Error(
+          `Invalid config for layer "${definition.id}": ${parsed.error.message}`
+        );
+      }
+      const dispose = await Effect3.runPromise(
+        definition.setup({ ...options.context, config: parsed.data })
+      );
+      if (dispose) cleanup.push(dispose);
+      options.context.emit({
+        type: "foundry.layer.mounted",
+        data: { id: definition.id }
+      });
+    }
+  } catch (cause) {
+    try {
+      await disposeAll();
+    } catch (cleanupCause) {
+      throw new AggregateError(
+        [cause, cleanupCause],
+        "Foundry surface mount and cleanup failed."
+      );
+    }
+    throw cause;
+  }
+  return disposeAll;
+}
+function isFoundryLayer(value) {
+  return Boolean(
+    value && typeof value === "object" && value[FOUNDRY_LAYER_BRAND] === true
+  );
+}
+function isFoundrySubscriber(value) {
+  return Boolean(
+    value && typeof value === "object" && value[FOUNDRY_SUBSCRIBER_BRAND] === true
+  );
+}
+
+// src/playbook.ts
+import { createHash } from "node:crypto";
+var ID = /^[a-z][a-z0-9-]*(?:\/[a-z][a-z0-9-]*)*$/;
+function assertData(value, path, seen = /* @__PURE__ */ new Set()) {
+  if (value === void 0) throw new Error(`Playbook ${path} cannot contain undefined.`);
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new Error(`Playbook ${path} must contain a finite number.`);
+  }
+  if (typeof value === "function" || typeof value === "symbol" || typeof value === "bigint") {
+    throw new Error(`Playbook ${path} must be serializable data, not ${typeof value}.`);
+  }
+  if (!value || typeof value !== "object") return;
+  const prototype = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+    throw new Error(`Playbook ${path} must contain plain objects and arrays only.`);
+  }
+  if (seen.has(value)) throw new Error(`Playbook ${path} cannot contain circular data.`);
+  seen.add(value);
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertData(item, `${path}[${index}]`, seen));
+  } else {
+    for (const [key, item] of Object.entries(value)) assertData(item, `${path}.${key}`, seen);
+  }
+  seen.delete(value);
+}
+function cloneData(value) {
+  if (Array.isArray(value)) return value.map(cloneData);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [key, cloneData(item)])
+    );
+  }
+  return value;
+}
+function freezeData(value) {
+  if (!value || typeof value !== "object") return value;
+  for (const item of Object.values(value)) freezeData(item);
+  return Object.freeze(value);
+}
+function normalizePlaybook(playbook) {
+  const authored = "transmission" in playbook;
+  const id2 = playbook.id;
+  if (!id2) throw new Error("A persisted playbook must have an id.");
+  const transmissionId = authored ? playbook.transmission.id : playbook.transmissionId;
+  const normalized = {
+    id: id2,
+    transmissionId,
+    ...playbook.enabled !== void 0 ? { enabled: playbook.enabled } : {},
+    ...playbook.match ? {
+      match: {
+        ...playbook.match.event ? { event: authored ? playbook.match.event.id : playbook.match.event } : {},
+        ...(authored ? playbook.match.routes?.length : playbook.match.routeIds?.length) ? {
+          routeIds: authored ? playbook.match.routes?.map((route) => route.id) : playbook.match.routeIds
+        } : {},
+        ...playbook.match.predicate ? {
+          predicate: {
+            name: authored ? playbook.match.predicate.definition.id : playbook.match.predicate.name,
+            ...playbook.match.predicate.parameters ? { parameters: playbook.match.predicate.parameters } : {}
+          }
+        } : {}
+      }
+    } : {},
+    directives: authored ? playbook.directives.map((directive) => ({
+      action: directive.action.id,
+      instruction: directive.instruction,
+      ...directive.parameters ? { parameters: directive.parameters } : {}
+    })) : playbook.directives,
+    ...playbook.applications ? {
+      applications: authored ? playbook.applications.map((application) => application.id) : playbook.applications
+    } : {},
+    ...playbook.outbound ? {
+      outbound: authored ? playbook.outbound.map(
+        (outbound) => ({
+          routeId: outbound.route.id,
+          ...outbound.application ? { applicationId: outbound.application.id } : {},
+          ...outbound.event ? { event: outbound.event.id } : {},
+          ...outbound.account ? { accountId: outbound.account.id } : {},
+          ...outbound.applicationAccount ? { applicationAccountId: outbound.applicationAccount.id } : {},
+          ...outbound.instruction ? { instruction: outbound.instruction } : {}
+        })
+      ) : playbook.outbound.map(
+        (outbound) => ({ ...outbound })
+      )
+    } : {},
+    ...playbook.serialization ? { serialization: playbook.serialization } : {},
+    ..."origin" in playbook && playbook.origin ? { origin: playbook.origin } : {},
+    ..."playbookName" in playbook && playbook.playbookName ? { playbookName: playbook.playbookName } : {},
+    ..."definitionRevision" in playbook && playbook.definitionRevision ? { definitionRevision: playbook.definitionRevision } : {}
+  };
+  if (!ID.test(id2)) throw new Error(`Invalid playbook id "${id2}".`);
+  if (!ID.test(transmissionId)) {
+    throw new Error(`Invalid transmission id "${transmissionId}" in playbook "${playbook.id}".`);
+  }
+  if (normalized.directives.length === 0) {
+    throw new Error(`Playbook "${playbook.id}" must define at least one action directive.`);
+  }
+  if (normalized.match?.predicate && !normalized.match.predicate.name) {
+    throw new Error(`Playbook "${playbook.id}" predicate must reference a definition.`);
+  }
+  for (const outbound of normalized.outbound ?? []) {
+    if (!outbound.routeId) throw new Error(`Playbook "${playbook.id}" outbound must reference a route.`);
+  }
+  assertData(normalized, normalized.id);
+  return freezeData(cloneData(normalized));
+}
+function composePlaybook(playbook) {
+  if (!playbook.name.trim()) throw new Error("A composed playbook name is required.");
+  if (playbook.directives.length === 0) throw new Error("A playbook must define an action directive.");
+  for (const directive of playbook.directives) {
+    if (!directive.instruction) throw new Error("A playbook directive must have an instruction.");
+    if (directive.parameters) assertData(directive.parameters, "directive.parameters");
+  }
+  const transmissionEvents = new Set(
+    (playbook.transmission.events ?? []).map(fileDefinitionKey)
+  );
+  for (const event of [
+    playbook.match?.event,
+    ...(playbook.outbound ?? []).map((entry) => entry.event)
+  ]) {
+    if (event && !transmissionEvents.has(fileDefinitionKey(event))) {
+      throw new Error("A playbook event must be declared by its transmission definition.");
+    }
+  }
+  if (playbook.serialization) assertData(playbook.serialization, "serialization");
+  return Object.freeze({
+    ...playbook,
+    directives: Object.freeze([...playbook.directives]),
+    [FOUNDRY_COMPOSED_PLAYBOOK_BRAND]: true
+  });
+}
+function materializeComposedPlaybook(playbook, id2, revision) {
+  return normalizePlaybook({
+    ...playbook,
+    id: id2,
+    origin: "agent-definition",
+    playbookName: playbook.name,
+    definitionRevision: revision
+  });
+}
+function reconstructPlaybook(playbook) {
+  return normalizePlaybook(playbook);
+}
+var FOUNDRY_PLAYBOOK_ACTION_BRAND = /* @__PURE__ */ Symbol.for("glove-foundry-playbook-action");
+var FOUNDRY_COMPOSED_PLAYBOOK_BRAND = /* @__PURE__ */ Symbol.for("glove-foundry-composed-playbook");
+function agentPlaybookId(definitionId, agentId, name) {
+  return `playbook-${createHash("sha256").update(`${definitionId}\0${agentId}\0${name}`).digest("hex").slice(0, 24)}`;
+}
+function composedPlaybookRevision(playbook) {
+  const materialized = materializeComposedPlaybook(playbook, "playbook-revision", "pending");
+  const { id: _id, definitionRevision: _revision, ...data } = materialized;
+  return createHash("sha256").update(JSON.stringify(data)).digest("hex");
+}
+function definePlaybookAction(options = {}) {
+  if (options.id && !ID.test(options.id)) {
+    throw new Error(`Invalid playbook action id "${options.id}".`);
+  }
+  const { id: id2, ...definition } = options;
+  return Object.freeze(fileIdentified({
+    ...definition,
+    [FOUNDRY_PLAYBOOK_ACTION_BRAND]: true
+  }, "action", id2));
+}
+
+// src/subscription.ts
+var FOUNDRY_PLAYBOOK_SUBSCRIPTION_BRAND = /* @__PURE__ */ Symbol.for(
+  "glove-foundry-playbook-subscription"
+);
+var ID2 = /^[a-z][a-z0-9-]*(?:\/[a-z][a-z0-9-]*)*$/;
+function freezeData2(value) {
+  if (!value || typeof value !== "object") return value;
+  for (const child of Object.values(value)) freezeData2(child);
+  return Object.freeze(value);
+}
+function definePlaybookSubscription(options) {
+  if (options.id && !ID2.test(options.id)) {
+    throw new Error(`Invalid playbook subscription id "${options.id}".`);
+  }
+  if (options.targets.length === 0) {
+    throw new Error("A playbook subscription must target at least one agent.");
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const targets = options.targets.map((target) => {
+    const authored2 = {
+      provisioning: target.provisioning ?? { mode: "singleton" },
+      context: structuredClone(target.context ?? {}),
+      installations: target.installations ?? []
+    };
+    Object.defineProperty(authored2, "definitionId", {
+      enumerable: true,
+      get: () => target.agent.id
+    });
+    return Object.freeze(authored2);
+  });
+  const authored = fileIdentified({
+    workspaceId: options.workspaceId ?? "default",
+    enabled: options.enabled ?? true,
+    playbook: options.playbook,
+    targets,
+    createdAt: options.createdAt ?? now,
+    updatedAt: options.updatedAt ?? now,
+    [FOUNDRY_PLAYBOOK_SUBSCRIPTION_BRAND]: true
+  }, "subscription", options.id);
+  return Object.freeze(authored);
+}
+function reconstructPlaybookSubscription(subscription) {
+  return freezeData2({
+    ...structuredClone(subscription),
+    playbook: reconstructPlaybook(subscription.playbook)
+  });
+}
+
+// src/primitives.ts
+import { randomUUID } from "node:crypto";
+import { Effect as Effect4 } from "effect";
+function toGloveMessage(input) {
+  if (typeof input === "string") {
+    return freezeGloveMessage({ sender: "user", text: input });
+  }
+  const text = input.filter((part) => part.type === "text" && part.text).map((part) => part.text).join("\n");
+  const media = input.filter((part) => part.type !== "text").map(cloneContentPart);
+  if (media.length === 0) {
+    return freezeGloveMessage({ sender: "user", text });
+  }
+  return freezeGloveMessage({
+    sender: "user",
+    text: text.length > 0 ? text : "[multimodal message]",
+    content: [
+      ...text.length > 0 ? [{ type: "text", text }] : [],
+      ...media
+    ]
+  });
+}
+function freezeGloveMessage(message) {
+  return freezeInstanceData(structuredClone(message));
+}
+function toGloveRequestInput(input) {
+  return typeof input === "string" ? input : input.map(cloneContentPart);
+}
+function cloneContentPart(part) {
+  return {
+    ...part,
+    ...part.source ? { source: { ...part.source } } : {}
+  };
+}
+var MemoryFoundryDataAdapter = class {
+  identifier;
+  agents = /* @__PURE__ */ new Map();
+  agentsByProvisioningKey = /* @__PURE__ */ new Map();
+  subscriptions = /* @__PURE__ */ new Map();
+  inboundDeliveries = /* @__PURE__ */ new Map();
+  activations = /* @__PURE__ */ new Map();
+  conversations = /* @__PURE__ */ new Map();
+  workspace = /* @__PURE__ */ new Map();
+  workingEnvironments = /* @__PURE__ */ new Map();
+  inbox = /* @__PURE__ */ new Map();
+  tasks = /* @__PURE__ */ new Map();
+  environment;
+  pendingAgents;
+  pendingSubscriptions;
+  constructor(options) {
+    this.identifier = options?.identifier ?? "foundry-memory-data";
+    this.environment = [...options?.environment ?? []];
+    this.pendingAgents = [...options?.agents ?? []];
+    this.pendingSubscriptions = [...options?.subscriptions ?? []];
+    for (const activation of options?.activations ?? []) {
+      this.activations.set(activation.id, reconstructActivation(activation));
+    }
+    for (const conversation of options?.conversations ?? []) this.conversations.set(conversation.id, conversation);
+  }
+  /** Resolve file-owned identities only after Foundry discovery has bound them. */
+  materializeSeeds() {
+    for (const agent of this.pendingAgents) {
+      const reconstructed = reconstructAgentInstance(agent);
+      this.agents.set(agent.id, reconstructed);
+      if (reconstructed.provisioningKey) {
+        this.agentsByProvisioningKey.set(reconstructed.provisioningKey, reconstructed.id);
+      }
+    }
+    this.pendingAgents = [];
+    for (const subscription of this.pendingSubscriptions) {
+      this.subscriptions.set(subscription.id, reconstructPlaybookSubscription(subscription));
+    }
+    this.pendingSubscriptions = [];
+  }
+  getAgent(id2) {
+    return Effect4.sync(() => {
+      this.materializeSeeds();
+      return this.agents.get(id2) ?? null;
+    });
+  }
+  putAgent(agent) {
+    return Effect4.sync(() => {
+      this.materializeSeeds();
+      const reconstructed = reconstructAgentInstance(agent);
+      const prior = this.agents.get(agent.id);
+      if (prior?.provisioningKey && prior.provisioningKey !== reconstructed.provisioningKey) {
+        this.agentsByProvisioningKey.delete(prior.provisioningKey);
+      }
+      this.agents.set(agent.id, reconstructed);
+      if (reconstructed.provisioningKey) {
+        this.agentsByProvisioningKey.set(reconstructed.provisioningKey, reconstructed.id);
+      }
+    });
+  }
+  listAgents(definitionId) {
+    return Effect4.sync(() => {
+      this.materializeSeeds();
+      return [...this.agents.values()].filter((item) => !definitionId || item.definitionId === definitionId);
+    });
+  }
+  provisionAgent(input) {
+    return Effect4.sync(() => {
+      this.materializeSeeds();
+      const existingId = this.agentsByProvisioningKey.get(input.provisioningKey);
+      if (existingId) return this.agents.get(existingId);
+      const created = createAgentInstance(input.definitionId, {
+        ...input,
+        id: input.id ?? `agent_${randomUUID()}`
+      }, input.provisioningKey);
+      this.agents.set(created.id, created);
+      this.agentsByProvisioningKey.set(input.provisioningKey, created.id);
+      return created;
+    });
+  }
+  getPlaybookSubscription(id2) {
+    return Effect4.sync(() => {
+      this.materializeSeeds();
+      return this.subscriptions.get(id2) ?? null;
+    });
+  }
+  putPlaybookSubscription(subscription) {
+    return Effect4.sync(() => {
+      this.materializeSeeds();
+      this.subscriptions.set(subscription.id, reconstructPlaybookSubscription(subscription));
+    });
+  }
+  deletePlaybookSubscription(id2) {
+    return Effect4.sync(() => {
+      this.materializeSeeds();
+      return this.subscriptions.delete(id2);
+    });
+  }
+  listPlaybookSubscriptions(workspaceId) {
+    return Effect4.sync(() => {
+      this.materializeSeeds();
+      return [...this.subscriptions.values()].filter((item) => !workspaceId || item.workspaceId === workspaceId);
+    });
+  }
+  getInboundDelivery(key) {
+    return Effect4.succeed(this.inboundDeliveries.get(key) ?? null);
+  }
+  claimInboundDelivery(key) {
+    return Effect4.sync(() => {
+      if (this.inboundDeliveries.has(key)) return false;
+      this.inboundDeliveries.set(key, Object.freeze({
+        key,
+        status: "pending",
+        runIds: Object.freeze([]),
+        claimedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+      return true;
+    });
+  }
+  completeInboundDelivery(key, runIds) {
+    return Effect4.sync(() => {
+      const prior = this.inboundDeliveries.get(key);
+      if (!prior) throw new Error(`Inbound delivery claim "${key}" does not exist.`);
+      this.inboundDeliveries.set(key, Object.freeze({
+        ...prior,
+        status: "completed",
+        runIds: Object.freeze([...runIds]),
+        completedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+    });
+  }
+  releaseInboundDelivery(key) {
+    return Effect4.sync(() => {
+      if (this.inboundDeliveries.get(key)?.status === "pending") {
+        this.inboundDeliveries.delete(key);
+      }
+    });
+  }
+  getActivation(id2) {
+    return Effect4.succeed(this.activations.get(id2) ?? null);
+  }
+  putActivation(activation) {
+    return Effect4.sync(() => {
+      this.activations.set(activation.id, reconstructActivation(activation));
+    });
+  }
+  listActivations(workspaceId) {
+    return Effect4.succeed(
+      [...this.activations.values()].filter((item) => !workspaceId || item.workspaceId === workspaceId)
+    );
+  }
+  getConversation(id2) {
+    return Effect4.succeed(this.conversations.get(id2) ?? null);
+  }
+  putConversation(conversation) {
+    return Effect4.sync(() => {
+      this.conversations.set(conversation.id, Object.freeze({ ...conversation }));
+    });
+  }
+  listConversations(agentId) {
+    return Effect4.succeed([...this.conversations.values()].filter((item) => item.agentId === agentId));
+  }
+  getWorkspaceEntry(workspaceId, key) {
+    return Effect4.succeed(this.workspace.get(`${workspaceId}:${key}`) ?? null);
+  }
+  putWorkspaceEntry(entry) {
+    return Effect4.sync(() => {
+      this.workspace.set(`${entry.workspaceId}:${entry.key}`, Object.freeze({ ...entry }));
+    });
+  }
+  listWorkspaceEntries(workspaceId) {
+    return Effect4.succeed([...this.workspace.values()].filter((item) => item.workspaceId === workspaceId));
+  }
+  getWorkingEnvironmentSnapshot(owner) {
+    return Effect4.sync(() => {
+      const snapshot = this.workingEnvironments.get(workingEnvironmentOwnerKey(owner));
+      return snapshot ? structuredClone(snapshot) : null;
+    });
+  }
+  putWorkingEnvironmentSnapshot(owner, snapshot) {
+    return Effect4.sync(() => {
+      this.workingEnvironments.set(
+        workingEnvironmentOwnerKey(owner),
+        structuredClone(snapshot)
+      );
+    });
+  }
+  putInboxItem(item) {
+    return Effect4.sync(() => {
+      this.inbox.set(item.id, Object.freeze({ ...item }));
+    });
+  }
+  listInboxItems(workspaceId) {
+    return Effect4.succeed([...this.inbox.values()].filter((item) => item.workspaceId === workspaceId));
+  }
+  putTask(task) {
+    return Effect4.sync(() => {
+      this.tasks.set(task.id, Object.freeze({ ...task }));
+    });
+  }
+  listTasks(workspaceId) {
+    return Effect4.succeed([...this.tasks.values()].filter((item) => item.workspaceId === workspaceId));
+  }
+  listEnvironment(scope) {
+    return Effect4.succeed(this.environment.filter(
+      (item) => item.workspaceId === scope.workspaceId && (item.scope === "workspace" || item.scope === "agent" && item.agentId === scope.agentId || item.scope === "conversation" && item.conversationId === scope.conversationId)
+    ));
+  }
+};
+function workingEnvironmentOwnerKey(owner) {
+  return [
+    owner.scope,
+    owner.workspaceId,
+    owner.definitionId,
+    owner.agentId,
+    owner.scope === "conversation" ? owner.conversationId : ""
+  ].join("\0");
+}
+function reconstructActivation(activation) {
+  return Object.freeze({
+    ...activation,
+    ...activation.payload !== void 0 ? { payload: freezeInstanceData(structuredClone(activation.payload)) } : {},
+    timing: Object.freeze({ ...activation.timing })
+  });
+}
+function createAgentInstance(definitionId, options = {}, provisioningKey) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return reconstructAgentInstance({
+    id: options.id ?? `agent_${randomUUID()}`,
+    definitionId,
+    workspaceId: options.workspaceId ?? "default",
+    ...provisioningKey ? { provisioningKey } : {},
+    context: options.context ?? {},
+    installations: options.installations ?? [],
+    playbooks: options.playbooks ?? [],
+    createdAt: now,
+    updatedAt: now
+  });
+}
+function defineAgentInstance(definition, options = {}) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const seed = {
+    id: options.id ?? `agent_${randomUUID()}`,
+    workspaceId: options.workspaceId ?? "default",
+    context: options.context ?? {},
+    installations: options.installations ?? [],
+    playbooks: options.playbooks ?? [],
+    createdAt: now,
+    updatedAt: now
+  };
+  Object.defineProperty(seed, "definitionId", {
+    enumerable: true,
+    get: () => definition.id
+  });
+  return Object.freeze(seed);
+}
+function reconstructAgentInstance(agent) {
+  return Object.freeze({
+    ...agent,
+    context: freezeInstanceData(structuredClone(agent.context)),
+    installations: normalizeAgentInstallations(agent.installations),
+    playbooks: Object.freeze(agent.playbooks.map(reconstructPlaybook))
+  });
+}
+function normalizeAgentInstallations(installations) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const installation of installations) {
+    const copy = Object.freeze({
+      kind: installation.kind,
+      id: installation.id,
+      ...installation.accountId !== void 0 ? { accountId: installation.accountId } : {},
+      ...installation.config !== void 0 ? { config: freezeInstanceData(structuredClone(installation.config)) } : {}
+    });
+    byKey.set(installationKey(copy), copy);
+  }
+  return Object.freeze([...byKey.values()]);
+}
+function freezeInstanceData(value) {
+  if (!value || typeof value !== "object") return value;
+  for (const child of Object.values(value)) {
+    freezeInstanceData(child);
+  }
+  return Object.freeze(value);
+}
+function createConversation(agent, options = {}) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return Object.freeze({
+    id: options.id ?? `conversation_${randomUUID()}`,
+    agentId: agent.id,
+    workspaceId: options.workspaceId ?? agent.workspaceId,
+    ...options.title ? { title: options.title } : {},
+    context: Object.freeze({ ...options.context ?? {} }),
+    createdAt: now,
+    updatedAt: now
+  });
+}
+function id(prefix) {
+  return `${prefix}_${randomUUID()}`;
+}
+
+// src/schedule.ts
+import { createHash as createHash2 } from "node:crypto";
+import { Duration } from "effect";
+var FOUNDRY_SCHEDULE_BRAND = /* @__PURE__ */ Symbol.for("glove-foundry-schedule");
+var COMPACT_DURATION = /^(\d+)\s*(ms|s|m|h|d|w)$/i;
+function durationMillis(value) {
+  const compact = value.match(COMPACT_DURATION);
+  const input = compact ? `${compact[1]} ${{ ms: "millis", s: "seconds", m: "minutes", h: "hours", d: "days", w: "weeks" }[compact[2].toLowerCase()]}` : value;
+  const milliseconds = Duration.toMillis(Duration.decode(input));
+  if (!Number.isFinite(milliseconds) || milliseconds <= 0) {
+    throw new Error("Duration must be finite and greater than zero.");
+  }
+  return milliseconds;
+}
+function normalizeScheduleTiming(timing, now = Date.now()) {
+  if (timing.kind === "after") {
+    return Object.freeze({ kind: "at", at: new Date(now + durationMillis(timing.duration)).toISOString() });
+  }
+  if (timing.kind === "every") {
+    return Object.freeze({ kind: "every", intervalMs: durationMillis(timing.interval) });
+  }
+  if (timing.kind === "cron") {
+    if (!timing.expression.trim()) throw new Error("A cron expression is required.");
+    return Object.freeze({ kind: "cron", expression: timing.expression, timezone: timing.timezone ?? "UTC" });
+  }
+  const at = new Date(timing.at);
+  if (Number.isNaN(at.getTime())) throw new Error(`Invalid schedule date "${timing.at}".`);
+  return Object.freeze({ kind: "at", at: at.toISOString() });
+}
+function defineSchedule(options) {
+  if (!options.name.trim()) throw new Error("A Foundry schedule name is required.");
+  if (!options.message.trim()) throw new Error("A Foundry schedule message is required.");
+  normalizeScheduleTiming(options.timing);
+  return Object.freeze({
+    ...options,
+    ...options.payload !== void 0 ? { payload: structuredClone(options.payload) } : {},
+    timing: Object.freeze({ ...options.timing }),
+    enabled: options.enabled ?? true,
+    [FOUNDRY_SCHEDULE_BRAND]: true
+  });
+}
+function isFoundrySchedule(value) {
+  return Boolean(value && typeof value === "object" && value[FOUNDRY_SCHEDULE_BRAND] === true);
+}
+function agentScheduleActivationId(definitionId, agentId, name) {
+  const digest = createHash2("sha256").update(`${definitionId}\0${agentId}\0${name}`).digest("hex").slice(0, 24);
+  return `activation_${digest}`;
+}
+function agentScheduleRevision(schedule) {
+  return createHash2("sha256").update(JSON.stringify({
+    message: schedule.message,
+    payload: schedule.payload,
+    timing: schedule.timing,
+    enabled: schedule.enabled !== false
+  })).digest("hex");
+}
+
+// src/core-tools.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { Effect as Effect5, JSONSchema, Schema } from "effect";
+import { z } from "zod";
+var FOUNDRY_CORE_COMMAND_EVENT = "foundry.core.command";
+function commandId() {
+  return `command_${randomUUID2()}`;
+}
+function durationSchema(description) {
+  return z.string().describe(description).refine((value) => {
+    try {
+      durationMillis(value);
+      return true;
+    } catch {
+      return false;
+    }
+  }, "Use a positive duration such as 30s, 5m, 2h, or '5 minutes'.");
+}
+function afterDuration(value) {
+  return normalizeScheduleTiming({ kind: "after", duration: value }).at;
+}
+var timingInputSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("at"), at: z.string().datetime() }),
+  z.object({ kind: z.literal("after"), duration: durationSchema("Delay before the one-time activation") }),
+  z.object({ kind: z.literal("every"), interval: durationSchema("Interval between recurring activations") }),
+  z.object({ kind: z.literal("cron"), expression: z.string().min(1), timezone: z.string().min(1).default("UTC") })
+]);
+function toolSegment(value) {
+  return value.replaceAll("/", "__").replaceAll("-", "_");
+}
+function outboundToolSchema(transmission, routeIds) {
+  const document = JSONSchema.make(transmission.outbound.input);
+  const { $schema: _schema, $defs, ...payload } = document;
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      routeId: {
+        type: "string",
+        description: "Authorized Foundry outbound route id",
+        ...routeIds.length > 0 ? { enum: routeIds } : {}
+      },
+      payload
+    },
+    required: ["routeId", "payload"],
+    ...$defs ? { $defs } : {}
+  };
+}
+function createInstalledApplicationTransmissionTools(context, applications, installations, playbooks = context.agentInstance.playbooks) {
+  const installed = new Set(
+    installations.filter((item) => item.kind === "application").map((item) => item.id)
+  );
+  const emit = (command) => {
+    context.controls.commands.push(command);
+    context.controls.emit({ type: FOUNDRY_CORE_COMMAND_EVENT, data: command });
+    return success(command);
+  };
+  const tools = [];
+  for (const application of applications) {
+    if (!installed.has(application.id)) continue;
+    for (const transmission of application.transmissions ?? []) {
+      if (!transmission.outbound) continue;
+      const routeIds = [...new Set(
+        playbooks.filter(
+          (playbook) => playbook.enabled !== false && playbook.transmissionId === transmission.id
+        ).flatMap(
+          (playbook) => (playbook.outbound ?? []).filter(
+            (outbound) => outbound.applicationId ? outbound.applicationId === application.id : (playbook.applications ?? []).includes(application.id)
+          ).map((outbound) => outbound.routeId)
+        )
+      )].sort();
+      tools.push({
+        name: `glove_app_${toolSegment(application.id)}__${toolSegment(transmission.id)}_send`,
+        description: [
+          `Send through the ${transmission.name} outbound transmission installed by the ${application.id} application.`,
+          routeIds.length > 0 ? `Allowed playbook routes: ${routeIds.join(", ")}.` : "Supply a route authorized for this agent run."
+        ].join(" "),
+        jsonSchema: outboundToolSchema(transmission, routeIds),
+        async do(input) {
+          if (routeIds.length > 0 && !routeIds.includes(input.routeId)) {
+            return {
+              status: "error",
+              data: null,
+              message: `Route "${input.routeId}" is not selected for application "${application.id}".`
+            };
+          }
+          try {
+            const payload = await Schema.decodeUnknownPromise(
+              transmission.outbound.input
+            )(input.payload);
+            return emit({
+              id: commandId(),
+              type: "transmit",
+              definitionId: context.definitionId,
+              agentId: context.agentId,
+              conversationId: context.conversationId,
+              workspaceId: context.workspaceId,
+              routeId: input.routeId,
+              payload,
+              applicationId: application.id,
+              transmissionId: transmission.id
+            });
+          } catch (cause) {
+            return {
+              status: "error",
+              data: null,
+              message: cause instanceof Error ? cause.message : String(cause)
+            };
+          }
+        }
+      });
+    }
+  }
+  return Object.freeze(tools);
+}
+function success(command) {
+  return {
+    status: "success",
+    data: {
+      commandId: command.id,
+      accepted: true,
+      type: command.type,
+      ...command.type === "sleep" ? { wakeAt: command.wakeAt } : {},
+      ...command.type === "schedule" ? { timing: command.timing } : {},
+      ..."activationId" in command ? { activationId: command.activationId } : {}
+    }
+  };
+}
+function createFoundryCoreTools(context, desiredSchedules = []) {
+  const emit = (command) => {
+    context.controls.commands.push(command);
+    context.controls.emit({ type: FOUNDRY_CORE_COMMAND_EVENT, data: command });
+    return success(command);
+  };
+  const scheduleView = () => {
+    const records = new Map(
+      context.activations.filter((item) => item.kind === "scheduled").map((item) => [item.id, item])
+    );
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const desired of desiredSchedules) {
+      if (records.has(desired.id) || !desired.enabled) continue;
+      records.set(desired.id, {
+        id: desired.id,
+        kind: "scheduled",
+        definitionId: context.definitionId,
+        agentId: context.agentId,
+        conversationId: context.conversationId,
+        workspaceId: context.workspaceId,
+        message: desired.message,
+        ...desired.payload !== void 0 ? { payload: desired.payload } : {},
+        timing: desired.timing,
+        origin: "agent-definition",
+        scheduleName: desired.name,
+        definitionRevision: desired.revision,
+        status: "pending",
+        createdByRunId: context.runId,
+        createdAt: now,
+        updatedAt: now
+      });
+    }
+    for (const command of context.controls.commands) {
+      if (command.type === "schedule" && command.agentId === context.agentId) {
+        const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+        records.set(command.id, {
+          id: command.id,
+          kind: "scheduled",
+          definitionId: command.definitionId,
+          agentId: context.agentId,
+          conversationId: command.conversationId ?? context.conversationId,
+          workspaceId: command.workspaceId,
+          message: command.message,
+          ...command.payload !== void 0 ? { payload: command.payload } : {},
+          timing: command.timing,
+          origin: "agent-tool",
+          status: "pending",
+          createdByRunId: context.runId,
+          createdAt,
+          updatedAt: createdAt
+        });
+      } else if (command.type === "schedule.update") {
+        const current = records.get(command.activationId);
+        if (current) records.set(command.activationId, {
+          ...current,
+          ...command.patch,
+          status: "pending",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } else if (command.type === "schedule.cancel") {
+        const current = records.get(command.activationId);
+        if (current) records.set(command.activationId, {
+          ...current,
+          status: "cancelled",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }
+    return [...records.values()];
+  };
+  return [
+    {
+      name: "glove_foundry_spawn",
+      description: "Immediately invoke an agent. Use glove_foundry_schedule for future or recurring work.",
+      inputSchema: z.object({
+        definitionId: z.string().optional(),
+        agentId: z.string().optional(),
+        conversationId: z.string().optional(),
+        message: z.string(),
+        payload: z.unknown().optional()
+      }),
+      async do(input) {
+        return emit({
+          id: commandId(),
+          type: "spawn",
+          definitionId: input.definitionId ?? context.definitionId,
+          ...input.agentId ? { agentId: input.agentId } : {},
+          ...input.conversationId ? { conversationId: input.conversationId } : {},
+          workspaceId: context.workspaceId,
+          message: input.message,
+          ...input.payload !== void 0 ? { payload: input.payload } : {}
+        });
+      }
+    },
+    {
+      name: "glove_foundry_schedule",
+      description: "Create an ad hoc future or recurring activation. Agent-definition schedules are loaded separately through the lazy schedules resolver.",
+      inputSchema: z.object({
+        definitionId: z.string().optional(),
+        agentId: z.string().optional(),
+        conversationId: z.string().optional(),
+        message: z.string(),
+        payload: z.unknown().optional(),
+        timing: timingInputSchema
+      }),
+      async do(input) {
+        return emit({
+          id: commandId(),
+          type: "schedule",
+          definitionId: input.definitionId ?? context.definitionId,
+          ...input.agentId ?? (!input.definitionId ? context.agentId : void 0) ? { agentId: input.agentId ?? context.agentId } : {},
+          ...input.conversationId ?? (!input.definitionId && !input.agentId ? context.conversationId : void 0) ? { conversationId: input.conversationId ?? context.conversationId } : {},
+          workspaceId: context.workspaceId,
+          message: input.message,
+          ...input.payload !== void 0 ? { payload: input.payload } : {},
+          timing: normalizeScheduleTiming(input.timing)
+        });
+      }
+    },
+    {
+      name: "glove_foundry_schedules",
+      description: "List, update, or cancel scheduled triggers owned by this agent instance. Use the activation id returned by list.",
+      inputSchema: z.discriminatedUnion("action", [
+        z.object({
+          action: z.literal("list"),
+          status: z.enum(["active", "completed", "cancelled", "all"]).default("active")
+        }),
+        z.object({
+          action: z.literal("update"),
+          activationId: z.string().min(1),
+          message: z.string().min(1).optional(),
+          payload: z.unknown().optional(),
+          timing: timingInputSchema.optional()
+        }),
+        z.object({ action: z.literal("cancel"), activationId: z.string().min(1) })
+      ]),
+      async do(input) {
+        if (input.action === "list") {
+          const scheduled = scheduleView();
+          const filter = input.status ?? "active";
+          const filtered = filter === "all" ? scheduled : filter === "active" ? scheduled.filter((item) => item.status === "pending" || item.status === "active") : scheduled.filter((item) => item.status === filter);
+          return { status: "success", data: filtered };
+        }
+        if (!scheduleView().some((item) => item.id === input.activationId && item.agentId === context.agentId && item.kind === "scheduled")) {
+          return { status: "error", data: null, message: `Schedule "${input.activationId}" is not owned by this agent instance.` };
+        }
+        if (input.action === "cancel") {
+          return emit({
+            id: commandId(),
+            type: "schedule.cancel",
+            activationId: input.activationId,
+            definitionId: context.definitionId,
+            agentId: context.agentId,
+            conversationId: context.conversationId,
+            workspaceId: context.workspaceId
+          });
+        }
+        const patch = {};
+        if (input.message !== void 0) patch.message = input.message;
+        if (input.payload !== void 0) patch.payload = input.payload;
+        if (input.timing !== void 0) patch.timing = normalizeScheduleTiming(input.timing);
+        if (Object.keys(patch).length === 0) {
+          return { status: "error", data: null, message: "Provide message, payload, or timing to update." };
+        }
+        return emit({
+          id: commandId(),
+          type: "schedule.update",
+          activationId: input.activationId,
+          patch,
+          definitionId: context.definitionId,
+          agentId: context.agentId,
+          conversationId: context.conversationId,
+          workspaceId: context.workspaceId
+        });
+      }
+    },
+    {
+      name: "glove_foundry_sleep",
+      description: "Suspend this logical run, then wake the same agent instance and conversation at a date or after a duration.",
+      inputSchema: z.discriminatedUnion("kind", [
+        z.object({
+          kind: z.literal("until"),
+          at: z.string().datetime(),
+          message: z.string().default("Continue the suspended work.")
+        }),
+        z.object({
+          kind: z.literal("for"),
+          duration: durationSchema("How long this agent should sleep"),
+          message: z.string().default("Continue the suspended work.")
+        })
+      ]),
+      async do(input) {
+        return emit({
+          id: commandId(),
+          type: "sleep",
+          definitionId: context.definitionId,
+          agentId: context.agentId,
+          conversationId: context.conversationId,
+          workspaceId: context.workspaceId,
+          wakeAt: input.kind === "until" ? input.at : afterDuration(input.duration),
+          message: input.message
+        });
+      }
+    },
+    {
+      name: "glove_foundry_background",
+      description: "Start work in the background and optionally reconvene its result into this conversation's shared inbox.",
+      inputSchema: z.object({
+        definitionId: z.string().optional(),
+        message: z.string(),
+        payload: z.unknown().optional(),
+        reconvene: z.boolean().default(true)
+      }),
+      async do(input) {
+        return emit({
+          id: commandId(),
+          type: "background",
+          definitionId: input.definitionId ?? context.definitionId,
+          agentId: context.agentId,
+          conversationId: context.conversationId,
+          workspaceId: context.workspaceId,
+          message: input.message,
+          ...input.payload !== void 0 ? { payload: input.payload } : {},
+          reconvene: input.reconvene
+        });
+      }
+    },
+    {
+      name: "glove_foundry_transmit",
+      description: "Deliver an outbound event through a route declared by this instance's playbook and authorized for this run.",
+      inputSchema: z.object({
+        routeId: z.string(),
+        payload: z.unknown()
+      }),
+      async do(input) {
+        return emit({
+          id: commandId(),
+          type: "transmit",
+          definitionId: context.definitionId,
+          agentId: context.agentId,
+          conversationId: context.conversationId,
+          workspaceId: context.workspaceId,
+          routeId: input.routeId,
+          payload: input.payload
+        });
+      }
+    },
+    {
+      name: "glove_foundry_conversations",
+      description: "List the conversations owned by this runtime agent instance.",
+      inputSchema: z.object({}),
+      async do() {
+        return { status: "success", data: await Effect5.runPromise(context.data.listConversations(context.agentId)) };
+      }
+    },
+    {
+      name: "glove_foundry_workspace",
+      description: "Read or write a value in the agent's shared workspace.",
+      inputSchema: z.discriminatedUnion("action", [
+        z.object({ action: z.literal("get"), key: z.string() }),
+        z.object({ action: z.literal("set"), key: z.string(), value: z.unknown() }),
+        z.object({ action: z.literal("list") })
+      ]),
+      async do(input) {
+        if (input.action === "get") {
+          return { status: "success", data: await Effect5.runPromise(context.data.getWorkspaceEntry(context.workspaceId, input.key)) };
+        }
+        if (input.action === "list") {
+          return { status: "success", data: await Effect5.runPromise(context.data.listWorkspaceEntries(context.workspaceId)) };
+        }
+        await Effect5.runPromise(context.data.putWorkspaceEntry({
+          workspaceId: context.workspaceId,
+          key: input.key,
+          value: input.value,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        return { status: "success", data: { key: input.key, saved: true } };
+      }
+    },
+    {
+      name: "glove_foundry_shared_inbox",
+      description: "List shared workspace inbox items or post a new item for another agent/conversation.",
+      inputSchema: z.discriminatedUnion("action", [
+        z.object({ action: z.literal("list") }),
+        z.object({
+          action: z.literal("post"),
+          topic: z.string(),
+          payload: z.unknown(),
+          agentId: z.string().optional(),
+          conversationId: z.string().optional()
+        }),
+        z.object({
+          action: z.literal("update"),
+          itemId: z.string(),
+          status: z.enum(["pending", "resolved", "dismissed"])
+        })
+      ]),
+      async do(input) {
+        if (input.action === "list") {
+          return { status: "success", data: await Effect5.runPromise(context.data.listInboxItems(context.workspaceId)) };
+        }
+        if (input.action === "update") {
+          const current = (await Effect5.runPromise(context.data.listInboxItems(context.workspaceId))).find((item3) => item3.id === input.itemId);
+          if (!current) return { status: "error", data: null, error: `Shared inbox item "${input.itemId}" was not found.` };
+          const item2 = { ...current, status: input.status, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+          await Effect5.runPromise(context.data.putInboxItem(item2));
+          return { status: "success", data: item2 };
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const item = {
+          id: id("inbox"),
+          workspaceId: context.workspaceId,
+          agentId: input.agentId ?? context.agentId,
+          conversationId: input.conversationId ?? context.conversationId,
+          topic: input.topic,
+          payload: input.payload,
+          status: "pending",
+          createdAt: now,
+          updatedAt: now
+        };
+        await Effect5.runPromise(context.data.putInboxItem(item));
+        return { status: "success", data: item };
+      }
+    },
+    {
+      name: "glove_foundry_tasks",
+      description: "List shared workspace tasks or create a task scoped to this agent conversation.",
+      inputSchema: z.discriminatedUnion("action", [
+        z.object({ action: z.literal("list") }),
+        z.object({ action: z.literal("create"), title: z.string(), detail: z.string().optional() }),
+        z.object({
+          action: z.literal("update"),
+          taskId: z.string(),
+          status: z.enum(["open", "in-progress", "completed", "cancelled"])
+        })
+      ]),
+      async do(input) {
+        if (input.action === "list") {
+          return { status: "success", data: await Effect5.runPromise(context.data.listTasks(context.workspaceId)) };
+        }
+        if (input.action === "update") {
+          const current = (await Effect5.runPromise(context.data.listTasks(context.workspaceId))).find((task3) => task3.id === input.taskId);
+          if (!current) return { status: "error", data: null, error: `Task "${input.taskId}" was not found.` };
+          const task2 = { ...current, status: input.status, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+          await Effect5.runPromise(context.data.putTask(task2));
+          return { status: "success", data: task2 };
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const task = {
+          id: id("task"),
+          workspaceId: context.workspaceId,
+          agentId: context.agentId,
+          conversationId: context.conversationId,
+          title: input.title,
+          ...input.detail ? { detail: input.detail } : {},
+          status: "open",
+          createdAt: now,
+          updatedAt: now
+        };
+        await Effect5.runPromise(context.data.putTask(task));
+        return { status: "success", data: task };
+      }
+    },
+    {
+      name: "glove_foundry_environment",
+      description: "List non-secret environment metadata visible to this workspace, agent, and conversation.",
+      inputSchema: z.object({}),
+      async do() {
+        return {
+          status: "success",
+          data: await Effect5.runPromise(context.data.listEnvironment({
+            workspaceId: context.workspaceId,
+            agentId: context.agentId,
+            conversationId: context.conversationId
+          }))
+        };
+      }
+    }
+  ];
+}
+
+// src/workbench.ts
+import { Effect as Effect6 } from "effect";
+import {
+  JsSession,
+  mountJs
+} from "glove-js";
+import {
+  LispSession,
+  mountLisp
+} from "glove-lisp";
+import {
+  PySession,
+  mountPy
+} from "glove-python";
+import {
+  createWorkingEnvironment,
+  fromSnapshot,
+  mountWorkingEnvironment
+} from "glove-working-environment";
+var FOUNDRY_WORKING_ENVIRONMENT_BRAND = /* @__PURE__ */ Symbol.for(
+  "glove-foundry-working-environment"
+);
+var FOUNDRY_REPL_BRAND = /* @__PURE__ */ Symbol.for("glove-foundry-repl");
+function defineWorkingEnvironment(options = {}) {
+  if (options.create && options.options) {
+    throw new Error(
+      "defineWorkingEnvironment accepts either create or options, not both."
+    );
+  }
+  return Object.freeze({
+    ...options,
+    [FOUNDRY_WORKING_ENVIRONMENT_BRAND]: true
+  });
+}
+function assertSnapshot(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("Stored working-environment snapshot must be an object.");
+  }
+  const snapshot = value;
+  if (snapshot.version !== 1 || !Array.isArray(snapshot.dirs) || !snapshot.dirs.every((path) => typeof path === "string") || !Array.isArray(snapshot.files) || !snapshot.files.every(
+    (file) => Boolean(
+      file && typeof file === "object" && typeof file.path === "string" && typeof file.data === "string" && typeof file.mtime === "number"
+    )
+  )) {
+    throw new Error("Stored working-environment snapshot is invalid or unsupported.");
+  }
+  return structuredClone(snapshot);
+}
+function environmentSnapshotOwner(scope, context) {
+  return {
+    scope,
+    definitionId: context.definitionId,
+    agentId: context.agentId,
+    conversationId: context.conversationId,
+    workspaceId: context.workspaceId
+  };
+}
+function foundryDataEnvironmentPersistence(options = {}) {
+  const scope = options.scope ?? "agent";
+  const adapter = {
+    identifier: `foundry-data:${scope}`,
+    load(context) {
+      return Effect6.map(
+        context.data.getWorkingEnvironmentSnapshot(
+          environmentSnapshotOwner(scope, context)
+        ),
+        (snapshot) => snapshot ? assertSnapshot(snapshot) : null
+      );
+    },
+    save(snapshot, context) {
+      return context.data.putWorkingEnvironmentSnapshot(
+        environmentSnapshotOwner(scope, context),
+        structuredClone(snapshot)
+      );
+    }
+  };
+  return Object.freeze(adapter);
+}
+function defineRepl(options) {
+  const valid = options.language === "javascript" && options.session instanceof JsSession || options.language === "python" && options.session instanceof PySession || options.language === "lisp" && options.session instanceof LispSession;
+  if (!valid) {
+    throw new Error(
+      `Foundry ${options.language} REPL requires the matching native Glove session.`
+    );
+  }
+  return Object.freeze({
+    ...options,
+    [FOUNDRY_REPL_BRAND]: true
+  });
+}
+function persistenceContext(context) {
+  return {
+    definitionId: context.definitionId,
+    agentId: context.agentId,
+    conversationId: context.conversationId,
+    workspaceId: context.workspaceId,
+    runId: context.runId,
+    data: context.data,
+    signal: context.controls.signal
+  };
+}
+async function createEnvironment(definition, context) {
+  if (definition[FOUNDRY_WORKING_ENVIRONMENT_BRAND] !== true) {
+    throw new Error(
+      "Agent workingEnvironment must be created with defineWorkingEnvironment(...)."
+    );
+  }
+  const persistence = persistenceContext(context);
+  const snapshot = definition.persistence ? await resolveResolvable(definition.persistence.load(persistence)) : null;
+  const createContext = {
+    assembly: context,
+    snapshot
+  };
+  if (definition.create) {
+    return {
+      environment: await resolveResolvable(definition.create(createContext)),
+      persistence
+    };
+  }
+  const resolvedOptions = typeof definition.options === "function" ? await resolveResolvable(definition.options(createContext)) : definition.options ?? {};
+  return {
+    environment: await createWorkingEnvironment({
+      ...resolvedOptions,
+      ...snapshot && resolvedOptions.filesystem === void 0 ? { filesystem: fromSnapshot(snapshot) } : {}
+    }),
+    persistence
+  };
+}
+async function mountFoundryWorkbench(options) {
+  let environment;
+  let persistence;
+  let mountedRepl;
+  const dispose = async () => {
+    if (!environment || !options.workingEnvironment) return;
+    const failures = [];
+    if (options.workingEnvironment.persistence && persistence) {
+      try {
+        const snapshot = await environment.snapshot();
+        await resolveResolvable(
+          options.workingEnvironment.persistence.save(snapshot, persistence)
+        );
+        options.context.controls.emit({
+          type: "foundry.working-environment.snapshot.saved",
+          data: {
+            persistence: options.workingEnvironment.persistence.identifier,
+            files: snapshot.files.length
+          }
+        });
+      } catch (cause) {
+        failures.push(cause);
+      }
+    }
+    if (options.workingEnvironment.close !== false) {
+      try {
+        await environment.close();
+      } catch (cause) {
+        failures.push(cause);
+      }
+    }
+    if (failures.length > 0) {
+      throw new AggregateError(
+        failures,
+        "Foundry working-environment cleanup failed."
+      );
+    }
+  };
+  try {
+    if (options.workingEnvironment) {
+      const created = await createEnvironment(
+        options.workingEnvironment,
+        options.context
+      );
+      environment = created.environment;
+      persistence = created.persistence;
+      mountWorkingEnvironment(options.glove, {
+        env: environment,
+        ...options.workingEnvironment.mount ?? {}
+      });
+      options.context.controls.emit({
+        type: "foundry.working-environment.mounted",
+        data: {
+          tools: environment.tools.map((tool) => tool.name),
+          modules: [...environment.moduleDescriptions.keys()],
+          warnings: environment.warnings,
+          persistence: options.workingEnvironment.persistence?.identifier ?? null
+        }
+      });
+    }
+    if (options.repl) {
+      if (options.repl[FOUNDRY_REPL_BRAND] !== true) {
+        throw new Error("Agent repl must be created with defineRepl(...).");
+      }
+      switch (options.repl.language) {
+        case "javascript":
+          mountJs(options.glove, {
+            session: options.repl.session,
+            ...options.repl.mount ?? {}
+          });
+          mountedRepl = Object.freeze({
+            language: "javascript",
+            session: options.repl.session
+          });
+          break;
+        case "python":
+          mountPy(options.glove, {
+            session: options.repl.session,
+            ...options.repl.mount ?? {}
+          });
+          mountedRepl = Object.freeze({
+            language: "python",
+            session: options.repl.session
+          });
+          break;
+        case "lisp":
+          mountLisp(options.glove, {
+            session: options.repl.session,
+            ...options.repl.mount ?? {}
+          });
+          mountedRepl = Object.freeze({
+            language: "lisp",
+            session: options.repl.session
+          });
+          break;
+      }
+      options.context.controls.emit({
+        type: "foundry.repl.mounted",
+        data: {
+          language: options.repl.language,
+          frame: options.repl.mount?.frame ?? "repl"
+        }
+      });
+    }
+    return {
+      ...environment ? { workingEnvironment: environment, vfs: environment.fs } : {},
+      ...mountedRepl ? { repl: mountedRepl } : {},
+      dispose
+    };
+  } catch (cause) {
+    try {
+      await dispose();
+    } catch (cleanupCause) {
+      throw new AggregateError(
+        [cause, cleanupCause],
+        "Foundry workbench mounting and cleanup failed."
+      );
+    }
+    throw cause;
+  }
+}
+
+// src/agent-runtime.ts
+import { pathToFileURL } from "node:url";
+import { Displaymanager as Displaymanager2, Glove as Glove2 } from "glove-core";
+import { mountMesh } from "glove-mesh";
+import { Effect as Effect7 } from "effect";
+import { signal } from "station-signal";
+import { z as z2 } from "zod";
+var INBOX_ITEMS_SCHEMA = z2.array(z2.object({
+  id: z2.string().min(1),
+  tag: z2.string(),
+  request: z2.string(),
+  response: z2.string().nullable(),
+  status: z2.enum(["pending", "resolved", "consumed"]),
+  blocking: z2.boolean(),
+  created_at: z2.string(),
+  resolved_at: z2.string().nullable()
+}));
+async function hydrateInbox(store, items, emit) {
+  if (!isInboxCapableStore(store)) {
+    throw new Error("Agent inbox loading requires an inbox-capable Glove StoreAdapter.");
+  }
+  const loaded = INBOX_ITEMS_SCHEMA.parse(items);
+  const existing = new Map((await store.getInboxItems()).map((item) => [item.id, item]));
+  let added = 0;
+  let updated = 0;
+  for (const item of loaded) {
+    const current = existing.get(item.id);
+    if (!current) {
+      await store.addInboxItem({ ...item });
+      added++;
+      continue;
+    }
+    if (current.status !== item.status || current.response !== item.response || current.resolved_at !== item.resolved_at) {
+      await store.updateInboxItem(item.id, {
+        status: item.status,
+        response: item.response,
+        resolved_at: item.resolved_at
+      });
+      updated++;
+    }
+  }
+  emit({
+    type: "foundry.definition.inboxes.loaded",
+    data: { count: loaded.length, added, updated }
+  });
+}
+function extractOutput(result) {
+  if (result == null || typeof result !== "object") return result;
+  const object = result;
+  if (Array.isArray(object.messages)) {
+    const last = object.messages.at(-1);
+    return last?.text ?? "";
+  }
+  return "text" in object ? object.text : result;
+}
+function serializable(value) {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return String(value);
+  }
+}
+function writeAgentEvent(type, data) {
+  const line = `${FOUNDRY_EVENT_PREFIX}${JSON.stringify({
+    type,
+    data: serializable(data),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  })}
+`;
+  return new Promise((resolveWrite, rejectWrite) => {
+    process.stdout.write(line, (error) => {
+      if (error) rejectWrite(error);
+      else resolveWrite();
+    });
+  });
+}
+function executionSubscriber() {
+  return {
+    async record(eventType, data) {
+      await writeAgentEvent(eventType, data);
+    }
+  };
+}
+async function resolveAgentValue(definition, value, context, field) {
+  context.controls.emit({
+    type: "foundry.assembly.resolve.start",
+    data: { field }
+  });
+  const resolved = await resolveResolvable(
+    typeof value === "function" ? value(definition, context) : value
+  );
+  context.controls.emit({
+    type: "foundry.assembly.resolve.complete",
+    data: {
+      field,
+      count: Array.isArray(resolved) ? resolved.length : void 0
+    }
+  });
+  return resolved;
+}
+var HANDLER_ONLY_MODEL = {
+  name: "foundry-handler",
+  setSystemPrompt: () => void 0,
+  prompt: async () => {
+    throw new Error(
+      "This is a model-free Foundry agent. Define run/spawn or configure a model."
+    );
+  }
+};
+async function loadRuntimeApplication() {
+  const path = process.env[FOUNDRY_APPLICATION_ENV];
+  if (!path) return EMPTY_FOUNDRY_APPLICATION;
+  const imported = await import(pathToFileURL(path).href);
+  if (!isFoundryApplication(imported.default)) {
+    throw new Error(
+      `${path} must default-export defineApplication(...) for installation resolution.`
+    );
+  }
+  return imported.default;
+}
+async function executeSpawned(spawned, message, signal2) {
+  if (spawned && typeof spawned === "object" && "processRequest" in spawned && typeof spawned.processRequest === "function") {
+    return extractOutput(
+      await spawned.processRequest(toGloveRequestInput(message), signal2)
+    );
+  }
+  if (spawned && typeof spawned === "object" && "run" in spawned && typeof spawned.run === "function") {
+    return spawned.run(
+      message,
+      signal2
+    );
+  }
+  return spawned;
+}
+async function runDefinition(definition, id2, runtimeValue) {
+  const envelope = runtimeValue;
+  const request = envelope.request;
+  const input = request;
+  const runId = process.env.STATION_SIGNAL_RUN_ID ?? "unknown";
+  const subscriber = executionSubscriber();
+  const abortController = new AbortController();
+  const onTerminate = () => abortController.abort();
+  process.once("SIGTERM", onTerminate);
+  let disposeSurfaces;
+  const cleanups = [];
+  const application = await loadRuntimeApplication();
+  const storeFactory = definition.store ?? application.conversationStore;
+  const store = storeFactory ? await storeFactory({
+    definitionId: id2,
+    agentId: request.agentId,
+    conversationId: request.conversationId,
+    workspaceId: request.workspaceId
+  }) : null;
+  const history = Object.freeze(
+    (store ? await store.getMessages() : []).map(freezeGloveMessage)
+  );
+  const message = toGloveMessage(request.message);
+  const messages = Object.freeze([...history, message]);
+  const controls = {
+    signal: abortController.signal,
+    commands: [],
+    emit: (event) => {
+      void writeAgentEvent(event.type, event.data).catch((cause) => {
+        process.stderr.write(
+          `Foundry failed to forward agent event: ${cause instanceof Error ? cause.message : String(cause)}
+`
+        );
+      });
+    }
+  };
+  try {
+    const registry = definition.components ?? {
+      capabilities: EMPTY_CAPABILITY_REGISTRY,
+      native: { layers: Object.freeze([]), subscribers: Object.freeze([]) }
+    };
+    const installations = envelope.agent.installations;
+    const data = application.data ?? new MemoryFoundryDataAdapter();
+    const initialAssemblyContext = {
+      definitionId: id2,
+      agentId: request.agentId,
+      conversationId: request.conversationId,
+      workspaceId: request.workspaceId,
+      name: internalAgentName(id2),
+      runId,
+      mode: "agent",
+      request,
+      agentInstance: envelope.agent,
+      conversation: envelope.conversation,
+      activations: Object.freeze([...envelope.activations ?? []]),
+      data,
+      input,
+      message,
+      messageInput: request.message,
+      messageText: message.text,
+      history,
+      messages,
+      installations,
+      store,
+      subscriber,
+      controls
+    };
+    const assemblyContext = initialAssemblyContext;
+    const resolveOptional = async (field, value, fallback) => value === void 0 ? fallback : resolveAgentValue(
+      definition,
+      value,
+      assemblyContext,
+      field
+    );
+    const [model, systemPrompt, displayManager, compactionLimit, compactionInstructions, maxTurns] = await Promise.all([
+      resolveOptional("model", definition.model, HANDLER_ONLY_MODEL),
+      resolveOptional("systemPrompt", definition.systemPrompt, ""),
+      resolveOptional("displayManager", definition.displayManager, new Displaymanager2()),
+      resolveOptional("compactionLimit", definition.compactionLimit, void 0),
+      resolveOptional("compactionInstructions", definition.compactionInstructions, "Preserve goals, decisions, unresolved work, tool results, and pending inbox items."),
+      resolveOptional("maxTurns", definition.maxTurns, void 0)
+    ]);
+    const base = new Glove2({
+      ...store ? { store } : {},
+      model,
+      displayManager,
+      systemPrompt,
+      serverMode: definition.serverMode ?? true,
+      ...definition.maxRetries !== void 0 ? { maxRetries: definition.maxRetries } : {},
+      ...definition.maxConsecutiveErrors !== void 0 ? { maxConsecutiveErrors: definition.maxConsecutiveErrors } : {},
+      compaction_config: {
+        compaction_instructions: compactionInstructions,
+        ...maxTurns !== void 0 ? { max_turns: maxTurns } : {},
+        ...compactionLimit !== void 0 ? { compaction_context_limit: compactionLimit } : {}
+      },
+      ...definition.enableToolResultSummary !== void 0 ? { enableToolResultSummary: definition.enableToolResultSummary } : {}
+    }).build();
+    base.addSubscriber(subscriber);
+    const [tools, hooks, skills, subagents, memory, inboxItems, layers, subscribers, calls, playbooks, schedules, mesh, workingEnvironment, repl] = await Promise.all([
+      resolveOptional("tools", definition.tools, []),
+      resolveOptional("hooks", definition.hooks, []),
+      resolveOptional("skills", definition.skills, []),
+      resolveOptional("subagents", definition.subagents, []),
+      resolveOptional("memory", definition.memory, []),
+      definition.inboxes ? resolveAgentValue(
+        definition,
+        definition.inboxes,
+        assemblyContext,
+        "inboxes"
+      ) : Promise.resolve([]),
+      resolveOptional("layers", definition.layers, []),
+      resolveOptional("subscribers", definition.subscribers, []),
+      resolveOptional("calls", definition.calls, []),
+      resolveOptional("playbooks", definition.playbooks, []),
+      resolveOptional("schedules", definition.schedules, []),
+      resolveOptional("mesh", definition.mesh, void 0),
+      resolveOptional("workingEnvironment", definition.workingEnvironment, void 0),
+      resolveOptional("repl", definition.repl, void 0)
+    ]);
+    const playbookNames = /* @__PURE__ */ new Set();
+    const desiredPlaybooks = definition.playbooks === void 0 ? envelope.agent.playbooks : playbooks.map((playbook) => {
+      if (playbook[FOUNDRY_COMPOSED_PLAYBOOK_BRAND] !== true) {
+        throw new Error("Agent playbooks must be created at runtime with composePlaybook(...).");
+      }
+      if (playbookNames.has(playbook.name)) {
+        throw new Error(`Duplicate composed playbook name "${playbook.name}".`);
+      }
+      playbookNames.add(playbook.name);
+      const revision = composedPlaybookRevision(playbook);
+      return materializeComposedPlaybook(
+        playbook,
+        agentPlaybookId(id2, request.agentId, playbook.name),
+        revision
+      );
+    });
+    if (definition.playbooks !== void 0) {
+      const playbookSync = {
+        id: `playbook_sync_${runId}`,
+        type: "playbook.sync",
+        definitionId: id2,
+        agentId: request.agentId,
+        conversationId: request.conversationId,
+        workspaceId: request.workspaceId,
+        playbooks: desiredPlaybooks
+      };
+      controls.commands.push(playbookSync);
+      controls.emit({ type: FOUNDRY_CORE_COMMAND_EVENT, data: playbookSync });
+      controls.emit({
+        type: "foundry.definition.playbooks.composed",
+        data: { count: desiredPlaybooks.length, names: desiredPlaybooks.map((item) => item.playbookName) }
+      });
+    }
+    const scheduleNames = /* @__PURE__ */ new Set();
+    const desiredSchedules = schedules.map((schedule) => {
+      if (!isFoundrySchedule(schedule)) {
+        throw new Error("Agent schedules must be created with defineSchedule(...).");
+      }
+      if (scheduleNames.has(schedule.name)) {
+        throw new Error(`Duplicate agent schedule name "${schedule.name}".`);
+      }
+      scheduleNames.add(schedule.name);
+      return {
+        id: agentScheduleActivationId(id2, request.agentId, schedule.name),
+        name: schedule.name,
+        revision: agentScheduleRevision(schedule),
+        message: schedule.message,
+        ...schedule.payload !== void 0 ? { payload: schedule.payload } : {},
+        timing: normalizeScheduleTiming(schedule.timing),
+        enabled: schedule.enabled !== false
+      };
+    });
+    const scheduleSync = {
+      id: `schedule_sync_${runId}`,
+      type: "schedule.sync",
+      definitionId: id2,
+      agentId: request.agentId,
+      conversationId: request.conversationId,
+      workspaceId: request.workspaceId,
+      schedules: desiredSchedules
+    };
+    controls.commands.push(scheduleSync);
+    controls.emit({ type: FOUNDRY_CORE_COMMAND_EVENT, data: scheduleSync });
+    controls.emit({
+      type: "foundry.definition.schedules.loaded",
+      data: { count: desiredSchedules.length, names: desiredSchedules.map((item) => item.name) }
+    });
+    const effectiveInstallations = [...installations];
+    for (const tool of createFoundryCoreTools(assemblyContext, desiredSchedules)) base.fold(tool);
+    const applicationTransmissionTools = createInstalledApplicationTransmissionTools(
+      assemblyContext,
+      registry.capabilities.applications,
+      effectiveInstallations,
+      desiredPlaybooks
+    );
+    for (const tool of applicationTransmissionTools) base.fold(tool);
+    if (applicationTransmissionTools.length > 0) {
+      controls.emit({
+        type: "foundry.application.transmission-tools.mounted",
+        data: {
+          tools: applicationTransmissionTools.map((tool) => tool.name)
+        }
+      });
+    }
+    for (const tool of tools) base.fold(tool);
+    for (const hook of hooks) base.defineHook(hook.name, hook.handler);
+    for (const skill of skills) base.defineSkill(skill);
+    for (const subagent of subagents) base.defineSubAgent(subagent);
+    const workbench = await mountFoundryWorkbench({
+      glove: base,
+      context: assemblyContext,
+      ...workingEnvironment ? { workingEnvironment } : {},
+      ...repl ? { repl } : {}
+    });
+    cleanups.push(workbench.dispose);
+    const callByName = /* @__PURE__ */ new Map();
+    const invoke = async (name, callInput) => {
+      const call = callByName.get(name);
+      if (!call) throw new Error(`Foundry call "${name}" is not available.`);
+      const parsed = call.input.parse(callInput);
+      const value = await resolveResolvable(call.handler(parsed, callContext));
+      return call.output.parse(value);
+    };
+    const surfaceContext = {
+      definitionId: id2,
+      agentId: request.agentId,
+      conversationId: request.conversationId,
+      workspaceId: request.workspaceId,
+      runId,
+      input,
+      request,
+      message,
+      messageInput: request.message,
+      messageText: message.text,
+      history,
+      messages,
+      glove: base,
+      ...workbench.workingEnvironment ? { workingEnvironment: workbench.workingEnvironment, vfs: workbench.vfs } : {},
+      ...workbench.repl ? { repl: workbench.repl } : {},
+      signal: abortController.signal,
+      emit: controls.emit
+    };
+    const callContext = {
+      ...surfaceContext,
+      installations: effectiveInstallations,
+      invoke
+    };
+    for (const call of calls) {
+      if (callByName.has(call.name)) throw new Error(`Duplicate Foundry call "${call.name}".`);
+      callByName.set(call.name, call);
+      if (call.exposeToAgent ?? true) {
+        base.fold({
+          name: call.name,
+          description: call.description,
+          inputSchema: call.input,
+          async do(callInput) {
+            try {
+              return { status: "success", data: await invoke(call.name, callInput) };
+            } catch (cause) {
+              return {
+                status: "error",
+                data: null,
+                message: cause instanceof Error ? cause.message : String(cause)
+              };
+            }
+          }
+        });
+      }
+    }
+    disposeSurfaces = await mountFoundrySurfaces({
+      registry: registry.native,
+      layers,
+      subscribers,
+      context: surfaceContext
+    });
+    await Effect7.runPromise(
+      installRegistry({
+        registry: registry.capabilities,
+        installations: effectiveInstallations,
+        context: {
+          definitionId: id2,
+          agentId: request.agentId,
+          conversationId: request.conversationId,
+          workspaceId: request.workspaceId,
+          runId,
+          input,
+          request,
+          message,
+          messageInput: request.message,
+          messageText: message.text,
+          history,
+          messages,
+          glove: base,
+          store: base.store,
+          emit: controls.emit
+        },
+        ...definition.mcpAdapter ? { mcpAdapter: definition.mcpAdapter } : {},
+        ...definition.accountSessions ? { accountSessions: definition.accountSessions } : {}
+      })
+    );
+    await Effect7.runPromise(
+      mountAgentDefinitionMemory({
+        registry: registry.capabilities,
+        memory,
+        context: {
+          definitionId: id2,
+          agentId: request.agentId,
+          conversationId: request.conversationId,
+          workspaceId: request.workspaceId,
+          runId,
+          input,
+          request,
+          message,
+          messageInput: request.message,
+          messageText: message.text,
+          history,
+          messages,
+          glove: base,
+          store: base.store,
+          emit: controls.emit
+        }
+      })
+    );
+    if (definition.inboxes) {
+      await hydrateInbox(base.store, inboxItems, controls.emit);
+    }
+    if (mesh) {
+      await mountMesh(base, {
+        adapter: mesh.adapter,
+        identity: {
+          id: mesh.identity?.id ?? request.agentId,
+          name: mesh.identity?.name ?? request.agentId,
+          description: mesh.identity?.description ?? definition.description,
+          ...mesh.identity?.capabilities ? { capabilities: mesh.identity.capabilities } : {},
+          metadata: {
+            definitionId: id2,
+            conversationId: request.conversationId,
+            workspaceId: request.workspaceId,
+            ...mesh.identity?.metadata ?? {}
+          }
+        }
+      });
+      cleanups.push(() => mesh.adapter.unregister());
+    }
+    if (definition.configure) {
+      await resolveResolvable(definition.configure(base, callContext));
+    }
+    const glove = definition.build ? await resolveResolvable(definition.build(base, assemblyContext)) ?? base : base;
+    const runtimeContext = { ...callContext, glove };
+    const defaultRun = async () => extractOutput(
+      await glove.processRequest(
+        toGloveRequestInput(assemblyContext.messageInput),
+        abortController.signal
+      )
+    );
+    const spawn = async (messageInput = assemblyContext.messageInput) => definition.spawn ? executeSpawned(
+      await resolveResolvable(definition.spawn(glove, runtimeContext, messageInput)),
+      messageInput,
+      abortController.signal
+    ) : defaultRun();
+    const handlerContext = {
+      ...runtimeContext,
+      defaultRun,
+      defaultHandler: defaultRun,
+      spawn
+    };
+    const result = definition.run ? await resolveResolvable(definition.run(glove, handlerContext)) : definition.handler ? await resolveResolvable(definition.handler(handlerContext)) : definition.spawn ? await spawn() : await defaultRun();
+    const sleep = [...controls.commands].reverse().find(
+      (command) => command.type === "sleep"
+    );
+    return {
+      status: sleep ? "suspended" : "completed",
+      value: serializable(result),
+      agentId: request.agentId,
+      conversationId: request.conversationId,
+      workspaceId: request.workspaceId,
+      ...sleep && sleep.type === "sleep" ? { suspension: { commandId: sleep.id, wakeAt: sleep.wakeAt } } : {}
+    };
+  } finally {
+    const failures = [];
+    for (const cleanup of cleanups.reverse()) {
+      try {
+        await cleanup();
+      } catch (cause) {
+        failures.push(cause);
+      }
+    }
+    try {
+      if (disposeSurfaces) await disposeSurfaces();
+    } catch (cause) {
+      failures.push(cause);
+    }
+    process.removeListener("SIGTERM", onTerminate);
+    if (failures.length > 0) throw new AggregateError(failures, "Foundry agent cleanup failed.");
+  }
+}
+function compileAgentDefinition(definition, route) {
+  const contentPartSchema = z2.object({
+    type: z2.enum(["text", "image", "video", "document"]),
+    text: z2.string().optional(),
+    source: z2.object({
+      type: z2.enum(["base64", "url"]),
+      media_type: z2.string(),
+      data: z2.string().optional(),
+      url: z2.string().optional()
+    }).optional()
+  });
+  const requestSchema = z2.object({
+    agentId: z2.string().min(1),
+    conversationId: z2.string().min(1),
+    workspaceId: z2.string().min(1),
+    message: z2.union([z2.string(), z2.array(contentPartSchema)]),
+    payload: z2.unknown().optional(),
+    context: z2.record(z2.string(), z2.unknown()).optional(),
+    source: z2.object({
+      kind: z2.enum(["direct", "transmission", "activation", "spawn", "background"]),
+      id: z2.string().optional(),
+      provider: z2.string().optional(),
+      eventId: z2.string().optional(),
+      threadKey: z2.string().optional()
+    }).optional()
+  });
+  const executionEnvelope = z2.object({
+    [FOUNDRY_EXECUTION_MARKER]: z2.literal(true),
+    request: requestSchema,
+    agent: z2.object({
+      id: z2.string(),
+      definitionId: z2.string(),
+      workspaceId: z2.string(),
+      context: z2.record(z2.string(), z2.unknown()),
+      installations: z2.array(z2.object({
+        kind: z2.enum(["tool", "application", "mcp"]),
+        id: z2.string(),
+        config: z2.unknown().optional()
+      })),
+      playbooks: z2.array(z2.object({
+        id: z2.string(),
+        transmissionId: z2.string(),
+        enabled: z2.boolean().optional(),
+        match: z2.object({
+          event: z2.string().optional(),
+          routeIds: z2.array(z2.string()).optional(),
+          predicate: z2.object({
+            name: z2.string(),
+            parameters: z2.record(z2.string(), z2.unknown()).optional()
+          }).optional()
+        }).optional(),
+        directives: z2.array(z2.object({
+          action: z2.string(),
+          instruction: z2.string(),
+          parameters: z2.record(z2.string(), z2.unknown()).optional()
+        })),
+        applications: z2.array(z2.string()).optional(),
+        outbound: z2.array(z2.object({
+          routeId: z2.string(),
+          applicationId: z2.string().optional(),
+          event: z2.string().optional(),
+          accountId: z2.string().optional(),
+          applicationAccountId: z2.string().optional(),
+          instruction: z2.string().optional()
+        })).optional(),
+        serialization: z2.record(z2.string(), z2.unknown()).optional(),
+        origin: z2.enum(["agent-definition", "instance"]).optional(),
+        playbookName: z2.string().optional(),
+        definitionRevision: z2.string().optional()
+      })),
+      createdAt: z2.string(),
+      updatedAt: z2.string()
+    }),
+    conversation: z2.object({
+      id: z2.string(),
+      agentId: z2.string(),
+      workspaceId: z2.string(),
+      title: z2.string().optional(),
+      context: z2.record(z2.string(), z2.unknown()),
+      createdAt: z2.string(),
+      updatedAt: z2.string()
+    }),
+    activations: z2.array(z2.object({
+      id: z2.string(),
+      kind: z2.enum(["scheduled", "sleep"]),
+      definitionId: z2.string(),
+      agentId: z2.string(),
+      conversationId: z2.string(),
+      workspaceId: z2.string(),
+      message: z2.string(),
+      payload: z2.unknown().optional(),
+      timing: z2.union([
+        z2.object({ kind: z2.literal("at"), at: z2.string() }),
+        z2.object({ kind: z2.literal("every"), intervalMs: z2.number() }),
+        z2.object({ kind: z2.literal("cron"), expression: z2.string(), timezone: z2.string() })
+      ]),
+      origin: z2.enum(["agent-definition", "agent-tool"]),
+      scheduleName: z2.string().optional(),
+      definitionRevision: z2.string().optional(),
+      status: z2.enum(["pending", "active", "completed", "cancelled"]),
+      createdByRunId: z2.string(),
+      lastRunId: z2.string().optional(),
+      createdAt: z2.string(),
+      updatedAt: z2.string()
+    })).default([])
+  });
+  let builder = signal(internalAgentName(route)).input(executionEnvelope).output(z2.object({
+    status: z2.enum(["completed", "suspended"]),
+    value: z2.unknown(),
+    agentId: z2.string(),
+    conversationId: z2.string(),
+    workspaceId: z2.string(),
+    suspension: z2.object({ commandId: z2.string(), wakeAt: z2.string() }).optional()
+  }));
+  const built = builder.run(
+    (value) => runDefinition(definition, route, value)
+  );
+  return built;
+}
+function compileAgentModule(route, module) {
+  return compileAgentDefinition(defineAgentFromModule(route, module), route);
+}
+
+// src/connection.ts
+var FOUNDRY_CONNECTION_BRAND = /* @__PURE__ */ Symbol.for(
+  "glove-foundry-application-connection"
+);
+var ID3 = /^[a-z][a-z0-9-]*$/;
+function defineConnection(options) {
+  if (options.id && !ID3.test(options.id)) {
+    throw new Error(`Invalid application connection id "${options.id}".`);
+  }
+  if (options.transmissions.length === 0) {
+    throw new Error(`Application connection "${options.id}" must receive at least one transmission.`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const transmission of options.transmissions) {
+    if (!transmission.inbound) {
+      throw new Error(
+        `Application connection "${options.id ?? "<file route>"}" references an outbound-only transmission.`
+      );
+    }
+    const key = fileDefinitionKey(transmission);
+    if (seen.has(key)) {
+      throw new Error(
+        `Application connection "${options.id ?? "<file route>"}" repeats a transmission.`
+      );
+    }
+    seen.add(key);
+  }
+  const { id: id2, ...definition } = options;
+  return Object.freeze(fileIdentified({
+    ...definition,
+    transmissions: Object.freeze([...options.transmissions]),
+    [FOUNDRY_CONNECTION_BRAND]: true
+  }, "connection", id2));
+}
+
+// src/integration.ts
+import { JSONSchema as JSONSchema2 } from "effect";
+var FOUNDRY_TRANSMISSION_BRAND = /* @__PURE__ */ Symbol.for(
+  "glove-foundry-transmission"
+);
+var FOUNDRY_TRANSMISSION_PREDICATE_BRAND = /* @__PURE__ */ Symbol.for(
+  "glove-foundry-transmission-predicate"
+);
+var FOUNDRY_TRANSMISSION_EVENT_BRAND = /* @__PURE__ */ Symbol.for(
+  "glove-foundry-transmission-event"
+);
+var TRANSMISSION_ID = /^[a-z][a-z0-9-]*(?:\/[a-z][a-z0-9-]*)*$/;
+var CAPABILITY_ID = /^[a-z][a-z0-9-]*(?::[a-z][a-z0-9-]*)?$/;
+var CREDENTIAL_FIELD_NAMES = /* @__PURE__ */ new Set([
+  "token",
+  "accesstoken",
+  "refreshtoken",
+  "secret",
+  "clientsecret",
+  "password",
+  "apikey",
+  "credential",
+  "credentials"
+]);
+function assertSchemaContainsNoCredentialFields(transmissionId, area, schema) {
+  const json = JSONSchema2.make(schema);
+  const visit = (value, path) => {
+    if (!value || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => visit(entry, `${path}[${index}]`));
+      return;
+    }
+    const object = value;
+    const properties = object.properties;
+    if (properties && typeof properties === "object") {
+      for (const [name, child] of Object.entries(
+        properties
+      )) {
+        const normalized = name.toLowerCase().replace(/[^a-z0-9]/g, "");
+        if (CREDENTIAL_FIELD_NAMES.has(normalized)) {
+          throw new Error(
+            `Foundry transmission "${transmissionId}" declares credential field "${path}.${name}" in ${area}. Store an opaque accessRef on the account instead.`
+          );
+        }
+        visit(child, `${path}.${name}`);
+      }
+    }
+    for (const [name, child] of Object.entries(object)) {
+      if (name !== "properties") visit(child, path);
+    }
+  };
+  visit(json, area);
+}
+function isFoundryTransmission(value) {
+  return Boolean(
+    value && typeof value === "object" && value[FOUNDRY_TRANSMISSION_BRAND] === true
+  );
+}
+function defineTransmissionPredicate(options) {
+  if (options.id && !TRANSMISSION_ID.test(options.id)) {
+    throw new Error(`Invalid transmission predicate id "${options.id}".`);
+  }
+  const { id: id2, ...definition } = options;
+  return Object.freeze(fileIdentified({
+    ...definition,
+    [FOUNDRY_TRANSMISSION_PREDICATE_BRAND]: true
+  }, "predicate", id2));
+}
+function defineTransmissionEvent(options) {
+  if (options.id && !TRANSMISSION_ID.test(options.id)) {
+    throw new Error(`Invalid transmission event id "${options.id}".`);
+  }
+  const { id: id2, ...definition } = options;
+  return Object.freeze(fileIdentified({
+    ...definition,
+    [FOUNDRY_TRANSMISSION_EVENT_BRAND]: true
+  }, "event", id2));
+}
+function transmissionPredicate(transmission, id2) {
+  return transmission.inbound?.predicates?.find((candidate) => candidate.id === id2);
+}
+function defineTransmission(options) {
+  if (options.id && !TRANSMISSION_ID.test(options.id)) {
+    throw new Error(
+      `Invalid Foundry transmission id "${options.id}". Use lowercase letters, digits, and hyphens.`
+    );
+  }
+  const label = options.id ?? "<transmission file route>";
+  const capabilities = options.capabilities ?? [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const capability of capabilities) {
+    if (!CAPABILITY_ID.test(capability.id)) {
+      throw new Error(
+        `Invalid capability id "${capability.id}" in transmission "${label}".`
+      );
+    }
+    if (seen.has(capability.id)) {
+      throw new Error(
+        `Duplicate capability "${capability.id}" in transmission "${label}".`
+      );
+    }
+    seen.add(capability.id);
+  }
+  const eventKeys = /* @__PURE__ */ new Set();
+  for (const event of options.events ?? []) {
+    const key = fileDefinitionKey(event);
+    if (eventKeys.has(key)) {
+      throw new Error(`Duplicate event in transmission "${label}".`);
+    }
+    eventKeys.add(key);
+  }
+  if (options.account) {
+    assertSchemaContainsNoCredentialFields(
+      label,
+      "account.metadata",
+      options.account.metadata
+    );
+  }
+  if (options.inbound) {
+    assertSchemaContainsNoCredentialFields(
+      label,
+      "inbound.config",
+      options.inbound.config
+    );
+    const predicateIds = /* @__PURE__ */ new Set();
+    for (const predicate of options.inbound.predicates ?? []) {
+      const key = fileDefinitionKey(predicate);
+      if (predicateIds.has(key)) {
+        throw new Error(
+          `Duplicate predicate in transmission "${label}".`
+        );
+      }
+      predicateIds.add(key);
+    }
+  }
+  if (options.outbound) {
+    assertSchemaContainsNoCredentialFields(
+      label,
+      "outbound.config",
+      options.outbound.config
+    );
+  }
+  const { id: id2, ...definition } = options;
+  return Object.freeze(fileIdentified({
+    ...definition,
+    capabilities: Object.freeze([...capabilities]),
+    events: Object.freeze([...options.events ?? []]),
+    ...options.inbound ? {
+      inbound: Object.freeze({
+        ...options.inbound,
+        predicates: Object.freeze([...options.inbound.predicates ?? []])
+      })
+    } : {},
+    [FOUNDRY_TRANSMISSION_BRAND]: true
+  }, "transmission", id2));
+}
+
+// src/discovery.ts
+import { readdir } from "node:fs/promises";
+import { dirname, extname, relative, resolve, sep } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+var AGENT_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".js", ".mjs"]);
+var LOCAL_DEFINITION_FILES = [
+  { suffix: ".action", kind: "action", brand: FOUNDRY_PLAYBOOK_ACTION_BRAND },
+  { suffix: ".app", kind: "application", brand: FOUNDRY_AGENT_APPLICATION_BRAND },
+  { suffix: ".connection", kind: "connection", brand: FOUNDRY_CONNECTION_BRAND },
+  { suffix: ".event", kind: "event", brand: FOUNDRY_TRANSMISSION_EVENT_BRAND },
+  { suffix: ".layer", kind: "layer", brand: FOUNDRY_LAYER_BRAND },
+  { suffix: ".mcp", kind: "mcp", brand: FOUNDRY_MCP_BRAND },
+  { suffix: ".memory", kind: "memory", brand: FOUNDRY_MEMORY_BRAND },
+  { suffix: ".predicate", kind: "predicate", brand: FOUNDRY_TRANSMISSION_PREDICATE_BRAND },
+  { suffix: ".subscriber", kind: "subscriber", brand: FOUNDRY_SUBSCRIBER_BRAND },
+  { suffix: ".subscription", kind: "subscription", brand: FOUNDRY_PLAYBOOK_SUBSCRIPTION_BRAND },
+  { suffix: ".tool", kind: "tool", brand: FOUNDRY_SHARED_TOOL_BRAND },
+  { suffix: ".transmission", kind: "transmission", brand: FOUNDRY_TRANSMISSION_BRAND }
+];
+function hasAgentExtension(file) {
+  if (file.endsWith(".d.ts")) return false;
+  return AGENT_EXTENSIONS.has(extname(file));
+}
+function normalizePath(path) {
+  return path.split(sep).join("/");
+}
+function localDefinitionRoute(agentDirectory, filePath, suffix) {
+  const relativePath = normalizePath(relative(agentDirectory, filePath));
+  const extension = extname(relativePath);
+  const withoutSuffix = relativePath.slice(0, -extension.length - suffix.length);
+  const segments = withoutSuffix.split("/");
+  if (["actions", "apps", "connections", "events", "layers", "mcp", "memory", "playbooks", "predicates", "subscribers", "subscriptions", "tools", "transmissions"].includes(segments[0] ?? "")) {
+    segments.shift();
+  }
+  return segments.join("/");
+}
+async function bindAgentLocalDefinitions(agentDirectory) {
+  let entries;
+  try {
+    entries = await readdir(agentDirectory, { recursive: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries.sort()) {
+    if (entry.endsWith(".d.ts")) continue;
+    const extension = extname(entry);
+    if (!AGENT_EXTENSIONS.has(extension)) continue;
+    const matched = LOCAL_DEFINITION_FILES.find(
+      ({ suffix }) => entry.slice(0, -extension.length).endsWith(suffix)
+    );
+    if (!matched) continue;
+    const filePath = resolve(agentDirectory, entry);
+    const url = pathToFileURL2(filePath);
+    const imported = await import(url.href);
+    const value = imported.default;
+    if (!value || typeof value !== "object" || value[matched.brand] !== true) {
+      throw new Error(
+        `${normalizePath(relative(agentDirectory, filePath))} must default-export its Foundry ${matched.kind} definition so the file can own its identity.`
+      );
+    }
+    const route = localDefinitionRoute(agentDirectory, filePath, matched.suffix);
+    bindFileIdentity(value, route, matched.kind);
+  }
+}
+function routeFromAgentFile(agentsDir, filePath) {
+  const rel = normalizePath(relative(agentsDir, filePath));
+  if (rel.startsWith("../") || rel === "..") return null;
+  const extension = extname(rel);
+  if (!AGENT_EXTENSIONS.has(extension)) return null;
+  const withoutExtension = rel.slice(0, -extension.length);
+  if (withoutExtension === "agent") return "default";
+  if (withoutExtension.endsWith("/agent")) {
+    return withoutExtension.slice(0, -"/agent".length);
+  }
+  if (withoutExtension.endsWith(".agent")) {
+    return withoutExtension.slice(0, -".agent".length);
+  }
+  return null;
+}
+async function findAgentFiles(agentsDir) {
+  const absolute = resolve(agentsDir);
+  let entries;
+  try {
+    entries = await readdir(absolute, { recursive: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Cannot read Foundry agents directory ${absolute}: ${message}`);
+  }
+  return entries.filter((entry) => hasAgentExtension(entry)).map((entry) => resolve(absolute, entry)).filter((file) => routeFromAgentFile(absolute, file) !== null).sort();
+}
+async function discoverAgents(options) {
+  const agentsDir = resolve(options.agentsDir);
+  const files = await findAgentFiles(agentsDir);
+  const discovered = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const filePath of files) {
+    const route = routeFromAgentFile(agentsDir, filePath);
+    if (!route) continue;
+    const url = pathToFileURL2(filePath);
+    if (options.cacheBust) url.searchParams.set("t", String(Date.now()));
+    const imported = await import(url.href);
+    if (imported.id && (options.strictFileRoutes ?? true) && imported.id !== route) {
+      throw new Error(
+        `Foundry route mismatch in ${filePath}: file resolves to "${route}" but the agent declares "${imported.id}".`
+      );
+    }
+    const definition = defineAgentFromModule(route, imported);
+    await bindAgentLocalDefinitions(
+      dirname(filePath)
+    );
+    const prior = seen.get(route);
+    if (prior) {
+      throw new Error(
+        `Duplicate Foundry agent id "${route}" in ${prior} and ${filePath}.`
+      );
+    }
+    seen.set(route, filePath);
+    discovered.push({
+      route,
+      filePath,
+      relativePath: normalizePath(relative(agentsDir, filePath)),
+      definition,
+      executionName: internalAgentName(route)
+    });
+  }
+  return discovered;
+}
+function createManifest(agents) {
+  return {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    agents: agents.map(({ route, definition, relativePath }) => ({
+      id: route,
+      description: definition.description,
+      mode: "agent",
+      file: relativePath,
+      tags: definition.tags ?? [],
+      invocationContract: "foundry/request-v1",
+      resultContract: "foundry/result-v1",
+      assembly: "foundry",
+      handler: definition.run || definition.handler || definition.spawn ? "custom" : "glove",
+      layers: (typeof definition.layers === "function" ? [] : definition.layers ?? []).map(
+        (selection) => FOUNDRY_LAYER_BRAND in selection ? selection.id : selection.layer.id
+      ),
+      subscribers: (typeof definition.subscribers === "function" ? [] : definition.subscribers ?? []).flatMap(
+        (subscriber) => "id" in subscriber ? [String(subscriber.id)] : []
+      ),
+      tools: (typeof definition.tools === "function" ? [] : definition.tools ?? []).map((tool) => tool.name),
+      hooks: (typeof definition.hooks === "function" ? [] : definition.hooks ?? []).map((hook) => hook.name),
+      skills: (typeof definition.skills === "function" ? [] : definition.skills ?? []).map((skill) => skill.name),
+      subagents: (typeof definition.subagents === "function" ? [] : definition.subagents ?? []).map(
+        (subagent) => subagent.name
+      ),
+      memory: (typeof definition.memory === "function" ? [] : definition.memory ?? []).map(
+        (selection) => {
+          const profile = "profile" in selection ? selection.profile : selection;
+          return profile.id;
+        }
+      ),
+      inboxLoader: definition.inboxes !== void 0,
+      calls: (typeof definition.calls === "function" ? [] : definition.calls ?? []).map(
+        (call) => call.name
+      ),
+      schedules: (typeof definition.schedules === "function" ? [] : definition.schedules ?? []).map(
+        (schedule) => schedule.name
+      ),
+      playbooks: (typeof definition.playbooks === "function" ? [] : definition.playbooks ?? []).map(
+        (playbook) => playbook.name
+      ),
+      mesh: definition.mesh !== void 0,
+      workingEnvironment: definition.workingEnvironment !== void 0,
+      repl: definition.repl === void 0 ? null : typeof definition.repl === "function" ? "dynamic" : definition.repl.language,
+      lazy: [
+        "model",
+        "systemPrompt",
+        "displayManager",
+        "compactionLimit",
+        "compactionInstructions",
+        "maxTurns",
+        "tools",
+        "hooks",
+        "skills",
+        "subagents",
+        "memory",
+        "inboxes",
+        "subscribers",
+        "layers",
+        "calls",
+        "schedules",
+        "playbooks",
+        "mesh",
+        "workingEnvironment",
+        "repl"
+      ].filter((field) => typeof definition[field] === "function")
+    }))
+  };
+}
+
+export {
+  FOUNDRY_APPLICATION_BRAND,
+  isFoundryApplication,
+  defineApplication,
+  EMPTY_FOUNDRY_APPLICATION,
+  bindFileIdentity,
+  fileDefinitionKey,
+  fileDefinitionLabel,
+  FOUNDRY_AGENT_DEFINITION_BRAND,
+  FOUNDRY_AGENT_BRAND,
+  FOUNDRY_EVENT_PREFIX,
+  FOUNDRY_APPLICATION_ENV,
+  FOUNDRY_AGENT_ROUTE_ENV,
+  FOUNDRY_AGENT_FILE_ENV,
+  FOUNDRY_EXECUTION_MARKER,
+  defineCall,
+  internalAgentName,
+  routeFromInternalAgentName,
+  isFoundryAgentDefinition,
+  isFoundryAgent,
+  defineAgent,
+  defineAgentFromModule,
+  defineSubagent,
+  defineRoutes,
+  FOUNDRY_SHARED_TOOL_BRAND,
+  FOUNDRY_AGENT_APPLICATION_BRAND,
+  FOUNDRY_MCP_BRAND,
+  FOUNDRY_MEMORY_BRAND,
+  install,
+  installationKey,
+  defineSharedTool,
+  defineAgentApplication,
+  defineApp,
+  defineMcp,
+  defineMemory,
+  EMPTY_CAPABILITY_REGISTRY,
+  isInboxCapableStore,
+  configureMemory,
+  mountAgentDefinitionMemory,
+  installRegistry,
+  isFoundryCapability,
+  FOUNDRY_LAYER_BRAND,
+  FOUNDRY_SUBSCRIBER_BRAND,
+  defineLayer,
+  configureLayer,
+  defineSubscriber,
+  EMPTY_NATIVE_REGISTRY,
+  mountFoundrySurfaces,
+  isFoundryLayer,
+  isFoundrySubscriber,
+  composePlaybook,
+  reconstructPlaybook,
+  FOUNDRY_PLAYBOOK_ACTION_BRAND,
+  FOUNDRY_COMPOSED_PLAYBOOK_BRAND,
+  definePlaybookAction,
+  definePlaybookSubscription,
+  reconstructPlaybookSubscription,
+  toGloveMessage,
+  toGloveRequestInput,
+  MemoryFoundryDataAdapter,
+  createAgentInstance,
+  defineAgentInstance,
+  reconstructAgentInstance,
+  normalizeAgentInstallations,
+  createConversation,
+  id,
+  FOUNDRY_SCHEDULE_BRAND,
+  defineSchedule,
+  isFoundrySchedule,
+  FOUNDRY_CORE_COMMAND_EVENT,
+  createInstalledApplicationTransmissionTools,
+  createFoundryCoreTools,
+  FOUNDRY_WORKING_ENVIRONMENT_BRAND,
+  FOUNDRY_REPL_BRAND,
+  defineWorkingEnvironment,
+  foundryDataEnvironmentPersistence,
+  defineRepl,
+  compileAgentDefinition,
+  compileAgentModule,
+  FOUNDRY_CONNECTION_BRAND,
+  defineConnection,
+  FOUNDRY_TRANSMISSION_BRAND,
+  FOUNDRY_TRANSMISSION_PREDICATE_BRAND,
+  FOUNDRY_TRANSMISSION_EVENT_BRAND,
+  isFoundryTransmission,
+  defineTransmissionPredicate,
+  defineTransmissionEvent,
+  transmissionPredicate,
+  defineTransmission,
+  bindAgentLocalDefinitions,
+  routeFromAgentFile,
+  findAgentFiles,
+  discoverAgents,
+  createManifest
+};